Urađena test aplikacija. Povezan front i back.

1 files changed, 339 insertions, 0 deletions

diff --git a/sandbox/testAppNevena/Front/node_modules/@angular/cli/commands/add-impl.js b/sandbox/testAppNevena/Front/node_modules/@angular/cli/commands/add-impl.js
new file mode 100644
index 00000000..aa9f5e05
--- /dev/null
+++ b/sandbox/testAppNevena/Front/node_modules/@angular/cli/commands/add-impl.js
@@ -0,0 +1,339 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddCommand = void 0;
+const core_1 = require("@angular-devkit/core");
+const tools_1 = require("@angular-devkit/schematics/tools");
+const npm_package_arg_1 = __importDefault(require("npm-package-arg"));
+const path_1 = require("path");
+const semver_1 = require("semver");
+const workspace_schema_1 = require("../lib/config/workspace-schema");
+const analytics_1 = require("../models/analytics");
+const schematic_command_1 = require("../models/schematic-command");
+const color_1 = require("../utilities/color");
+const install_package_1 = require("../utilities/install-package");
+const package_manager_1 = require("../utilities/package-manager");
+const package_metadata_1 = require("../utilities/package-metadata");
+const prompt_1 = require("../utilities/prompt");
+const spinner_1 = require("../utilities/spinner");
+const tty_1 = require("../utilities/tty");
+/**
+ * The set of packages that should have certain versions excluded from consideration
+ * when attempting to find a compatible version for a package.
+ * The key is a package name and the value is a SemVer range of versions to exclude.
+ */
+const packageVersionExclusions = {
+    // @angular/localize@9.x versions do not have peer dependencies setup
+    '@angular/localize': '9.x',
+};
+class AddCommand extends schematic_command_1.SchematicCommand {
+    constructor() {
+        super(...arguments);
+        this.allowPrivateSchematics = true;
+    }
+    async initialize(options) {
+        if (options.registry) {
+            return super.initialize({ ...options, packageRegistry: options.registry });
+        }
+        else {
+            return super.initialize(options);
+        }
+    }
+    // eslint-disable-next-line max-lines-per-function
+    async run(options) {
+        var _a;
+        await (0, package_manager_1.ensureCompatibleNpm)(this.context.root);
+        if (!options.collection) {
+            this.logger.fatal(`The "ng add" command requires a name argument to be specified eg. ` +
+                `${color_1.colors.yellow('ng add [name] ')}. For more details, use "ng help".`);
+            return 1;
+        }
+        let packageIdentifier;
+        try {
+            packageIdentifier = (0, npm_package_arg_1.default)(options.collection);
+        }
+        catch (e) {
+            this.logger.error(e.message);
+            return 1;
+        }
+        if (packageIdentifier.name &&
+            packageIdentifier.registry &&
+            this.isPackageInstalled(packageIdentifier.name)) {
+            const validVersion = await this.isProjectVersionValid(packageIdentifier);
+            if (validVersion) {
+                // Already installed so just run schematic
+                this.logger.info('Skipping installation: Package already installed');
+                return this.executeSchematic(packageIdentifier.name, options['--']);
+            }
+        }
+        const spinner = new spinner_1.Spinner();
+        spinner.start('Determining package manager...');
+        const packageManager = await (0, package_manager_1.getPackageManager)(this.context.root);
+        const usingYarn = packageManager === workspace_schema_1.PackageManager.Yarn;
+        spinner.info(`Using package manager: ${color_1.colors.grey(packageManager)}`);
+        if (packageIdentifier.name && packageIdentifier.type === 'tag' && !packageIdentifier.rawSpec) {
+            // only package name provided; search for viable version
+            // plus special cases for packages that did not have peer deps setup
+            spinner.start('Searching for compatible package version...');
+            let packageMetadata;
+            try {
+                packageMetadata = await (0, package_metadata_1.fetchPackageMetadata)(packageIdentifier.name, this.logger, {
+                    registry: options.registry,
+                    usingYarn,
+                    verbose: options.verbose,
+                });
+            }
+            catch (e) {
+                spinner.fail('Unable to load package information from registry: ' + e.message);
+                return 1;
+            }
+            // Start with the version tagged as `latest` if it exists
+            const latestManifest = packageMetadata.tags['latest'];
+            if (latestManifest) {
+                packageIdentifier = npm_package_arg_1.default.resolve(latestManifest.name, latestManifest.version);
+            }
+            // Adjust the version based on name and peer dependencies
+            if (latestManifest && Object.keys(latestManifest.peerDependencies).length === 0) {
+                if (latestManifest.name === '@angular/pwa') {
+                    const version = await this.findProjectVersion('@angular/cli');
+                    const semverOptions = { includePrerelease: true };
+                    if (version &&
+                        (((0, semver_1.validRange)(version) && (0, semver_1.intersects)(version, '7', semverOptions)) ||
+                            ((0, semver_1.valid)(version) && (0, semver_1.satisfies)(version, '7', semverOptions)))) {
+                        packageIdentifier = npm_package_arg_1.default.resolve('@angular/pwa', '0.12');
+                    }
+                }
+                spinner.succeed(`Found compatible package version: ${color_1.colors.grey(packageIdentifier.toString())}.`);
+            }
+            else if (!latestManifest || (await this.hasMismatchedPeer(latestManifest))) {
+                // 'latest' is invalid so search for most recent matching package
+                const versionExclusions = packageVersionExclusions[packageMetadata.name];
+                const versionManifests = Object.values(packageMetadata.versions).filter((value) => {
+                    // Prerelease versions are not stable and should not be considered by default
+                    if ((0, semver_1.prerelease)(value.version)) {
+                        return false;
+                    }
+                    // Deprecated versions should not be used or considered
+                    if (value.deprecated) {
+                        return false;
+                    }
+                    // Excluded package versions should not be considered
+                    if (versionExclusions && (0, semver_1.satisfies)(value.version, versionExclusions)) {
+                        return false;
+                    }
+                    return true;
+                });
+                versionManifests.sort((a, b) => (0, semver_1.rcompare)(a.version, b.version, true));
+                let newIdentifier;
+                for (const versionManifest of versionManifests) {
+                    if (!(await this.hasMismatchedPeer(versionManifest))) {
+                        newIdentifier = npm_package_arg_1.default.resolve(versionManifest.name, versionManifest.version);
+                        break;
+                    }
+                }
+                if (!newIdentifier) {
+                    spinner.warn("Unable to find compatible package. Using 'latest' tag.");
+                }
+                else {
+                    packageIdentifier = newIdentifier;
+                    spinner.succeed(`Found compatible package version: ${color_1.colors.grey(packageIdentifier.toString())}.`);
+                }
+            }
+            else {
+                spinner.succeed(`Found compatible package version: ${color_1.colors.grey(packageIdentifier.toString())}.`);
+            }
+        }
+        let collectionName = packageIdentifier.name;
+        let savePackage;
+        try {
+            spinner.start('Loading package information from registry...');
+            const manifest = await (0, package_metadata_1.fetchPackageManifest)(packageIdentifier.toString(), this.logger, {
+                registry: options.registry,
+                verbose: options.verbose,
+                usingYarn,
+            });
+            savePackage = (_a = manifest['ng-add']) === null || _a === void 0 ? void 0 : _a.save;
+            collectionName = manifest.name;
+            if (await this.hasMismatchedPeer(manifest)) {
+                spinner.warn('Package has unmet peer dependencies. Adding the package may not succeed.');
+            }
+            else {
+                spinner.succeed(`Package information loaded.`);
+            }
+        }
+        catch (e) {
+            spinner.fail(`Unable to fetch package information for '${packageIdentifier}': ${e.message}`);
+            return 1;
+        }
+        if (!options.skipConfirmation) {
+            const confirmationResponse = await (0, prompt_1.askConfirmation)(`\nThe package ${color_1.colors.blue(packageIdentifier.raw)} will be installed and executed.\n` +
+                'Would you like to proceed?', true, false);
+            if (!confirmationResponse) {
+                if (!(0, tty_1.isTTY)()) {
+                    this.logger.error('No terminal detected. ' +
+                        `'--skip-confirmation' can be used to bypass installation confirmation. ` +
+                        `Ensure package name is correct prior to '--skip-confirmation' option usage.`);
+                }
+                this.logger.error('Command aborted.');
+                return 1;
+            }
+        }
+        if (savePackage === false) {
+            // Temporary packages are located in a different directory
+            // Hence we need to resolve them using the temp path
+            const { status, tempNodeModules } = await (0, install_package_1.installTempPackage)(packageIdentifier.raw, packageManager, options.registry ? [`--registry="${options.registry}"`] : undefined);
+            const resolvedCollectionPath = require.resolve((0, path_1.join)(collectionName, 'package.json'), {
+                paths: [tempNodeModules],
+            });
+            if (status !== 0) {
+                return status;
+            }
+            collectionName = (0, path_1.dirname)(resolvedCollectionPath);
+        }
+        else {
+            const status = await (0, install_package_1.installPackage)(packageIdentifier.raw, packageManager, savePackage, options.registry ? [`--registry="${options.registry}"`] : undefined);
+            if (status !== 0) {
+                return status;
+            }
+        }
+        return this.executeSchematic(collectionName, options['--']);
+    }
+    async isProjectVersionValid(packageIdentifier) {
+        if (!packageIdentifier.name) {
+            return false;
+        }
+        let validVersion = false;
+        const installedVersion = await this.findProjectVersion(packageIdentifier.name);
+        if (installedVersion) {
+            if (packageIdentifier.type === 'range' && packageIdentifier.fetchSpec) {
+                validVersion = (0, semver_1.satisfies)(installedVersion, packageIdentifier.fetchSpec);
+            }
+            else if (packageIdentifier.type === 'version') {
+                const v1 = (0, semver_1.valid)(packageIdentifier.fetchSpec);
+                const v2 = (0, semver_1.valid)(installedVersion);
+                validVersion = v1 !== null && v1 === v2;
+            }
+            else if (!packageIdentifier.rawSpec) {
+                validVersion = true;
+            }
+        }
+        return validVersion;
+    }
+    async reportAnalytics(paths, options, dimensions = [], metrics = []) {
+        const collection = options.collection;
+        // Add the collection if it's safe listed.
+        if (collection && (0, analytics_1.isPackageNameSafeForAnalytics)(collection)) {
+            dimensions[core_1.analytics.NgCliAnalyticsDimensions.NgAddCollection] = collection;
+        }
+        else {
+            delete dimensions[core_1.analytics.NgCliAnalyticsDimensions.NgAddCollection];
+        }
+        return super.reportAnalytics(paths, options, dimensions, metrics);
+    }
+    isPackageInstalled(name) {
+        try {
+            require.resolve((0, path_1.join)(name, 'package.json'), { paths: [this.context.root] });
+            return true;
+        }
+        catch (e) {
+            if (e.code !== 'MODULE_NOT_FOUND') {
+                throw e;
+            }
+        }
+        return false;
+    }
+    async executeSchematic(collectionName, options = []) {
+        const runOptions = {
+            schematicOptions: options,
+            collectionName,
+            schematicName: 'ng-add',
+            dryRun: false,
+            force: false,
+        };
+        try {
+            return await this.runSchematic(runOptions);
+        }
+        catch (e) {
+            if (e instanceof tools_1.NodePackageDoesNotSupportSchematics) {
+                this.logger.error(core_1.tags.oneLine `
+          The package that you are trying to add does not support schematics. You can try using
+          a different version of the package or contact the package author to add ng-add support.
+        `);
+                return 1;
+            }
+            throw e;
+        }
+    }
+    async findProjectVersion(name) {
+        let installedPackage;
+        try {
+            installedPackage = require.resolve((0, path_1.join)(name, 'package.json'), {
+                paths: [this.context.root],
+            });
+        }
+        catch { }
+        if (installedPackage) {
+            try {
+                const installed = await (0, package_metadata_1.fetchPackageManifest)((0, path_1.dirname)(installedPackage), this.logger);
+                return installed.version;
+            }
+            catch { }
+        }
+        let projectManifest;
+        try {
+            projectManifest = await (0, package_metadata_1.fetchPackageManifest)(this.context.root, this.logger);
+        }
+        catch { }
+        if (projectManifest) {
+            const version = projectManifest.dependencies[name] || projectManifest.devDependencies[name];
+            if (version) {
+                return version;
+            }
+        }
+        return null;
+    }
+    async hasMismatchedPeer(manifest) {
+        for (const peer in manifest.peerDependencies) {
+            let peerIdentifier;
+            try {
+                peerIdentifier = npm_package_arg_1.default.resolve(peer, manifest.peerDependencies[peer]);
+            }
+            catch {
+                this.logger.warn(`Invalid peer dependency ${peer} found in package.`);
+                continue;
+            }
+            if (peerIdentifier.type === 'version' || peerIdentifier.type === 'range') {
+                try {
+                    const version = await this.findProjectVersion(peer);
+                    if (!version) {
+                        continue;
+                    }
+                    const options = { includePrerelease: true };
+                    if (!(0, semver_1.intersects)(version, peerIdentifier.rawSpec, options) &&
+                        !(0, semver_1.satisfies)(version, peerIdentifier.rawSpec, options)) {
+                        return true;
+                    }
+                }
+                catch {
+                    // Not found or invalid so ignore
+                    continue;
+                }
+            }
+            else {
+                // type === 'tag' | 'file' | 'directory' | 'remote' | 'git'
+                // Cannot accurately compare these as the tag/location may have changed since install
+            }
+        }
+        return false;
+    }
+}
+exports.AddCommand = AddCommand;