From 291803c31f829fe0d32bb3207bc11def95a7408c Mon Sep 17 00:00:00 2001 From: Nevena Bojovic Date: Tue, 1 Mar 2022 20:05:50 +0100 Subject: Urađena test aplikacija. Povezan front i back. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../node_modules/@angular/cli/utilities/config.js | 410 +++++++++++++++++++++ 1 file changed, 410 insertions(+) create mode 100644 sandbox/testAppNevena/Front/node_modules/@angular/cli/utilities/config.js (limited to 'sandbox/testAppNevena/Front/node_modules/@angular/cli/utilities/config.js') diff --git a/sandbox/testAppNevena/Front/node_modules/@angular/cli/utilities/config.js b/sandbox/testAppNevena/Front/node_modules/@angular/cli/utilities/config.js new file mode 100644 index 00000000..bbc692f7 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/@angular/cli/utilities/config.js @@ -0,0 +1,410 @@ +"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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isWarningEnabled = exports.getSchematicDefaults = exports.migrateLegacyGlobalConfig = exports.getConfiguredPackageManager = exports.getProjectByCwd = exports.validateWorkspace = exports.getWorkspaceRaw = exports.createGlobalSettings = exports.getWorkspace = exports.AngularWorkspace = exports.workspaceSchemaPath = void 0; +const core_1 = require("@angular-devkit/core"); +const fs_1 = require("fs"); +const os = __importStar(require("os")); +const path = __importStar(require("path")); +const find_up_1 = require("./find-up"); +const json_file_1 = require("./json-file"); +function isJsonObject(value) { + return value !== undefined && core_1.json.isJsonObject(value); +} +function createWorkspaceHost() { + return { + async readFile(path) { + return (0, fs_1.readFileSync)(path, 'utf-8'); + }, + async writeFile(path, data) { + (0, fs_1.writeFileSync)(path, data); + }, + async isDirectory(path) { + try { + return (0, fs_1.statSync)(path).isDirectory(); + } + catch { + return false; + } + }, + async isFile(path) { + try { + return (0, fs_1.statSync)(path).isFile(); + } + catch { + return false; + } + }, + }; +} +function getSchemaLocation() { + return path.join(__dirname, '../lib/config/schema.json'); +} +exports.workspaceSchemaPath = getSchemaLocation(); +const configNames = ['angular.json', '.angular.json']; +const globalFileName = '.angular-config.json'; +function xdgConfigHome(home, configFile) { + // https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html + const xdgConfigHome = process.env['XDG_CONFIG_HOME'] || path.join(home, '.config'); + const xdgAngularHome = path.join(xdgConfigHome, 'angular'); + return configFile ? path.join(xdgAngularHome, configFile) : xdgAngularHome; +} +function xdgConfigHomeOld(home) { + // Check the configuration files in the old location that should be: + // - $XDG_CONFIG_HOME/.angular-config.json (if XDG_CONFIG_HOME is set) + // - $HOME/.config/angular/.angular-config.json (otherwise) + const p = process.env['XDG_CONFIG_HOME'] || path.join(home, '.config', 'angular'); + return path.join(p, '.angular-config.json'); +} +function projectFilePath(projectPath) { + // Find the configuration, either where specified, in the Angular CLI project + // (if it's in node_modules) or from the current process. + return ((projectPath && (0, find_up_1.findUp)(configNames, projectPath)) || + (0, find_up_1.findUp)(configNames, process.cwd()) || + (0, find_up_1.findUp)(configNames, __dirname)); +} +function globalFilePath() { + const home = os.homedir(); + if (!home) { + return null; + } + // follow XDG Base Directory spec + // note that createGlobalSettings() will continue creating + // global file in home directory, with this user will have + // choice to move change its location to meet XDG convention + const xdgConfig = xdgConfigHome(home, 'config.json'); + if ((0, fs_1.existsSync)(xdgConfig)) { + return xdgConfig; + } + // NOTE: This check is for the old configuration location, for more + // information see https://github.com/angular/angular-cli/pull/20556 + const xdgConfigOld = xdgConfigHomeOld(home); + if ((0, fs_1.existsSync)(xdgConfigOld)) { + /* eslint-disable no-console */ + console.warn(`Old configuration location detected: ${xdgConfigOld}\n` + + `Please move the file to the new location ~/.config/angular/config.json`); + return xdgConfigOld; + } + const p = path.join(home, globalFileName); + if ((0, fs_1.existsSync)(p)) { + return p; + } + return null; +} +class AngularWorkspace { + constructor(workspace, filePath) { + this.workspace = workspace; + this.filePath = filePath; + this.basePath = path.dirname(filePath); + } + get extensions() { + return this.workspace.extensions; + } + get projects() { + return this.workspace.projects; + } + // Temporary helper functions to support refactoring + // eslint-disable-next-line @typescript-eslint/no-explicit-any + getCli() { + return this.workspace.extensions['cli'] || {}; + } + // eslint-disable-next-line @typescript-eslint/no-explicit-any + getProjectCli(projectName) { + const project = this.workspace.projects.get(projectName); + return (project === null || project === void 0 ? void 0 : project.extensions['cli']) || {}; + } + static async load(workspaceFilePath) { + const oldConfigFileNames = ['.angular-cli.json', 'angular-cli.json']; + if (oldConfigFileNames.includes(path.basename(workspaceFilePath))) { + // 1.x file format + // Create an empty workspace to allow update to be used + return new AngularWorkspace({ extensions: {}, projects: new core_1.workspaces.ProjectDefinitionCollection() }, workspaceFilePath); + } + const result = await core_1.workspaces.readWorkspace(workspaceFilePath, createWorkspaceHost(), core_1.workspaces.WorkspaceFormat.JSON); + return new AngularWorkspace(result.workspace, workspaceFilePath); + } +} +exports.AngularWorkspace = AngularWorkspace; +const cachedWorkspaces = new Map(); +async function getWorkspace(level = 'local') { + const cached = cachedWorkspaces.get(level); + if (cached !== undefined) { + return cached; + } + const configPath = level === 'local' ? projectFilePath() : globalFilePath(); + if (!configPath) { + cachedWorkspaces.set(level, null); + return null; + } + try { + const workspace = await AngularWorkspace.load(configPath); + cachedWorkspaces.set(level, workspace); + return workspace; + } + catch (error) { + throw new Error(`Workspace config file cannot be loaded: ${configPath}` + + `\n${error instanceof Error ? error.message : error}`); + } +} +exports.getWorkspace = getWorkspace; +function createGlobalSettings() { + const home = os.homedir(); + if (!home) { + throw new Error('No home directory found.'); + } + const globalPath = path.join(home, globalFileName); + (0, fs_1.writeFileSync)(globalPath, JSON.stringify({ version: 1 })); + return globalPath; +} +exports.createGlobalSettings = createGlobalSettings; +function getWorkspaceRaw(level = 'local') { + let configPath = level === 'local' ? projectFilePath() : globalFilePath(); + if (!configPath) { + if (level === 'global') { + configPath = createGlobalSettings(); + } + else { + return [null, null]; + } + } + return [new json_file_1.JSONFile(configPath), configPath]; +} +exports.getWorkspaceRaw = getWorkspaceRaw; +async function validateWorkspace(data) { + const schema = (0, json_file_1.readAndParseJson)(path.join(__dirname, '../lib/config/schema.json')); + const { formats } = await Promise.resolve().then(() => __importStar(require('@angular-devkit/schematics'))); + const registry = new core_1.json.schema.CoreSchemaRegistry(formats.standardFormats); + const validator = await registry.compile(schema).toPromise(); + const { success, errors } = await validator(data).toPromise(); + if (!success) { + throw new core_1.json.schema.SchemaValidationException(errors); + } +} +exports.validateWorkspace = validateWorkspace; +function findProjectByPath(workspace, location) { + const isInside = (base, potential) => { + const absoluteBase = path.resolve(workspace.basePath, base); + const absolutePotential = path.resolve(workspace.basePath, potential); + const relativePotential = path.relative(absoluteBase, absolutePotential); + if (!relativePotential.startsWith('..') && !path.isAbsolute(relativePotential)) { + return true; + } + return false; + }; + const projects = Array.from(workspace.projects) + .map(([name, project]) => [project.root, name]) + .filter((tuple) => isInside(tuple[0], location)) + // Sort tuples by depth, with the deeper ones first. Since the first member is a path and + // we filtered all invalid paths, the longest will be the deepest (and in case of equality + // the sort is stable and the first declared project will win). + .sort((a, b) => b[0].length - a[0].length); + if (projects.length === 0) { + return null; + } + else if (projects.length > 1) { + const found = new Set(); + const sameRoots = projects.filter((v) => { + if (!found.has(v[0])) { + found.add(v[0]); + return false; + } + return true; + }); + if (sameRoots.length > 0) { + // Ambiguous location - cannot determine a project + return null; + } + } + return projects[0][1]; +} +function getProjectByCwd(workspace) { + if (workspace.projects.size === 1) { + // If there is only one project, return that one. + return Array.from(workspace.projects.keys())[0]; + } + const project = findProjectByPath(workspace, process.cwd()); + if (project) { + return project; + } + const defaultProject = workspace.extensions['defaultProject']; + if (defaultProject && typeof defaultProject === 'string') { + // If there is a default project name, return it. + return defaultProject; + } + return null; +} +exports.getProjectByCwd = getProjectByCwd; +async function getConfiguredPackageManager() { + var _a; + const getPackageManager = (source) => { + if (isJsonObject(source)) { + const value = source['packageManager']; + if (value && typeof value === 'string') { + return value; + } + } + }; + let result; + const workspace = await getWorkspace('local'); + if (workspace) { + const project = getProjectByCwd(workspace); + if (project) { + result = getPackageManager((_a = workspace.projects.get(project)) === null || _a === void 0 ? void 0 : _a.extensions['cli']); + } + result = result !== null && result !== void 0 ? result : getPackageManager(workspace.extensions['cli']); + } + if (result === undefined) { + const globalOptions = await getWorkspace('global'); + result = getPackageManager(globalOptions === null || globalOptions === void 0 ? void 0 : globalOptions.extensions['cli']); + if (!workspace && !globalOptions) { + // Only check legacy if updated workspace is not found + result = getLegacyPackageManager(); + } + } + // Default to null + return result !== null && result !== void 0 ? result : null; +} +exports.getConfiguredPackageManager = getConfiguredPackageManager; +function migrateLegacyGlobalConfig() { + const homeDir = os.homedir(); + if (homeDir) { + const legacyGlobalConfigPath = path.join(homeDir, '.angular-cli.json'); + if ((0, fs_1.existsSync)(legacyGlobalConfigPath)) { + const legacy = (0, json_file_1.readAndParseJson)(legacyGlobalConfigPath); + if (!isJsonObject(legacy)) { + return false; + } + const cli = {}; + if (legacy.packageManager && + typeof legacy.packageManager == 'string' && + legacy.packageManager !== 'default') { + cli['packageManager'] = legacy.packageManager; + } + if (isJsonObject(legacy.defaults) && + isJsonObject(legacy.defaults.schematics) && + typeof legacy.defaults.schematics.collection == 'string') { + cli['defaultCollection'] = legacy.defaults.schematics.collection; + } + if (isJsonObject(legacy.warnings)) { + const warnings = {}; + if (typeof legacy.warnings.versionMismatch == 'boolean') { + warnings['versionMismatch'] = legacy.warnings.versionMismatch; + } + if (Object.getOwnPropertyNames(warnings).length > 0) { + cli['warnings'] = warnings; + } + } + if (Object.getOwnPropertyNames(cli).length > 0) { + const globalPath = path.join(homeDir, globalFileName); + (0, fs_1.writeFileSync)(globalPath, JSON.stringify({ version: 1, cli }, null, 2)); + return true; + } + } + } + return false; +} +exports.migrateLegacyGlobalConfig = migrateLegacyGlobalConfig; +// Fallback, check for packageManager in config file in v1.* global config. +function getLegacyPackageManager() { + const homeDir = os.homedir(); + if (homeDir) { + const legacyGlobalConfigPath = path.join(homeDir, '.angular-cli.json'); + if ((0, fs_1.existsSync)(legacyGlobalConfigPath)) { + const legacy = (0, json_file_1.readAndParseJson)(legacyGlobalConfigPath); + if (!isJsonObject(legacy)) { + return null; + } + if (legacy.packageManager && + typeof legacy.packageManager === 'string' && + legacy.packageManager !== 'default') { + return legacy.packageManager; + } + } + } + return null; +} +async function getSchematicDefaults(collection, schematic, project) { + var _a; + const result = {}; + const mergeOptions = (source) => { + if (isJsonObject(source)) { + // Merge options from the qualified name + Object.assign(result, source[`${collection}:${schematic}`]); + // Merge options from nested collection schematics + const collectionOptions = source[collection]; + if (isJsonObject(collectionOptions)) { + Object.assign(result, collectionOptions[schematic]); + } + } + }; + // Global level schematic options + const globalOptions = await getWorkspace('global'); + mergeOptions(globalOptions === null || globalOptions === void 0 ? void 0 : globalOptions.extensions['schematics']); + const workspace = await getWorkspace('local'); + if (workspace) { + // Workspace level schematic options + mergeOptions(workspace.extensions['schematics']); + project = project || getProjectByCwd(workspace); + if (project) { + // Project level schematic options + mergeOptions((_a = workspace.projects.get(project)) === null || _a === void 0 ? void 0 : _a.extensions['schematics']); + } + } + return result; +} +exports.getSchematicDefaults = getSchematicDefaults; +async function isWarningEnabled(warning) { + var _a; + const getWarning = (source) => { + if (isJsonObject(source)) { + const warnings = source['warnings']; + if (isJsonObject(warnings)) { + const value = warnings[warning]; + if (typeof value == 'boolean') { + return value; + } + } + } + }; + let result; + const workspace = await getWorkspace('local'); + if (workspace) { + const project = getProjectByCwd(workspace); + if (project) { + result = getWarning((_a = workspace.projects.get(project)) === null || _a === void 0 ? void 0 : _a.extensions['cli']); + } + result = result !== null && result !== void 0 ? result : getWarning(workspace.extensions['cli']); + } + if (result === undefined) { + const globalOptions = await getWorkspace('global'); + result = getWarning(globalOptions === null || globalOptions === void 0 ? void 0 : globalOptions.extensions['cli']); + } + // All warnings are enabled by default + return result !== null && result !== void 0 ? result : true; +} +exports.isWarningEnabled = isWarningEnabled; -- cgit v1.2.3