@angular-devkit/core 0.0.10 → 0.0.15

package/src/json/schema/schema.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @license
+ * Copyright Google Inc. 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
+ */
+import { JsonArray, JsonObject, JsonValue } from '../interface';
+export interface JsonSchemaBase extends Partial<JsonObject> {
+    $schema?: string;
+    $id?: string;
+    id?: string;
+    title?: string;
+    description?: string;
+    readonly?: boolean;
+    $ref?: string;
+    allOf?: (JsonObject & JsonSchema)[];
+    anyOf?: (JsonObject & JsonSchema)[];
+    oneOf?: (JsonObject & JsonSchema)[];
+    definitions?: {
+        [name: string]: (JsonObject & JsonSchema);
+    };
+}
+export interface JsonSchemaString {
+    type: 'string';
+    default?: string;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: string;
+}
+export interface JsonSchemaNumberBase {
+    default?: number;
+    multipleOf?: number;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: boolean;
+    exclusiveMaximum?: boolean;
+}
+export interface JsonSchemaNumber extends JsonSchemaNumberBase {
+    type: 'number';
+}
+export interface JsonSchemaInteger extends JsonSchemaNumberBase {
+    type: 'integer';
+}
+export interface JsonSchemaBoolean {
+    type: 'boolean';
+    default?: boolean;
+}
+export interface JsonSchemaObject extends JsonSchemaBase {
+    type: 'object';
+    properties?: {
+        [name: string]: (JsonObject & JsonSchema);
+    };
+    patternProperties?: {
+        [pattern: string]: (JsonObject & JsonSchema);
+    };
+    required?: string[];
+    minProperties?: number;
+    maxProperties?: number;
+    dependencies?: {
+        [name: string]: (string & JsonSchema) | string[];
+    };
+    additionalProperties?: boolean | (JsonObject & JsonSchema);
+}
+export interface JsonSchemaArray extends JsonSchemaBase {
+    type: 'array';
+    additionalItems?: boolean | (JsonObject & JsonSchema);
+    items?: JsonArray;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+}
+export interface JsonSchemaOneOfType extends JsonSchemaBase {
+    type: JsonArray & (JsonSchemaBaseType[]);
+}
+export interface JsonSchemaAny {
+    type: undefined;
+    default?: JsonValue;
+    enum?: JsonArray;
+}
+export declare type JsonSchema = JsonSchemaString | JsonSchemaNumber | JsonSchemaInteger | JsonSchemaObject | JsonSchemaArray | JsonSchemaOneOfType | JsonSchemaAny;
+export declare type JsonSchemaBaseType = undefined | 'string' | 'number' | 'object' | 'array' | 'boolean';

package/src/json/schema/schema.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/src/json/schema/serializers/interface.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright Google Inc. 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
+ */
+import { JsonSchemaRegistry } from '../registry';
+export declare abstract class JsonSchemaSerializer<T> {
+    abstract serialize(ref: string, registry: JsonSchemaRegistry): T;
+}

package/src/json/schema/serializers/interface.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class JsonSchemaSerializer {
+}
+exports.JsonSchemaSerializer = JsonSchemaSerializer;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6Ii9Vc2Vycy9oYW5zbC9Tb3VyY2VzL2RldmtpdC8iLCJzb3VyY2VzIjpbInBhY2thZ2VzL2FuZ3VsYXJfZGV2a2l0L2NvcmUvc3JjL2pzb24vc2NoZW1hL3NlcmlhbGl6ZXJzL2ludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQVVBO0NBRUM7QUFGRCxvREFFQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cbmltcG9ydCB7IEpzb25TY2hlbWFSZWdpc3RyeSB9IGZyb20gJy4uL3JlZ2lzdHJ5JztcblxuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgSnNvblNjaGVtYVNlcmlhbGl6ZXI8VD4ge1xuICBhYnN0cmFjdCBzZXJpYWxpemUocmVmOiBzdHJpbmcsIHJlZ2lzdHJ5OiBKc29uU2NoZW1hUmVnaXN0cnkpOiBUO1xufVxuIl19

package/src/json/schema/serializers/javascript.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @license
+ * Copyright Google Inc. 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
+ */
+import { BaseException } from '../../../exception/exception';
+import { JsonSchemaRegistry } from '../registry';
+import { JsonSchema } from '../schema';
+import { JsonSchemaSerializer } from './interface';
+export declare class InvalidRangeException<T> extends BaseException {
+    constructor(name: string, value: T, comparator: string, expected: T);
+}
+export declare class InvalidValueException extends BaseException {
+    constructor(name: string, value: {}, expected: string);
+}
+export declare class InvalidSchemaException extends BaseException {
+    constructor(schema: JsonSchema);
+}
+export declare class InvalidPropertyNameException extends BaseException {
+    readonly path: string;
+    constructor(path: string);
+}
+export declare class RequiredValueMissingException extends BaseException {
+    readonly path: string;
+    constructor(path: string);
+}
+export declare const exceptions: {
+    InvalidRangeException: typeof InvalidRangeException;
+    InvalidSchemaException: typeof InvalidSchemaException;
+    InvalidValueException: typeof InvalidValueException;
+    InvalidPropertyNameException: typeof InvalidPropertyNameException;
+    RequiredValueMissingException: typeof RequiredValueMissingException;
+};
+export interface JavascriptSerializerOptions {
+    ignoreExtraProperties?: boolean;
+    allowAccessUndefinedObjects?: boolean;
+}
+export declare class JavascriptSerializer<T> extends JsonSchemaSerializer<(value: T) => T> {
+    private _options;
+    private _uniqueSet;
+    constructor(_options?: JavascriptSerializerOptions);
+    protected _unique(name: string): string;
+    serialize(ref: string, registry: JsonSchemaRegistry): (value: T) => any;
+}

package/src/json/schema/serializers/javascript.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @license
+ * Copyright Google Inc. 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
+ */
+const exception_1 = require("../../../exception/exception");
+const strings_1 = require("../../../utils/strings");
+const interface_1 = require("./interface");
+class InvalidRangeException extends exception_1.BaseException {
+    constructor(name, value, comparator, expected) {
+        super(`Property ${JSON.stringify(name)} expected a value `
+            + `${comparator} ${JSON.stringify(expected)}, received ${JSON.stringify(value)}.`);
+    }
+}
+exports.InvalidRangeException = InvalidRangeException;
+class InvalidValueException extends exception_1.BaseException {
+    constructor(name, value, expected) {
+        super(`Property ${JSON.stringify(name)} expected a value of type ${expected}, `
+            + `received ${value}.`);
+    }
+}
+exports.InvalidValueException = InvalidValueException;
+class InvalidSchemaException extends exception_1.BaseException {
+    constructor(schema) {
+        super(`Invalid schema: ${JSON.stringify(schema)}`);
+    }
+}
+exports.InvalidSchemaException = InvalidSchemaException;
+class InvalidPropertyNameException extends exception_1.BaseException {
+    constructor(path) {
+        super(`Property ${JSON.stringify(path)} does not exist in the schema, and no additional `
+            + `properties are allowed.`);
+        this.path = path;
+    }
+}
+exports.InvalidPropertyNameException = InvalidPropertyNameException;
+class RequiredValueMissingException extends exception_1.BaseException {
+    constructor(path) {
+        super(`Property ${JSON.stringify(path)} is required but missing.`);
+        this.path = path;
+    }
+}
+exports.RequiredValueMissingException = RequiredValueMissingException;
+exports.exceptions = {
+    InvalidRangeException,
+    InvalidSchemaException,
+    InvalidValueException,
+    InvalidPropertyNameException,
+    RequiredValueMissingException,
+};
+const symbols = {
+    Schema: Symbol('schema'),
+};
+class JavascriptSerializer extends interface_1.JsonSchemaSerializer {
+    constructor(_options) {
+        super();
+        this._options = _options;
+        this._uniqueSet = new Set();
+    }
+    _unique(name) {
+        let i = 1;
+        let result = name;
+        while (this._uniqueSet.has(result)) {
+            result = name + i;
+            i++;
+        }
+        this._uniqueSet.add(result);
+        return result;
+    }
+    serialize(ref, registry) {
+        const rootSchema = registry.getSchemaFromRef(ref);
+        const { root, templates } = require('./templates/javascript');
+        const source = root({
+            exceptions: exports.exceptions,
+            name: '',
+            options: this._options || {},
+            schema: rootSchema,
+            strings: {
+                classify: strings_1.classify,
+                camelize: strings_1.camelize,
+            },
+            symbols,
+            templates,
+        });
+        const fn = new Function('registry', 'exceptions', 'symbols', 'value', source);
+        return (value) => fn(registry, exports.exceptions, symbols, value);
+    }
+}
+exports.JavascriptSerializer = JavascriptSerializer;
+//# sourceMappingURL=data:application/json;base64,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

package/src/json/schema/serializers/javascript_benchmark.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @license
+ * Copyright Google Inc. 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
+ */
+// tslint:disable:no-any
+const benchmark_1 = require("@_/benchmark");
+const json_schema_1 = require("@ngtools/json-schema");
+const fs = require("fs");
+const path = require("path");
+const registry_1 = require("../registry");
+const javascript_1 = require("./javascript");
+describe('JavaScript Serializer', () => {
+    // Schema for the Angular-CLI config.
+    const jsonPath = path.join(global._DevKitRoot, 'tests/@angular_devkit/core/json/schema/serializers/schema_benchmark.json');
+    const jsonContent = fs.readFileSync(jsonPath).toString();
+    const complexSchema = JSON.parse(jsonContent);
+    const registry = new registry_1.JsonSchemaRegistry();
+    registry.addSchema('', complexSchema);
+    benchmark_1.benchmark('schema parsing', () => {
+        new javascript_1.JavascriptSerializer().serialize('', registry)({});
+    }, () => {
+        const SchemaMetaClass = json_schema_1.SchemaClassFactory(complexSchema);
+        const schemaClass = new SchemaMetaClass({});
+        schemaClass.$$root();
+    });
+    (function () {
+        const registry = new registry_1.JsonSchemaRegistry();
+        registry.addSchema('', complexSchema);
+        const coreRoot = new javascript_1.JavascriptSerializer().serialize('', registry)({});
+        const SchemaMetaClass = json_schema_1.SchemaClassFactory(complexSchema);
+        const schemaClass = new SchemaMetaClass({});
+        const ngtoolsRoot = schemaClass.$$root();
+        benchmark_1.benchmark('schema access', () => {
+            coreRoot.project = { name: 'abc' };
+        }, () => {
+            ngtoolsRoot.project = { name: 'abc' };
+        });
+    })();
+});
+//# sourceMappingURL=data:application/json;base64,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

package/src/json/schema/serializers/templates/javascript/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright Google Inc. 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
+ */
+export declare const templates: {
+    [name: string]: (value: {}) => string;
+};
+export declare const root: (value: {}) => string;

package/src/json/schema/serializers/templates/javascript/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google Inc. 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.templates = {
+    subschema: require('./subschema').default,
+    prop_any: require('./prop-any').default,
+    prop_array: require('./prop-array').default,
+    prop_boolean: require('./prop-boolean').default,
+    prop_number: require('./prop-number').default,
+    prop_integer: require('./prop-number').default,
+    prop_object: require('./prop-object').default,
+    prop_string: require('./prop-string').default,
+};
+exports.root = require('./root').default;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiL1VzZXJzL2hhbnNsL1NvdXJjZXMvZGV2a2l0LyIsInNvdXJjZXMiOlsicGFja2FnZXMvYW5ndWxhcl9kZXZraXQvY29yZS9zcmMvanNvbi9zY2hlbWEvc2VyaWFsaXplcnMvdGVtcGxhdGVzL2phdmFzY3JpcHQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7R0FNRzs7QUFFVSxRQUFBLFNBQVMsR0FBOEM7SUFDbEUsU0FBUyxFQUFFLE9BQU8sQ0FBQyxhQUFhLENBQUMsQ0FBQyxPQUFPO0lBRXpDLFFBQVEsRUFBRSxPQUFPLENBQUMsWUFBWSxDQUFDLENBQUMsT0FBTztJQUN2QyxVQUFVLEVBQUUsT0FBTyxDQUFDLGNBQWMsQ0FBQyxDQUFDLE9BQU87SUFDM0MsWUFBWSxFQUFFLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDLE9BQU87SUFDL0MsV0FBVyxFQUFFLE9BQU8sQ0FBQyxlQUFlLENBQUMsQ0FBQyxPQUFPO0lBQzdDLFlBQVksRUFBRSxPQUFPLENBQUMsZUFBZSxDQUFDLENBQUMsT0FBTztJQUM5QyxXQUFXLEVBQUUsT0FBTyxDQUFDLGVBQWUsQ0FBQyxDQUFDLE9BQU87SUFDN0MsV0FBVyxFQUFFLE9BQU8sQ0FBQyxlQUFlLENBQUMsQ0FBQyxPQUFPO0NBQzlDLENBQUM7QUFFVyxRQUFBLElBQUksR0FBRyxPQUFPLENBQUMsUUFBUSxDQUFDLENBQUMsT0FBZ0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuZXhwb3J0IGNvbnN0IHRlbXBsYXRlczogeyBbbmFtZTogc3RyaW5nXTogKHZhbHVlOiB7fSkgPT4gc3RyaW5nIH0gPSB7XG4gIHN1YnNjaGVtYTogcmVxdWlyZSgnLi9zdWJzY2hlbWEnKS5kZWZhdWx0LFxuXG4gIHByb3BfYW55OiByZXF1aXJlKCcuL3Byb3AtYW55JykuZGVmYXVsdCxcbiAgcHJvcF9hcnJheTogcmVxdWlyZSgnLi9wcm9wLWFycmF5JykuZGVmYXVsdCxcbiAgcHJvcF9ib29sZWFuOiByZXF1aXJlKCcuL3Byb3AtYm9vbGVhbicpLmRlZmF1bHQsXG4gIHByb3BfbnVtYmVyOiByZXF1aXJlKCcuL3Byb3AtbnVtYmVyJykuZGVmYXVsdCxcbiAgcHJvcF9pbnRlZ2VyOiByZXF1aXJlKCcuL3Byb3AtbnVtYmVyJykuZGVmYXVsdCxcbiAgcHJvcF9vYmplY3Q6IHJlcXVpcmUoJy4vcHJvcC1vYmplY3QnKS5kZWZhdWx0LFxuICBwcm9wX3N0cmluZzogcmVxdWlyZSgnLi9wcm9wLXN0cmluZycpLmRlZmF1bHQsXG59O1xuXG5leHBvcnQgY29uc3Qgcm9vdCA9IHJlcXVpcmUoJy4vcm9vdCcpLmRlZmF1bHQgYXMgKHZhbHVlOiB7fSkgPT4gc3RyaW5nO1xuIl19

package/src/json/schema/serializers/templates/javascript/prop-any.js

@@ -0,0 +1,40 @@
+return module.exports.default = function(obj) {
+  obj || (obj = {});
+  let __t;
+  let __p = "";
+  const __escapes = {"&":"&amp;","<":"&lt;",">":"&gt;","\"":"&quot;","'":"&#39;","`":"&#96;"};
+  const __escapesre = new RegExp('[&<>"\\\'`]', 'g');
+
+  const __e = function(s) {     return s ? s.replace(__escapesre, function(key) { return __escapes[key]; }) : '';  };
+  with (obj) {
+__p = __p
+    + "{\n"
+    + "  value: undefined,\n"
+    + "  get() { return this.value === undefined ? ";
+__p += ((__t =  'default' in schema ? JSON.stringify(schema.default) : 'undefined' ) == null ? "" : __t);
+__p = __p
+    + " : this.value; },\n"
+    + "  set(v) {\n"
+    + "    if (v === undefined && ";
+__p += ((__t =  !required ) == null ? "" : __t);
+__p = __p
+    + ") {\n"
+    + "      this.value = undefined;\n"
+    + "      return;\n"
+    + "    }\n"
+    + "    this.value = v;\n"
+    + "  },\n"
+    + "  isDefined() { return this.value !== undefined; },\n"
+    + "  remove() { this.set(undefined); },\n"
+    + "  schema() { return ";
+__p += ((__t =  JSON.stringify(schema) ) == null ? "" : __t);
+__p = __p
+    + "; },\n"
+    + "}\n"
+    + "";
+  };
+
+  return __p;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInBhY2thZ2VzL2FuZ3VsYXJfZGV2a2l0L2NvcmUvc3JjL2pzb24vc2NoZW1hL3NlcmlhbGl6ZXJzL3RlbXBsYXRlcy9qYXZhc2NyaXB0L3Byb3AtYW55LmVqcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLFdBQ0E7QUFBQSw2QkFDQTtBQUFBLG9EQUEyQztBQUFBLG1GQUF5RTtBQUFBO0FBQUEsMkJBQ3BIO0FBQUEsb0JBQ0E7QUFBQSxtQ0FBMEI7QUFBQSwwQkFBZ0I7QUFBQTtBQUFBLGFBQzFDO0FBQUEsdUNBQ0E7QUFBQSx1QkFDQTtBQUFBLGVBQ0E7QUFBQSw2QkFDQTtBQUFBLGNBQ0E7QUFBQSw2REFDQTtBQUFBLDhDQUNBO0FBQUEsNEJBQW1CO0FBQUEsdUNBQTZCO0FBQUE7QUFBQSxjQUNoRDtBQUFBLFdBQ0E7QUFBQSxRQURDO0FBQUE7QUFBQTtBQUFBO0FBQUEiLCJmaWxlIjoicGFja2FnZXMvYW5ndWxhcl9kZXZraXQvY29yZS9zcmMvanNvbi9zY2hlbWEvc2VyaWFsaXplcnMvdGVtcGxhdGVzL2phdmFzY3JpcHQvcHJvcC1hbnkuZWpzIiwic291cmNlUm9vdCI6Ii9Vc2Vycy9oYW5zbC9Tb3VyY2VzL2RldmtpdCIsInNvdXJjZXNDb250ZW50IjpbIntcbiAgdmFsdWU6IHVuZGVmaW5lZCxcbiAgZ2V0KCkgeyByZXR1cm4gdGhpcy52YWx1ZSA9PT0gdW5kZWZpbmVkID8gPCU9ICdkZWZhdWx0JyBpbiBzY2hlbWEgPyBKU09OLnN0cmluZ2lmeShzY2hlbWEuZGVmYXVsdCkgOiAndW5kZWZpbmVkJyAlPiA6IHRoaXMudmFsdWU7IH0sXG4gIHNldCh2KSB7XG4gICAgaWYgKHYgPT09IHVuZGVmaW5lZCAmJiA8JT0gIXJlcXVpcmVkICU+KSB7XG4gICAgICB0aGlzLnZhbHVlID0gdW5kZWZpbmVkO1xuICAgICAgcmV0dXJuO1xuICAgIH1cbiAgICB0aGlzLnZhbHVlID0gdjtcbiAgfSxcbiAgaXNEZWZpbmVkKCkgeyByZXR1cm4gdGhpcy52YWx1ZSAhPT0gdW5kZWZpbmVkOyB9LFxuICByZW1vdmUoKSB7IHRoaXMuc2V0KHVuZGVmaW5lZCk7IH0sXG4gIHNjaGVtYSgpIHsgcmV0dXJuIDwlPSBKU09OLnN0cmluZ2lmeShzY2hlbWEpICU+OyB9LFxufVxuIl19

package/src/json/schema/serializers/templates/javascript/prop-array.js

@@ -0,0 +1,166 @@
+return module.exports.default = function(obj) {
+  obj || (obj = {});
+  let __t;
+  let __p = "";
+  const __escapes = {"&":"&amp;","<":"&lt;",">":"&gt;","\"":"&quot;","'":"&#39;","`":"&#96;"};
+  const __escapesre = new RegExp('[&<>"\\\'`]', 'g');
+
+  const __e = function(s) {     return s ? s.replace(__escapesre, function(key) { return __escapes[key]; }) : '';  };
+  with (obj) {
+__p = __p
+    + "(function() {\n"
+    + "";
+
+  if ('default' in schema && !Array.isArray(schema.default)
+    || 'minItems' in schema && (typeof schema.minItems != 'number' || schema.minItems < 0)
+    || 'maxItems' in schema && (typeof schema.maxItems != 'number' || schema.maxItems < 0)
+    || 'uniqueItems' in schema && typeof schema.uniqueItems != 'boolean') {
+    throw new exceptions.InvalidSchemaException(schema);
+  }
+
+  const required = (schema.required || []);
+  const extras = {
+    exceptions: exceptions,
+    options: options,
+    path: path,
+    strings: strings,
+    symbols: symbols,
+    templates: templates,
+  };
+
+__p = __p
+    + "\n"
+    + "\n"
+    + "const itemHandler = function() { return (";
+__p += ((__t = 
+  templates.subschema(Object.assign({
+    name: '???',
+    required: false,
+    schema: schema.additionalProperties,
+  }, extras))
+) == null ? "" : __t);
+__p = __p
+    + "); };\n"
+    + "\n"
+    + "\n"
+    + "const items = [];\n"
+    + "const arrayFunctions = {\n"
+    + "  get length() { return items.length; },\n"
+    + "  push() { items.push.apply(items, arguments); },\n"
+    + "  pop() { return items.pop(); },\n"
+    + "  shift() { return items.shift(); },\n"
+    + "  unshift() { return items.unshift(); },\n"
+    + "  slice(start, end) { return items.slice(start, end); },\n"
+    + "};\n"
+    + "\n"
+    + "\n"
+    + "let defined = false;\n"
+    + "const proxy = new Proxy({}, {\n"
+    + "  isExtensible() { return false; },\n"
+    + "  has(target, prop) {\n"
+    + "    return (prop in items);\n"
+    + "  },\n"
+    + "  get(target, prop) {\n"
+    + "    if (prop === symbols.Schema) {\n"
+    + "      return arrayHandler.schema;\n"
+    + "    }\n"
+    + "\n"
+    + "    if (prop >= 0 && prop in value) {\n"
+    + "      return value[prop].get();\n"
+    + "    }\n"
+    + "    if (prop in arrayFunctions) {\n"
+    + "      return arrayFunctions[prop];\n"
+    + "    }\n"
+    + "    return undefined;\n"
+    + "  },\n"
+    + "  set(target, prop, v) {\n"
+    + "    if (prop >= 0) {\n"
+    + "      if (!(prop in items)) {\n"
+    + "        items[prop] = itemHandler();\n"
+    + "      }\n"
+    + "      items[prop].set(v);\n"
+    + "      return true;\n"
+    + "    }\n"
+    + "    return false;\n"
+    + "  },\n"
+    + "  deleteProperty(target, prop) {\n"
+    + "    if (prop >= 0 && prop in value) {\n"
+    + "      value[prop].remove();\n"
+    + "      return true;\n"
+    + "    }\n"
+    + "    return false;\n"
+    + "  },\n"
+    + "  defineProperty(target, prop, descriptor) {\n"
+    + "    return false;\n"
+    + "  },\n"
+    + "  getOwnPropertyDescriptor(target, prop) {\n"
+    + "    if (prop >= 0 && prop in value) {\n"
+    + "      return { configurable: true, enumerable: true };\n"
+    + "    }\n"
+    + "  },\n"
+    + "  ownKeys(target) {\n"
+    + "    return Object.keys(items);\n"
+    + "  },\n"
+    + "});\n"
+    + "\n"
+    + "const arrayHandler = {\n"
+    + "  set(v) {\n"
+    + "    if (v === undefined) {\n"
+    + "      defined = false;\n"
+    + "      return;\n"
+    + "    }\n"
+    + "\n"
+    + "    defined = true;\n"
+    + "    for (const key of Object.keys(v)) {\n"
+    + "      proxy[key] = v[key];\n"
+    + "    }\n"
+    + "\n"
+    + "    // Validate required fields.\n"
+    + "    ";
+ for (const key of required) { 
+__p = __p
+    + "\n"
+    + "    if (!(";
+__p += ((__t =  JSON.stringify(key) ) == null ? "" : __t);
+__p = __p
+    + " in v)) {\n"
+    + "      throw new exceptions.RequiredValueMissingException(";
+__p += ((__t =  JSON.stringify(path) ) == null ? "" : __t);
+__p = __p
+    + " + '/' + ";
+__p += ((__t =  JSON.stringify(key) ) == null ? "" : __t);
+__p = __p
+    + ");\n"
+    + "    }";
+ } 
+__p = __p
+    + "\n"
+    + "  },\n"
+    + "  get() {\n"
+    + "    if (defined) {\n"
+    + "      return proxy;\n"
+    + "    } else {\n"
+    + "      return ";
+__p += ((__t =  'default' in schema ? JSON.stringify(schema.default) : 'undefined' ) == null ? "" : __t);
+__p = __p
+    + ";\n"
+    + "    }\n"
+    + "  },\n"
+    + "  isDefined() { return defined; },\n"
+    + "  remove() { this.set(undefined); },\n"
+    + "  schema: ";
+__p += ((__t =  JSON.stringify(schema) ) == null ? "" : __t);
+__p = __p
+    + ",\n"
+    + "};\n"
+    + "\n"
+    + "return arrayHandler;\n"
+    + "\n"
+    + "})()\n"
+    + "";
+  };
+
+  return __p;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/src/json/schema/serializers/templates/javascript/prop-boolean.js

@@ -0,0 +1,54 @@
+return module.exports.default = function(obj) {
+  obj || (obj = {});
+  let __t;
+  let __p = "";
+  const __escapes = {"&":"&amp;","<":"&lt;",">":"&gt;","\"":"&quot;","'":"&#39;","`":"&#96;"};
+  const __escapesre = new RegExp('[&<>"\\\'`]', 'g');
+
+  const __e = function(s) {     return s ? s.replace(__escapesre, function(key) { return __escapes[key]; }) : '';  };
+  with (obj) {
+__p = __p
+    + "{\n"
+    + "";
+
+  if ('default' in schema && typeof schema.default != 'boolean') {
+    throw new exceptions.InvalidSchemaException(schema);
+  }
+
+__p = __p
+    + "\n"
+    + "  value: undefined,\n"
+    + "  get() { return this.value === undefined ? ";
+__p += ((__t =  schema.default || 'undefined' ) == null ? "" : __t);
+__p = __p
+    + " : this.value; },\n"
+    + "  set(v) {\n"
+    + "    if (v === undefined && ";
+__p += ((__t =  !required ) == null ? "" : __t);
+__p = __p
+    + ") {\n"
+    + "      this.value = undefined;\n"
+    + "      return;\n"
+    + "    }\n"
+    + "    if (typeof v != 'boolean') {\n"
+    + "      throw new exceptions.InvalidValueException(";
+__p += ((__t =  JSON.stringify(name) ) == null ? "" : __t);
+__p = __p
+    + ", typeof v, 'boolean');\n"
+    + "    }\n"
+    + "    this.value = v;\n"
+    + "  },\n"
+    + "  isDefined() { return this.value !== undefined; },\n"
+    + "  remove() { this.set(undefined); },\n"
+    + "  schema() { return ";
+__p += ((__t =  JSON.stringify(schema) ) == null ? "" : __t);
+__p = __p
+    + "; },\n"
+    + "}\n"
+    + "";
+  };
+
+  return __p;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInBhY2thZ2VzL2FuZ3VsYXJfZGV2a2l0L2NvcmUvc3JjL2pzb24vc2NoZW1hL3NlcmlhbGl6ZXJzL3RlbXBsYXRlcy9qYXZhc2NyaXB0L3Byb3AtYm9vbGVhbi5lanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSxXQUNBO0FBQUEsUUFEQztBQUFBO0FBQ0Q7QUFDQTtBQUNBO0FBRUU7QUFBQTtBQUFBLFVBQ0Y7QUFBQSw2QkFDQTtBQUFBLG9EQUE0QztBQUFBLDhDQUFvQztBQUFBO0FBQUEsMkJBQ2hGO0FBQUEsb0JBQ0E7QUFBQSxtQ0FBMkI7QUFBQSwwQkFBZ0I7QUFBQTtBQUFBLGFBQzNDO0FBQUEsdUNBQ0E7QUFBQSx1QkFDQTtBQUFBLGVBQ0E7QUFBQSwwQ0FDQTtBQUFBLHlEQUFpRDtBQUFBLHFDQUEyQjtBQUFBO0FBQUEsaUNBQzVFO0FBQUEsZUFDQTtBQUFBLDZCQUNBO0FBQUEsY0FDQTtBQUFBLDZEQUNBO0FBQUEsOENBQ0E7QUFBQSw0QkFBb0I7QUFBQSx1Q0FBNkI7QUFBQTtBQUFBLGNBQ2pEO0FBQUEsV0FDQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEiLCJmaWxlIjoicGFja2FnZXMvYW5ndWxhcl9kZXZraXQvY29yZS9zcmMvanNvbi9zY2hlbWEvc2VyaWFsaXplcnMvdGVtcGxhdGVzL2phdmFzY3JpcHQvcHJvcC1ib29sZWFuLmVqcyIsInNvdXJjZVJvb3QiOiIvVXNlcnMvaGFuc2wvU291cmNlcy9kZXZraXQiLCJzb3VyY2VzQ29udGVudCI6WyJ7XG48JVxuICBpZiAoJ2RlZmF1bHQnIGluIHNjaGVtYSAmJiB0eXBlb2Ygc2NoZW1hLmRlZmF1bHQgIT0gJ2Jvb2xlYW4nKSB7XG4gICAgdGhyb3cgbmV3IGV4Y2VwdGlvbnMuSW52YWxpZFNjaGVtYUV4Y2VwdGlvbihzY2hlbWEpO1xuICB9XG4lPlxuICB2YWx1ZTogdW5kZWZpbmVkLFxuICBnZXQoKSB7IHJldHVybiB0aGlzLnZhbHVlID09PSB1bmRlZmluZWQgPyA8JT0gc2NoZW1hLmRlZmF1bHQgfHwgJ3VuZGVmaW5lZCcgJT4gOiB0aGlzLnZhbHVlOyB9LFxuICBzZXQodikge1xuICAgIGlmICh2ID09PSB1bmRlZmluZWQgJiYgPCU9ICFyZXF1aXJlZCAlPikge1xuICAgICAgdGhpcy52YWx1ZSA9IHVuZGVmaW5lZDtcbiAgICAgIHJldHVybjtcbiAgICB9XG4gICAgaWYgKHR5cGVvZiB2ICE9ICdib29sZWFuJykge1xuICAgICAgdGhyb3cgbmV3IGV4Y2VwdGlvbnMuSW52YWxpZFZhbHVlRXhjZXB0aW9uKDwlPSBKU09OLnN0cmluZ2lmeShuYW1lKSAlPiwgdHlwZW9mIHYsICdib29sZWFuJyk7XG4gICAgfVxuICAgIHRoaXMudmFsdWUgPSB2O1xuICB9LFxuICBpc0RlZmluZWQoKSB7IHJldHVybiB0aGlzLnZhbHVlICE9PSB1bmRlZmluZWQ7IH0sXG4gIHJlbW92ZSgpIHsgdGhpcy5zZXQodW5kZWZpbmVkKTsgfSxcbiAgc2NoZW1hKCkgeyByZXR1cm4gPCU9IEpTT04uc3RyaW5naWZ5KHNjaGVtYSkgJT47IH0sXG59XG4iXX0=