diff options
Diffstat (limited to 'sandbox/testAppNevena/Front/node_modules/@angular/cli/utilities/json-schema.js')
| -rw-r--r-- | sandbox/testAppNevena/Front/node_modules/@angular/cli/utilities/json-schema.js | 245 |
1 files changed, 245 insertions, 0 deletions
diff --git a/sandbox/testAppNevena/Front/node_modules/@angular/cli/utilities/json-schema.js b/sandbox/testAppNevena/Front/node_modules/@angular/cli/utilities/json-schema.js new file mode 100644 index 00000000..bd24ee1e --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/@angular/cli/utilities/json-schema.js @@ -0,0 +1,245 @@ +"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 + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parseJsonSchemaToOptions = exports.parseJsonSchemaToCommandDescription = exports.parseJsonSchemaToSubCommandDescription = exports.CommandJsonPathException = void 0; +const core_1 = require("@angular-devkit/core"); +const tools_1 = require("@angular-devkit/schematics/tools"); +const fs_1 = require("fs"); +const path_1 = require("path"); +const interface_1 = require("../models/interface"); +class CommandJsonPathException extends core_1.BaseException { + constructor(path, name) { + super(`File ${path} was not found while constructing the subcommand ${name}.`); + this.path = path; + this.name = name; + } +} +exports.CommandJsonPathException = CommandJsonPathException; +function _getEnumFromValue(value, enumeration, defaultValue) { + if (typeof value !== 'string') { + return defaultValue; + } + if (Object.values(enumeration).includes(value)) { + return value; + } + return defaultValue; +} +async function parseJsonSchemaToSubCommandDescription(name, jsonPath, registry, schema) { + const options = await parseJsonSchemaToOptions(registry, schema); + const aliases = []; + if (core_1.json.isJsonArray(schema.$aliases)) { + schema.$aliases.forEach((value) => { + if (typeof value == 'string') { + aliases.push(value); + } + }); + } + if (core_1.json.isJsonArray(schema.aliases)) { + schema.aliases.forEach((value) => { + if (typeof value == 'string') { + aliases.push(value); + } + }); + } + if (typeof schema.alias == 'string') { + aliases.push(schema.alias); + } + let longDescription = ''; + if (typeof schema.$longDescription == 'string' && schema.$longDescription) { + const ldPath = (0, path_1.resolve)((0, path_1.dirname)(jsonPath), schema.$longDescription); + try { + longDescription = (0, fs_1.readFileSync)(ldPath, 'utf-8'); + } + catch (e) { + throw new CommandJsonPathException(ldPath, name); + } + } + let usageNotes = ''; + if (typeof schema.$usageNotes == 'string' && schema.$usageNotes) { + const unPath = (0, path_1.resolve)((0, path_1.dirname)(jsonPath), schema.$usageNotes); + try { + usageNotes = (0, fs_1.readFileSync)(unPath, 'utf-8'); + } + catch (e) { + throw new CommandJsonPathException(unPath, name); + } + } + const description = '' + (schema.description === undefined ? '' : schema.description); + return { + name, + description, + ...(longDescription ? { longDescription } : {}), + ...(usageNotes ? { usageNotes } : {}), + options, + aliases, + }; +} +exports.parseJsonSchemaToSubCommandDescription = parseJsonSchemaToSubCommandDescription; +async function parseJsonSchemaToCommandDescription(name, jsonPath, registry, schema) { + const subcommand = await parseJsonSchemaToSubCommandDescription(name, jsonPath, registry, schema); + // Before doing any work, let's validate the implementation. + if (typeof schema.$impl != 'string') { + throw new Error(`Command ${name} has an invalid implementation.`); + } + const ref = new tools_1.ExportStringRef(schema.$impl, (0, path_1.dirname)(jsonPath)); + const impl = ref.ref; + if (impl === undefined || typeof impl !== 'function') { + throw new Error(`Command ${name} has an invalid implementation.`); + } + const scope = _getEnumFromValue(schema.$scope, interface_1.CommandScope, interface_1.CommandScope.Default); + const hidden = !!schema.$hidden; + return { + ...subcommand, + scope, + hidden, + impl, + }; +} +exports.parseJsonSchemaToCommandDescription = parseJsonSchemaToCommandDescription; +async function parseJsonSchemaToOptions(registry, schema) { + const options = []; + function visitor(current, pointer, parentSchema) { + if (!parentSchema) { + // Ignore root. + return; + } + else if (pointer.split(/\/(?:properties|items|definitions)\//g).length > 2) { + // Ignore subitems (objects or arrays). + return; + } + else if (core_1.json.isJsonArray(current)) { + return; + } + if (pointer.indexOf('/not/') != -1) { + // We don't support anyOf/not. + throw new Error('The "not" keyword is not supported in JSON Schema.'); + } + const ptr = core_1.json.schema.parseJsonPointer(pointer); + const name = ptr[ptr.length - 1]; + if (ptr[ptr.length - 2] != 'properties') { + // Skip any non-property items. + return; + } + const typeSet = core_1.json.schema.getTypesOfSchema(current); + if (typeSet.size == 0) { + throw new Error('Cannot find type of schema.'); + } + // We only support number, string or boolean (or array of those), so remove everything else. + const types = [...typeSet] + .filter((x) => { + switch (x) { + case 'boolean': + case 'number': + case 'string': + return true; + case 'array': + // Only include arrays if they're boolean, string or number. + if (core_1.json.isJsonObject(current.items) && + typeof current.items.type == 'string' && + ['boolean', 'number', 'string'].includes(current.items.type)) { + return true; + } + return false; + default: + return false; + } + }) + .map((x) => _getEnumFromValue(x, interface_1.OptionType, interface_1.OptionType.String)); + if (types.length == 0) { + // This means it's not usable on the command line. e.g. an Object. + return; + } + // Only keep enum values we support (booleans, numbers and strings). + const enumValues = ((core_1.json.isJsonArray(current.enum) && current.enum) || []).filter((x) => { + switch (typeof x) { + case 'boolean': + case 'number': + case 'string': + return true; + default: + return false; + } + }); + let defaultValue = undefined; + if (current.default !== undefined) { + switch (types[0]) { + case 'string': + if (typeof current.default == 'string') { + defaultValue = current.default; + } + break; + case 'number': + if (typeof current.default == 'number') { + defaultValue = current.default; + } + break; + case 'boolean': + if (typeof current.default == 'boolean') { + defaultValue = current.default; + } + break; + } + } + const type = types[0]; + const $default = current.$default; + const $defaultIndex = core_1.json.isJsonObject($default) && $default['$source'] == 'argv' ? $default['index'] : undefined; + const positional = typeof $defaultIndex == 'number' ? $defaultIndex : undefined; + const required = core_1.json.isJsonArray(current.required) + ? current.required.indexOf(name) != -1 + : false; + const aliases = core_1.json.isJsonArray(current.aliases) + ? [...current.aliases].map((x) => '' + x) + : current.alias + ? ['' + current.alias] + : []; + const format = typeof current.format == 'string' ? current.format : undefined; + const visible = current.visible === undefined || current.visible === true; + const hidden = !!current.hidden || !visible; + const xUserAnalytics = current['x-user-analytics']; + const userAnalytics = typeof xUserAnalytics == 'number' ? xUserAnalytics : undefined; + // Deprecated is set only if it's true or a string. + const xDeprecated = current['x-deprecated']; + const deprecated = xDeprecated === true || typeof xDeprecated === 'string' ? xDeprecated : undefined; + const option = { + name, + description: '' + (current.description === undefined ? '' : current.description), + ...(types.length == 1 ? { type } : { type, types }), + ...(defaultValue !== undefined ? { default: defaultValue } : {}), + ...(enumValues && enumValues.length > 0 ? { enum: enumValues } : {}), + required, + aliases, + ...(format !== undefined ? { format } : {}), + hidden, + ...(userAnalytics ? { userAnalytics } : {}), + ...(deprecated !== undefined ? { deprecated } : {}), + ...(positional !== undefined ? { positional } : {}), + }; + options.push(option); + } + const flattenedSchema = await registry.flatten(schema).toPromise(); + core_1.json.schema.visitJsonSchema(flattenedSchema, visitor); + // Sort by positional. + return options.sort((a, b) => { + if (a.positional) { + if (b.positional) { + return a.positional - b.positional; + } + else { + return 1; + } + } + else if (b.positional) { + return -1; + } + else { + return 0; + } + }); +} +exports.parseJsonSchemaToOptions = parseJsonSchemaToOptions; |