Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
package.src.utilities.config.js Maven / Gradle / Ivy
"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.dev/license
*/
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (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.AngularWorkspace = exports.workspaceSchemaPath = void 0;
exports.getWorkspace = getWorkspace;
exports.getWorkspaceRaw = getWorkspaceRaw;
exports.validateWorkspace = validateWorkspace;
exports.getProjectByCwd = getProjectByCwd;
exports.getConfiguredPackageManager = getConfiguredPackageManager;
exports.getSchematicDefaults = getSchematicDefaults;
exports.isWarningEnabled = isWarningEnabled;
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 {
readFile(path) {
return fs_1.promises.readFile(path, 'utf-8');
},
async writeFile(path, data) {
await fs_1.promises.writeFile(path, data);
},
async isDirectory(path) {
try {
const stats = await fs_1.promises.stat(path);
return stats.isDirectory();
}
catch {
return false;
}
},
async isFile(path) {
try {
const stats = await fs_1.promises.stat(path);
return stats.isFile();
}
catch {
return false;
}
},
};
}
exports.workspaceSchemaPath = path.join(__dirname, '../../lib/config/schema.json');
const configNames = ['angular.json', '.angular.json'];
const globalFileName = '.angular-config.json';
const defaultGlobalFilePath = path.join(os.homedir(), globalFileName);
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;
}
if ((0, fs_1.existsSync)(defaultGlobalFilePath)) {
return defaultGlobalFilePath;
}
return null;
}
class AngularWorkspace {
workspace;
filePath;
basePath;
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?.extensions['cli'];
}
save() {
return core_1.workspaces.writeWorkspace(this.workspace, createWorkspaceHost(), this.filePath, core_1.workspaces.WorkspaceFormat.JSON);
}
static async load(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) {
if (cachedWorkspaces.has(level)) {
return cachedWorkspaces.get(level);
}
const configPath = level === 'local' ? projectFilePath() : globalFilePath();
if (!configPath) {
if (level === 'global') {
// Unlike a local config, a global config is not mandatory.
// So we create an empty one in memory and keep it as such until it has been modified and saved.
const globalWorkspace = new AngularWorkspace({ extensions: {}, projects: new core_1.workspaces.ProjectDefinitionCollection() }, defaultGlobalFilePath);
cachedWorkspaces.set(level, globalWorkspace);
return globalWorkspace;
}
cachedWorkspaces.set(level, undefined);
return undefined;
}
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}`);
}
}
/**
* This method will load the workspace configuration in raw JSON format.
* When `level` is `global` and file doesn't exists, it will be created.
*
* NB: This method is intended to be used only for `ng config`.
*/
async function getWorkspaceRaw(level = 'local') {
let configPath = level === 'local' ? projectFilePath() : globalFilePath();
if (!configPath) {
if (level === 'global') {
configPath = defaultGlobalFilePath;
// Config doesn't exist, force create it.
const globalWorkspace = await getWorkspace('global');
await globalWorkspace.save();
}
else {
return [null, null];
}
}
return [new json_file_1.JSONFile(configPath), configPath];
}
async function validateWorkspace(data, isGlobal) {
const schema = (0, json_file_1.readAndParseJson)(exports.workspaceSchemaPath);
// We should eventually have a dedicated global config schema and use that to validate.
const schemaToValidate = isGlobal
? {
'$ref': '#/definitions/global',
definitions: schema['definitions'],
}
: schema;
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(schemaToValidate);
const { success, errors } = await validator(data);
if (!success) {
throw new core_1.json.schema.SchemaValidationException(errors);
}
}
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;
}
return null;
}
async function getConfiguredPackageManager() {
const getPackageManager = (source) => {
if (isJsonObject(source)) {
const value = source['packageManager'];
if (value && typeof value === 'string') {
return value;
}
}
return null;
};
let result = null;
const workspace = await getWorkspace('local');
if (workspace) {
const project = getProjectByCwd(workspace);
if (project) {
result = getPackageManager(workspace.projects.get(project)?.extensions['cli']);
}
result ??= getPackageManager(workspace.extensions['cli']);
}
if (!result) {
const globalOptions = await getWorkspace('global');
result = getPackageManager(globalOptions?.extensions['cli']);
}
return result;
}
async function getSchematicDefaults(collection, schematic, project) {
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?.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(workspace.projects.get(project)?.extensions['schematics']);
}
}
return result;
}
async function isWarningEnabled(warning) {
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(workspace.projects.get(project)?.extensions['cli']);
}
result = result ?? getWarning(workspace.extensions['cli']);
}
if (result === undefined) {
const globalOptions = await getWorkspace('global');
result = getWarning(globalOptions?.extensions['cli']);
}
// All warnings are enabled by default
return result ?? true;
}
