Merge branch 'dev' of http://gitlab.pmf.kg.ac.rs/igrannonica/neuronstellar into logo

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;