@actions/workflow-parser 0.2.0

package/dist/templates/schema/boolean-definition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean-definition.js","sourceRoot":"","sources":["../../../src/templates/schema/boolean-definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAE,OAAO,EAAC,MAAM,uBAAuB,CAAC;AAE1D,OAAO,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAC,gBAAgB,EAAC,MAAM,qBAAqB,CAAC;AAErD,MAAM,OAAO,iBAAkB,SAAQ,gBAAgB;IACrD,YAAmB,GAAW,EAAE,UAAyB;QACvD,KAAK,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;QACvB,IAAI,UAAU,EAAE;YACd,KAAK,MAAM,cAAc,IAAI,UAAU,EAAE;gBACvC,MAAM,aAAa,GAAG,cAAc,CAAC,GAAG,CAAC,YAAY,CAAC,GAAG,UAAU,MAAM,CAAC,CAAC;gBAC3E,QAAQ,aAAa,CAAC,KAAK,EAAE;oBAC3B,KAAK,OAAO,CAAC,CAAC;wBACZ,MAAM,OAAO,GAAG,cAAc,CAAC,KAAK,CAAC,aAAa,CAAC,GAAG,UAAU,IAAI,OAAO,EAAE,CAAC,CAAC;wBAC/E,KAAK,MAAM,WAAW,IAAI,OAAO,EAAE;4BACjC,MAAM,UAAU,GAAG,WAAW,CAAC,GAAG,CAAC,YAAY,CAAC,GAAG,UAAU,IAAI,OAAO,MAAM,CAAC,CAAC;4BAChF,QAAQ,UAAU,CAAC,KAAK,EAAE;gCACxB;oCACE,SAAS;oCACT,UAAU,CAAC,qBAAqB,CAAC,GAAG,UAAU,IAAI,OAAO,MAAM,CAAC,CAAC;oCACjE,MAAM;6BACT;yBACF;wBACD,MAAM;qBACP;oBACD;wBACE,aAAa,CAAC,qBAAqB,CAAC,GAAG,UAAU,MAAM,CAAC,CAAC,CAAC,SAAS;iBACtE;aACF;SACF;IACH,CAAC;IAED,IAAoB,cAAc;QAChC,OAAO,cAAc,CAAC,OAAO,CAAC;IAChC,CAAC;IAEe,OAAO,CAAC,OAAqB;QAC3C,OAAO,OAAO,CAAC,iBAAiB,KAAK,SAAS,CAAC,OAAO,CAAC;IACzD,CAAC;IAEe,QAAQ;QACtB,QAAQ;IACV,CAAC;CACF"}

package/dist/templates/schema/definition-info.d.ts

@@ -0,0 +1,16 @@
+import { TemplateSchema } from ".";
+import { Definition } from "./definition";
+import { DefinitionType } from "./definition-type";
+import { ScalarDefinition } from "./scalar-definition";
+export declare class DefinitionInfo {
+    private readonly _schema;
+    readonly isDefinitionInfo = true;
+    readonly definition: Definition;
+    readonly allowedContext: string[];
+    constructor(schema: TemplateSchema, name: string);
+    constructor(parent: DefinitionInfo, name: string);
+    constructor(parent: DefinitionInfo, definition: Definition);
+    getScalarDefinitions(): ScalarDefinition[];
+    getDefinitionsOfType(type: DefinitionType): Definition[];
+}
+//# sourceMappingURL=definition-info.d.ts.map

package/dist/templates/schema/definition-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-info.d.ts","sourceRoot":"","sources":["../../../src/templates/schema/definition-info.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,cAAc,EAAC,MAAM,GAAG,CAAC;AACjC,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AACxC,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAC,gBAAgB,EAAC,MAAM,qBAAqB,CAAC;AAErD,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiB;IACzC,SAAgB,gBAAgB,QAAQ;IACxC,SAAgB,UAAU,EAAE,UAAU,CAAC;IACvC,SAAgB,cAAc,EAAE,MAAM,EAAE,CAAC;gBAEtB,MAAM,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM;gBACpC,MAAM,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM;gBACpC,MAAM,EAAE,cAAc,EAAE,UAAU,EAAE,UAAU;IAoC1D,oBAAoB,IAAI,gBAAgB,EAAE;IAI1C,oBAAoB,CAAC,IAAI,EAAE,cAAc,GAAG,UAAU,EAAE;CAGhE"}

package/dist/templates/schema/definition-info.js

@@ -0,0 +1,40 @@
+export class DefinitionInfo {
+    constructor(schemaOrParent, nameOrDefinition) {
+        this.isDefinitionInfo = true;
+        const parent = schemaOrParent?.isDefinitionInfo === true
+            ? schemaOrParent
+            : undefined;
+        this._schema = parent === undefined ? schemaOrParent : parent._schema;
+        // Lookup the definition if a key was passed in
+        this.definition =
+            typeof nameOrDefinition === "string" ? this._schema.getDefinition(nameOrDefinition) : nameOrDefinition;
+        // Record allowed context
+        if (this.definition.readerContext.length > 0) {
+            this.allowedContext = [];
+            // Copy parent allowed context
+            const upperSeen = {};
+            for (const context of parent?.allowedContext ?? []) {
+                this.allowedContext.push(context);
+                upperSeen[context.toUpperCase()] = true;
+            }
+            // Append context if unseen
+            for (const context of this.definition.readerContext) {
+                const upper = context.toUpperCase();
+                if (!upperSeen[upper]) {
+                    this.allowedContext.push(context);
+                    upperSeen[upper] = true;
+                }
+            }
+        }
+        else {
+            this.allowedContext = parent?.allowedContext ?? [];
+        }
+    }
+    getScalarDefinitions() {
+        return this._schema.getScalarDefinitions(this.definition);
+    }
+    getDefinitionsOfType(type) {
+        return this._schema.getDefinitionsOfType(this.definition, type);
+    }
+}
+//# sourceMappingURL=definition-info.js.map

package/dist/templates/schema/definition-info.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-info.js","sourceRoot":"","sources":["../../../src/templates/schema/definition-info.ts"],"names":[],"mappings":"AAKA,MAAM,OAAO,cAAc;IASzB,YAAmB,cAA+C,EAAE,gBAAqC;QAPzF,qBAAgB,GAAG,IAAI,CAAC;QAQtC,MAAM,MAAM,GACT,cAA6C,EAAE,gBAAgB,KAAK,IAAI;YACvE,CAAC,CAAE,cAAiC;YACpC,CAAC,CAAC,SAAS,CAAC;QAChB,IAAI,CAAC,OAAO,GAAG,MAAM,KAAK,SAAS,CAAC,CAAC,CAAE,cAAiC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC;QAE1F,+CAA+C;QAC/C,IAAI,CAAC,UAAU;YACb,OAAO,gBAAgB,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC;QAEzG,yBAAyB;QACzB,IAAI,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE;YAC5C,IAAI,CAAC,cAAc,GAAG,EAAE,CAAC;YAEzB,8BAA8B;YAC9B,MAAM,SAAS,GAA+B,EAAE,CAAC;YACjD,KAAK,MAAM,OAAO,IAAI,MAAM,EAAE,cAAc,IAAI,EAAE,EAAE;gBAClD,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBAClC,SAAS,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,GAAG,IAAI,CAAC;aACzC;YAED,2BAA2B;YAC3B,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE;gBACnD,MAAM,KAAK,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;gBACpC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE;oBACrB,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;oBAClC,SAAS,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;iBACzB;aACF;SACF;aAAM;YACL,IAAI,CAAC,cAAc,GAAG,MAAM,EAAE,cAAc,IAAI,EAAE,CAAC;SACpD;IACH,CAAC;IAEM,oBAAoB;QACzB,OAAO,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC5D,CAAC;IAEM,oBAAoB,CAAC,IAAoB;QAC9C,OAAO,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;IAClE,CAAC;CACF"}

package/dist/templates/schema/definition-type.d.ts

@@ -0,0 +1,11 @@
+export declare enum DefinitionType {
+    Null = 0,
+    Boolean = 1,
+    Number = 2,
+    String = 3,
+    Sequence = 4,
+    Mapping = 5,
+    OneOf = 6,
+    AllowedValues = 7
+}
+//# sourceMappingURL=definition-type.d.ts.map

package/dist/templates/schema/definition-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-type.d.ts","sourceRoot":"","sources":["../../../src/templates/schema/definition-type.ts"],"names":[],"mappings":"AAAA,oBAAY,cAAc;IACxB,IAAI,IAAA;IACJ,OAAO,IAAA;IACP,MAAM,IAAA;IACN,MAAM,IAAA;IACN,QAAQ,IAAA;IACR,OAAO,IAAA;IACP,KAAK,IAAA;IACL,aAAa,IAAA;CACd"}

package/dist/templates/schema/definition-type.js

@@ -0,0 +1,12 @@
+export var DefinitionType;
+(function (DefinitionType) {
+    DefinitionType[DefinitionType["Null"] = 0] = "Null";
+    DefinitionType[DefinitionType["Boolean"] = 1] = "Boolean";
+    DefinitionType[DefinitionType["Number"] = 2] = "Number";
+    DefinitionType[DefinitionType["String"] = 3] = "String";
+    DefinitionType[DefinitionType["Sequence"] = 4] = "Sequence";
+    DefinitionType[DefinitionType["Mapping"] = 5] = "Mapping";
+    DefinitionType[DefinitionType["OneOf"] = 6] = "OneOf";
+    DefinitionType[DefinitionType["AllowedValues"] = 7] = "AllowedValues";
+})(DefinitionType || (DefinitionType = {}));
+//# sourceMappingURL=definition-type.js.map

package/dist/templates/schema/definition-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-type.js","sourceRoot":"","sources":["../../../src/templates/schema/definition-type.ts"],"names":[],"mappings":"AAAA,MAAM,CAAN,IAAY,cASX;AATD,WAAY,cAAc;IACxB,mDAAI,CAAA;IACJ,yDAAO,CAAA;IACP,uDAAM,CAAA;IACN,uDAAM,CAAA;IACN,2DAAQ,CAAA;IACR,yDAAO,CAAA;IACP,qDAAK,CAAA;IACL,qEAAa,CAAA;AACf,CAAC,EATW,cAAc,KAAd,cAAc,QASzB"}

package/dist/templates/schema/definition.d.ts

@@ -0,0 +1,24 @@
+import { MappingToken } from "../tokens";
+import { DefinitionType } from "./definition-type";
+import { TemplateSchema } from "./template-schema";
+/**
+ * Defines the allowable schema for a user defined type
+ */
+export declare abstract class Definition {
+    /**
+     * Used by the template reader to determine allowed expression values and functions.
+     * Also used by the template reader to validate function min/max parameters.
+     */
+    readonly readerContext: string[];
+    /**
+     * Used by the template evaluator to determine allowed expression values and functions.
+     * The min/max parameter info is omitted.
+     */
+    readonly evaluatorContext: string[];
+    readonly key: string;
+    readonly description: string | undefined;
+    constructor(key: string, definition?: MappingToken);
+    abstract get definitionType(): DefinitionType;
+    abstract validate(schema: TemplateSchema, name: string): void;
+}
+//# sourceMappingURL=definition.d.ts.map

package/dist/templates/schema/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../../src/templates/schema/definition.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,YAAY,EAAC,MAAM,WAAW,CAAC;AACvC,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AAEjD;;GAEG;AACH,8BAAsB,UAAU;IAC9B;;;OAGG;IACH,SAAgB,aAAa,EAAE,MAAM,EAAE,CAAM;IAE7C;;;OAGG;IACH,SAAgB,gBAAgB,EAAE,MAAM,EAAE,CAAM;IAGhD,SAAgB,GAAG,EAAE,MAAM,CAAC;IAE5B,SAAgB,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;gBAE7B,GAAG,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,YAAY;IAgDzD,aAAoB,cAAc,IAAI,cAAc,CAAC;aAErC,QAAQ,CAAC,MAAM,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;CACrE"}

package/dist/templates/schema/definition.js

@@ -0,0 +1,62 @@
+import { CONTEXT, DEFINITION, DESCRIPTION } from "../template-constants";
+/**
+ * Defines the allowable schema for a user defined type
+ */
+export class Definition {
+    constructor(key, definition) {
+        /**
+         * Used by the template reader to determine allowed expression values and functions.
+         * Also used by the template reader to validate function min/max parameters.
+         */
+        this.readerContext = [];
+        /**
+         * Used by the template evaluator to determine allowed expression values and functions.
+         * The min/max parameter info is omitted.
+         */
+        this.evaluatorContext = [];
+        this.key = key;
+        if (definition) {
+            for (let i = 0; i < definition.count;) {
+                const definitionKey = definition.get(i).key.assertString(`${DEFINITION} key`);
+                switch (definitionKey.value) {
+                    case CONTEXT: {
+                        const context = definition.get(i).value.assertSequence(`${DEFINITION} ${CONTEXT}`);
+                        definition.remove(i);
+                        const seenReaderContext = {};
+                        const seenEvaluatorContext = {};
+                        for (const item of context) {
+                            const itemStr = item.assertString(`${CONTEXT} item`).value;
+                            const upperItemStr = itemStr.toUpperCase();
+                            if (seenReaderContext[upperItemStr]) {
+                                throw new Error(`Duplicate context item '${itemStr}'`);
+                            }
+                            seenReaderContext[upperItemStr] = true;
+                            this.readerContext.push(itemStr);
+                            // Remove min/max parameter info
+                            const paramIndex = itemStr.indexOf("(");
+                            const modifiedItemStr = paramIndex > 0 ? itemStr.substr(0, paramIndex + 1) + ")" : itemStr;
+                            const upperModifiedItemStr = modifiedItemStr.toUpperCase();
+                            if (seenEvaluatorContext[upperModifiedItemStr]) {
+                                throw new Error(`Duplicate context item '${modifiedItemStr}'`);
+                            }
+                            seenEvaluatorContext[upperModifiedItemStr] = true;
+                            this.evaluatorContext.push(modifiedItemStr);
+                        }
+                        break;
+                    }
+                    case DESCRIPTION: {
+                        const value = definition.get(i).value;
+                        this.description = value.assertString(DESCRIPTION).value;
+                        definition.remove(i);
+                        break;
+                    }
+                    default: {
+                        i++;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=definition.js.map

package/dist/templates/schema/definition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.js","sourceRoot":"","sources":["../../../src/templates/schema/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAE,UAAU,EAAE,WAAW,EAAC,MAAM,uBAAuB,CAAC;AAKvE;;GAEG;AACH,MAAM,OAAgB,UAAU;IAkB9B,YAAmB,GAAW,EAAE,UAAyB;QAjBzD;;;WAGG;QACa,kBAAa,GAAa,EAAE,CAAC;QAE7C;;;WAGG;QACa,qBAAgB,GAAa,EAAE,CAAC;QAQ9C,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QACf,IAAI,UAAU,EAAE;YACd,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,KAAK,GAAI;gBACtC,MAAM,aAAa,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,YAAY,CAAC,GAAG,UAAU,MAAM,CAAC,CAAC;gBAC9E,QAAQ,aAAa,CAAC,KAAK,EAAE;oBAC3B,KAAK,OAAO,CAAC,CAAC;wBACZ,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,cAAc,CAAC,GAAG,UAAU,IAAI,OAAO,EAAE,CAAC,CAAC;wBACnF,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;wBACrB,MAAM,iBAAiB,GAA6B,EAAE,CAAC;wBACvD,MAAM,oBAAoB,GAA6B,EAAE,CAAC;wBAC1D,KAAK,MAAM,IAAI,IAAI,OAAO,EAAE;4BAC1B,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,OAAO,OAAO,CAAC,CAAC,KAAK,CAAC;4BAC3D,MAAM,YAAY,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;4BAC3C,IAAI,iBAAiB,CAAC,YAAY,CAAC,EAAE;gCACnC,MAAM,IAAI,KAAK,CAAC,2BAA2B,OAAO,GAAG,CAAC,CAAC;6BACxD;4BACD,iBAAiB,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC;4BACvC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;4BAEjC,gCAAgC;4BAChC,MAAM,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;4BACxC,MAAM,eAAe,GAAG,UAAU,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,UAAU,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC;4BAC3F,MAAM,oBAAoB,GAAG,eAAe,CAAC,WAAW,EAAE,CAAC;4BAC3D,IAAI,oBAAoB,CAAC,oBAAoB,CAAC,EAAE;gCAC9C,MAAM,IAAI,KAAK,CAAC,2BAA2B,eAAe,GAAG,CAAC,CAAC;6BAChE;4BACD,oBAAoB,CAAC,oBAAoB,CAAC,GAAG,IAAI,CAAC;4BAClD,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;yBAC7C;wBAED,MAAM;qBACP;oBACD,KAAK,WAAW,CAAC,CAAC;wBAChB,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;wBACtC,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC,KAAK,CAAC;wBACzD,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;wBACrB,MAAM;qBACP;oBACD,OAAO,CAAC,CAAC;wBACP,CAAC,EAAE,CAAC;wBACJ,MAAM;qBACP;iBACF;aACF;SACF;IACH,CAAC;CAKF"}

package/dist/templates/schema/index.d.ts

@@ -0,0 +1,2 @@
+export { TemplateSchema } from "./template-schema";
+//# sourceMappingURL=index.d.ts.map

package/dist/templates/schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/templates/schema/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC"}

package/dist/templates/schema/index.js

@@ -0,0 +1,2 @@
+export { TemplateSchema } from "./template-schema";
+//# sourceMappingURL=index.js.map

package/dist/templates/schema/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/templates/schema/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC"}

package/dist/templates/schema/mapping-definition.d.ts

@@ -0,0 +1,16 @@
+import { TemplateSchema } from "./template-schema";
+import { MappingToken } from "../tokens";
+import { Definition } from "./definition";
+import { DefinitionType } from "./definition-type";
+import { PropertyDefinition } from "./property-definition";
+export declare class MappingDefinition extends Definition {
+    readonly properties: {
+        [key: string]: PropertyDefinition;
+    };
+    looseKeyType: string;
+    looseValueType: string;
+    constructor(key: string, definition?: MappingToken);
+    get definitionType(): DefinitionType;
+    validate(schema: TemplateSchema, name: string): void;
+}
+//# sourceMappingURL=mapping-definition.d.ts.map

package/dist/templates/schema/mapping-definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapping-definition.d.ts","sourceRoot":"","sources":["../../../src/templates/schema/mapping-definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AAEjD,OAAO,EAAC,YAAY,EAAC,MAAM,WAAW,CAAC;AACvC,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AACxC,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAC,kBAAkB,EAAC,MAAM,uBAAuB,CAAC;AAEzD,qBAAa,iBAAkB,SAAQ,UAAU;IAC/C,SAAgB,UAAU,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,kBAAkB,CAAA;KAAC,CAAM;IAC9D,YAAY,SAAM;IAClB,cAAc,SAAM;gBAER,GAAG,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,YAAY;IA4CzD,IAAoB,cAAc,IAAI,cAAc,CAEnD;IAEe,QAAQ,CAAC,MAAM,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;CA6BrE"}

package/dist/templates/schema/mapping-definition.js

@@ -0,0 +1,81 @@
+import { DEFINITION, MAPPING, PROPERTIES, LOOSE_KEY_TYPE, LOOSE_VALUE_TYPE } from "../template-constants";
+import { Definition } from "./definition";
+import { DefinitionType } from "./definition-type";
+import { PropertyDefinition } from "./property-definition";
+export class MappingDefinition extends Definition {
+    constructor(key, definition) {
+        super(key, definition);
+        this.properties = {};
+        this.looseKeyType = "";
+        this.looseValueType = "";
+        if (definition) {
+            for (const definitionPair of definition) {
+                const definitionKey = definitionPair.key.assertString(`${DEFINITION} key`);
+                switch (definitionKey.value) {
+                    case MAPPING: {
+                        const mapping = definitionPair.value.assertMapping(`${DEFINITION} ${MAPPING}`);
+                        for (const mappingPair of mapping) {
+                            const mappingKey = mappingPair.key.assertString(`${DEFINITION} ${MAPPING} key`);
+                            switch (mappingKey.value) {
+                                case PROPERTIES: {
+                                    const properties = mappingPair.value.assertMapping(`${DEFINITION} ${MAPPING} ${PROPERTIES}`);
+                                    for (const propertiesPair of properties) {
+                                        const propertyName = propertiesPair.key.assertString(`${DEFINITION} ${MAPPING} ${PROPERTIES} key`);
+                                        this.properties[propertyName.value] = new PropertyDefinition(propertiesPair.value);
+                                    }
+                                    break;
+                                }
+                                case LOOSE_KEY_TYPE: {
+                                    const looseKeyType = mappingPair.value.assertString(`${DEFINITION} ${MAPPING} ${LOOSE_KEY_TYPE}`);
+                                    this.looseKeyType = looseKeyType.value;
+                                    break;
+                                }
+                                case LOOSE_VALUE_TYPE: {
+                                    const looseValueType = mappingPair.value.assertString(`${DEFINITION} ${MAPPING} ${LOOSE_VALUE_TYPE}`);
+                                    this.looseValueType = looseValueType.value;
+                                    break;
+                                }
+                                default:
+                                    // throws
+                                    mappingKey.assertUnexpectedValue(`${DEFINITION} ${MAPPING} key`);
+                                    break;
+                            }
+                        }
+                        break;
+                    }
+                    default:
+                        definitionKey.assertUnexpectedValue(`${DEFINITION} key`); // throws
+                }
+            }
+        }
+    }
+    get definitionType() {
+        return DefinitionType.Mapping;
+    }
+    validate(schema, name) {
+        // Lookup loose key type
+        if (this.looseKeyType) {
+            schema.getDefinition(this.looseKeyType);
+            // Lookup loose value type
+            if (this.looseValueType) {
+                schema.getDefinition(this.looseValueType);
+            }
+            else {
+                throw new Error(`Property '${LOOSE_KEY_TYPE}' is defined but '${LOOSE_VALUE_TYPE}' is not defined on '${name}'`);
+            }
+        }
+        // Otherwise validate loose value type not be defined
+        else if (this.looseValueType) {
+            throw new Error(`Property '${LOOSE_VALUE_TYPE}' is defined but '${LOOSE_KEY_TYPE}' is not defined on '${name}'`);
+        }
+        // Lookup each property
+        for (const propertyName of Object.keys(this.properties)) {
+            const propertyDef = this.properties[propertyName];
+            if (!propertyDef.type) {
+                throw new Error(`Type not specified for the property '${propertyName}' on '${name}'`);
+            }
+            schema.getDefinition(propertyDef.type);
+        }
+    }
+}
+//# sourceMappingURL=mapping-definition.js.map

package/dist/templates/schema/mapping-definition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapping-definition.js","sourceRoot":"","sources":["../../../src/templates/schema/mapping-definition.ts"],"names":[],"mappings":"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"}

package/dist/templates/schema/null-definition.d.ts

@@ -0,0 +1,10 @@
+import { MappingToken, LiteralToken } from "../tokens";
+import { DefinitionType } from "./definition-type";
+import { ScalarDefinition } from "./scalar-definition";
+export declare class NullDefinition extends ScalarDefinition {
+    constructor(key: string, definition?: MappingToken);
+    get definitionType(): DefinitionType;
+    isMatch(literal: LiteralToken): boolean;
+    validate(): void;
+}
+//# sourceMappingURL=null-definition.d.ts.map

package/dist/templates/schema/null-definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"null-definition.d.ts","sourceRoot":"","sources":["../../../src/templates/schema/null-definition.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,YAAY,EAAE,YAAY,EAAC,MAAM,WAAW,CAAC;AACrD,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAC,gBAAgB,EAAC,MAAM,qBAAqB,CAAC;AAGrD,qBAAa,cAAe,SAAQ,gBAAgB;gBAC/B,GAAG,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,YAAY;IA0BzD,IAAoB,cAAc,IAAI,cAAc,CAEnD;IAEe,OAAO,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO;IAIvC,QAAQ,IAAI,IAAI;CAGjC"}

package/dist/templates/schema/null-definition.js

@@ -0,0 +1,41 @@
+import { DEFINITION, NULL } from "../template-constants";
+import { DefinitionType } from "./definition-type";
+import { ScalarDefinition } from "./scalar-definition";
+import { TokenType } from "../tokens/types";
+export class NullDefinition extends ScalarDefinition {
+    constructor(key, definition) {
+        super(key, definition);
+        if (definition) {
+            for (const definitionPair of definition) {
+                const definitionKey = definitionPair.key.assertString(`${DEFINITION} key`);
+                switch (definitionKey.value) {
+                    case NULL: {
+                        const mapping = definitionPair.value.assertMapping(`${DEFINITION} ${NULL}`);
+                        for (const mappingPair of mapping) {
+                            const mappingKey = mappingPair.key.assertString(`${DEFINITION} ${NULL} key`);
+                            switch (mappingKey.value) {
+                                default:
+                                    // throws
+                                    mappingKey.assertUnexpectedValue(`${DEFINITION} ${NULL} key`);
+                                    break;
+                            }
+                        }
+                        break;
+                    }
+                    default:
+                        definitionKey.assertUnexpectedValue(`${DEFINITION} key`); // throws
+                }
+            }
+        }
+    }
+    get definitionType() {
+        return DefinitionType.Null;
+    }
+    isMatch(literal) {
+        return literal.templateTokenType === TokenType.Null;
+    }
+    validate() {
+        // no-op
+    }
+}
+//# sourceMappingURL=null-definition.js.map

package/dist/templates/schema/null-definition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"null-definition.js","sourceRoot":"","sources":["../../../src/templates/schema/null-definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAE,IAAI,EAAC,MAAM,uBAAuB,CAAC;AAEvD,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAC,gBAAgB,EAAC,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAE1C,MAAM,OAAO,cAAe,SAAQ,gBAAgB;IAClD,YAAmB,GAAW,EAAE,UAAyB;QACvD,KAAK,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;QACvB,IAAI,UAAU,EAAE;YACd,KAAK,MAAM,cAAc,IAAI,UAAU,EAAE;gBACvC,MAAM,aAAa,GAAG,cAAc,CAAC,GAAG,CAAC,YAAY,CAAC,GAAG,UAAU,MAAM,CAAC,CAAC;gBAC3E,QAAQ,aAAa,CAAC,KAAK,EAAE;oBAC3B,KAAK,IAAI,CAAC,CAAC;wBACT,MAAM,OAAO,GAAG,cAAc,CAAC,KAAK,CAAC,aAAa,CAAC,GAAG,UAAU,IAAI,IAAI,EAAE,CAAC,CAAC;wBAC5E,KAAK,MAAM,WAAW,IAAI,OAAO,EAAE;4BACjC,MAAM,UAAU,GAAG,WAAW,CAAC,GAAG,CAAC,YAAY,CAAC,GAAG,UAAU,IAAI,IAAI,MAAM,CAAC,CAAC;4BAC7E,QAAQ,UAAU,CAAC,KAAK,EAAE;gCACxB;oCACE,SAAS;oCACT,UAAU,CAAC,qBAAqB,CAAC,GAAG,UAAU,IAAI,IAAI,MAAM,CAAC,CAAC;oCAC9D,MAAM;6BACT;yBACF;wBACD,MAAM;qBACP;oBACD;wBACE,aAAa,CAAC,qBAAqB,CAAC,GAAG,UAAU,MAAM,CAAC,CAAC,CAAC,SAAS;iBACtE;aACF;SACF;IACH,CAAC;IAED,IAAoB,cAAc;QAChC,OAAO,cAAc,CAAC,IAAI,CAAC;IAC7B,CAAC;IAEe,OAAO,CAAC,OAAqB;QAC3C,OAAO,OAAO,CAAC,iBAAiB,KAAK,SAAS,CAAC,IAAI,CAAC;IACtD,CAAC;IAEe,QAAQ;QACtB,QAAQ;IACV,CAAC;CACF"}

package/dist/templates/schema/number-definition.d.ts

@@ -0,0 +1,10 @@
+import { MappingToken, LiteralToken } from "../tokens";
+import { DefinitionType } from "./definition-type";
+import { ScalarDefinition } from "./scalar-definition";
+export declare class NumberDefinition extends ScalarDefinition {
+    constructor(key: string, definition?: MappingToken);
+    get definitionType(): DefinitionType;
+    isMatch(literal: LiteralToken): boolean;
+    validate(): void;
+}
+//# sourceMappingURL=number-definition.d.ts.map

package/dist/templates/schema/number-definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number-definition.d.ts","sourceRoot":"","sources":["../../../src/templates/schema/number-definition.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,YAAY,EAAE,YAAY,EAAC,MAAM,WAAW,CAAC;AACrD,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAC,gBAAgB,EAAC,MAAM,qBAAqB,CAAC;AAGrD,qBAAa,gBAAiB,SAAQ,gBAAgB;gBACjC,GAAG,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,YAAY;IA0BzD,IAAoB,cAAc,IAAI,cAAc,CAEnD;IAEe,OAAO,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO;IAIvC,QAAQ,IAAI,IAAI;CAGjC"}

package/dist/templates/schema/number-definition.js

@@ -0,0 +1,41 @@
+import { DEFINITION, NUMBER } from "../template-constants";
+import { DefinitionType } from "./definition-type";
+import { ScalarDefinition } from "./scalar-definition";
+import { TokenType } from "../tokens/types";
+export class NumberDefinition extends ScalarDefinition {
+    constructor(key, definition) {
+        super(key, definition);
+        if (definition) {
+            for (const definitionPair of definition) {
+                const definitionKey = definitionPair.key.assertString(`${DEFINITION} key`);
+                switch (definitionKey.value) {
+                    case NUMBER: {
+                        const mapping = definitionPair.value.assertMapping(`${DEFINITION} ${NUMBER}`);
+                        for (const mappingPair of mapping) {
+                            const mappingKey = mappingPair.key.assertString(`${DEFINITION} ${NUMBER} key`);
+                            switch (mappingKey.value) {
+                                default:
+                                    // throws
+                                    mappingKey.assertUnexpectedValue(`${DEFINITION} ${NUMBER} key`);
+                                    break;
+                            }
+                        }
+                        break;
+                    }
+                    default:
+                        definitionKey.assertUnexpectedValue(`${DEFINITION} key`); // throws
+                }
+            }
+        }
+    }
+    get definitionType() {
+        return DefinitionType.Number;
+    }
+    isMatch(literal) {
+        return literal.templateTokenType === TokenType.Number;
+    }
+    validate() {
+        // no-op
+    }
+}
+//# sourceMappingURL=number-definition.js.map

package/dist/templates/schema/number-definition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"number-definition.js","sourceRoot":"","sources":["../../../src/templates/schema/number-definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAE,MAAM,EAAC,MAAM,uBAAuB,CAAC;AAEzD,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAC,gBAAgB,EAAC,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAE1C,MAAM,OAAO,gBAAiB,SAAQ,gBAAgB;IACpD,YAAmB,GAAW,EAAE,UAAyB;QACvD,KAAK,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;QACvB,IAAI,UAAU,EAAE;YACd,KAAK,MAAM,cAAc,IAAI,UAAU,EAAE;gBACvC,MAAM,aAAa,GAAG,cAAc,CAAC,GAAG,CAAC,YAAY,CAAC,GAAG,UAAU,MAAM,CAAC,CAAC;gBAC3E,QAAQ,aAAa,CAAC,KAAK,EAAE;oBAC3B,KAAK,MAAM,CAAC,CAAC;wBACX,MAAM,OAAO,GAAG,cAAc,CAAC,KAAK,CAAC,aAAa,CAAC,GAAG,UAAU,IAAI,MAAM,EAAE,CAAC,CAAC;wBAC9E,KAAK,MAAM,WAAW,IAAI,OAAO,EAAE;4BACjC,MAAM,UAAU,GAAG,WAAW,CAAC,GAAG,CAAC,YAAY,CAAC,GAAG,UAAU,IAAI,MAAM,MAAM,CAAC,CAAC;4BAC/E,QAAQ,UAAU,CAAC,KAAK,EAAE;gCACxB;oCACE,SAAS;oCACT,UAAU,CAAC,qBAAqB,CAAC,GAAG,UAAU,IAAI,MAAM,MAAM,CAAC,CAAC;oCAChE,MAAM;6BACT;yBACF;wBACD,MAAM;qBACP;oBACD;wBACE,aAAa,CAAC,qBAAqB,CAAC,GAAG,UAAU,MAAM,CAAC,CAAC,CAAC,SAAS;iBACtE;aACF;SACF;IACH,CAAC;IAED,IAAoB,cAAc;QAChC,OAAO,cAAc,CAAC,MAAM,CAAC;IAC/B,CAAC;IAEe,OAAO,CAAC,OAAqB;QAC3C,OAAO,OAAO,CAAC,iBAAiB,KAAK,SAAS,CAAC,MAAM,CAAC;IACxD,CAAC;IAEe,QAAQ;QACtB,QAAQ;IACV,CAAC;CACF"}

package/dist/templates/schema/one-of-definition.d.ts

@@ -0,0 +1,15 @@
+import { TemplateSchema } from "./template-schema";
+import { MappingToken } from "../tokens";
+import { Definition } from "./definition";
+import { DefinitionType } from "./definition-type";
+/**
+ * Must resolve to exactly one of the referenced definitions
+ */
+export declare class OneOfDefinition extends Definition {
+    readonly oneOf: string[];
+    readonly oneOfPrefix: string[];
+    constructor(key: string, definition?: MappingToken);
+    get definitionType(): DefinitionType;
+    validate(schema: TemplateSchema, name: string): void;
+}
+//# sourceMappingURL=one-of-definition.d.ts.map

package/dist/templates/schema/one-of-definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"one-of-definition.d.ts","sourceRoot":"","sources":["../../../src/templates/schema/one-of-definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AAajD,OAAO,EAAC,YAAY,EAAC,MAAM,WAAW,CAAC;AAEvC,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AACxC,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AAQjD;;GAEG;AACH,qBAAa,eAAgB,SAAQ,UAAU;IAC7C,SAAgB,KAAK,EAAE,MAAM,EAAE,CAAM;IACrC,SAAgB,WAAW,EAAE,MAAM,EAAE,CAAM;gBAExB,GAAG,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,YAAY;IA+BzD,IAAoB,cAAc,IAAI,cAAc,CAEnD;IAEe,QAAQ,CAAC,MAAM,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;CA8HrE"}

package/dist/templates/schema/one-of-definition.js

@@ -0,0 +1,154 @@
+import { DEFINITION, ONE_OF, SEQUENCE, NULL, BOOLEAN, NUMBER, SCALAR, CONSTANT, LOOSE_KEY_TYPE, ALLOWED_VALUES } from "../template-constants";
+import { Definition } from "./definition";
+import { DefinitionType } from "./definition-type";
+/**
+ * Must resolve to exactly one of the referenced definitions
+ */
+export class OneOfDefinition extends Definition {
+    constructor(key, definition) {
+        super(key, definition);
+        this.oneOf = [];
+        this.oneOfPrefix = [];
+        if (definition) {
+            for (const definitionPair of definition) {
+                const definitionKey = definitionPair.key.assertString(`${DEFINITION} key`);
+                switch (definitionKey.value) {
+                    case ONE_OF: {
+                        const oneOf = definitionPair.value.assertSequence(`${DEFINITION} ${ONE_OF}`);
+                        for (const item of oneOf) {
+                            const oneOfItem = item.assertString(`${DEFINITION} ${ONE_OF} item`);
+                            this.oneOf.push(oneOfItem.value);
+                        }
+                        break;
+                    }
+                    case ALLOWED_VALUES: {
+                        const oneOf = definitionPair.value.assertSequence(`${DEFINITION} ${ALLOWED_VALUES}`);
+                        for (const item of oneOf) {
+                            const oneOfItem = item.assertString(`${DEFINITION} ${ONE_OF} item`);
+                            this.oneOf.push(this.key + "-" + oneOfItem.value);
+                        }
+                        break;
+                    }
+                    default:
+                        // throws
+                        definitionKey.assertUnexpectedValue(`${DEFINITION} key`);
+                        break;
+                }
+            }
+        }
+    }
+    get definitionType() {
+        return DefinitionType.OneOf;
+    }
+    validate(schema, name) {
+        if (this.oneOf.length === 0) {
+            throw new Error(`'${name}' does not contain any references`);
+        }
+        let foundLooseKeyType = false;
+        const mappingDefinitions = [];
+        let allowedValuesDefinition;
+        let sequenceDefinition;
+        let nullDefinition;
+        let booleanDefinition;
+        let numberDefinition;
+        const stringDefinitions = [];
+        const seenNestedTypes = {};
+        for (const nestedType of this.oneOf) {
+            if (seenNestedTypes[nestedType]) {
+                throw new Error(`'${name}' contains duplicate nested type '${nestedType}'`);
+            }
+            seenNestedTypes[nestedType] = true;
+            const nestedDefinition = schema.getDefinition(nestedType);
+            if (nestedDefinition.readerContext.length > 0) {
+                throw new Error(`'${name}' is a one-of definition and references another definition that defines context. This is currently not supported.`);
+            }
+            switch (nestedDefinition.definitionType) {
+                case DefinitionType.Mapping: {
+                    const mappingDefinition = nestedDefinition;
+                    mappingDefinitions.push(mappingDefinition);
+                    if (mappingDefinition.looseKeyType) {
+                        foundLooseKeyType = true;
+                    }
+                    break;
+                }
+                case DefinitionType.Sequence: {
+                    // Multiple sequence definitions not allowed
+                    if (sequenceDefinition) {
+                        throw new Error(`'${name}' refers to more than one definition of type '${SEQUENCE}'`);
+                    }
+                    sequenceDefinition = nestedDefinition;
+                    break;
+                }
+                case DefinitionType.Null: {
+                    // Multiple null definitions not allowed
+                    if (nullDefinition) {
+                        throw new Error(`'${name}' refers to more than one definition of type '${NULL}'`);
+                    }
+                    nullDefinition = nestedDefinition;
+                    break;
+                }
+                case DefinitionType.Boolean: {
+                    // Multiple boolean definitions not allowed
+                    if (booleanDefinition) {
+                        throw new Error(`'${name}' refers to more than one definition of type '${BOOLEAN}'`);
+                    }
+                    booleanDefinition = nestedDefinition;
+                    break;
+                }
+                case DefinitionType.Number: {
+                    // Multiple number definitions not allowed
+                    if (numberDefinition) {
+                        throw new Error(`'${name}' refers to more than one definition of type '${NUMBER}'`);
+                    }
+                    numberDefinition = nestedDefinition;
+                    break;
+                }
+                case DefinitionType.String: {
+                    const stringDefinition = nestedDefinition;
+                    // Multiple string definitions
+                    if (stringDefinitions.length > 0 && (!stringDefinitions[0].constant || !stringDefinition.constant)) {
+                        throw new Error(`'${name}' refers to more than one '${SCALAR}', but some do not set '${CONSTANT}'`);
+                    }
+                    stringDefinitions.push(stringDefinition);
+                    break;
+                }
+                case DefinitionType.OneOf: {
+                    // Multiple allowed-values definitions not allowed
+                    if (allowedValuesDefinition) {
+                        throw new Error(`'${name}' contains multiple allowed-values definitions`);
+                    }
+                    allowedValuesDefinition = nestedDefinition;
+                    break;
+                }
+                default:
+                    throw new Error(`'${name}' refers to a definition with type '${nestedDefinition.definitionType}'`);
+            }
+        }
+        if (mappingDefinitions.length > 1) {
+            if (foundLooseKeyType) {
+                throw new Error(`'${name}' refers to two mappings and at least one sets '${LOOSE_KEY_TYPE}'. This is not currently supported.`);
+            }
+            const seenProperties = {};
+            for (const mappingDefinition of mappingDefinitions) {
+                for (const propertyName of Object.keys(mappingDefinition.properties)) {
+                    const newPropertyDef = mappingDefinition.properties[propertyName];
+                    // Already seen
+                    const existingPropertyDef = seenProperties[propertyName];
+                    if (existingPropertyDef) {
+                        // Types match
+                        if (existingPropertyDef.type === newPropertyDef.type) {
+                            continue;
+                        }
+                        // Collision
+                        throw new Error(`'${name}' contains two mappings with the same property, but each refers to a different type. All matching properties must refer to the same type.`);
+                    }
+                    // New
+                    else {
+                        seenProperties[propertyName] = newPropertyDef;
+                    }
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=one-of-definition.js.map