@servicenow/sdk-build-core 2.0.1

package/dist/plugins/behaviors/Composer.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linkDocument = linkDocument;
+/**
+ * Utility which takes an unlinked document and a node and returns the
+ * same document linked to the provided node.
+ *
+ * @param document The {@linkcode UnlinkedDocument} to link
+ * @param node The AST node to link the document to
+ * @returns A {@linkcode LinkedDocument}
+ */
+function linkDocument(document, node) {
+    return { ...document, node };
+}
+//# sourceMappingURL=Composer.js.map

package/dist/plugins/behaviors/Composer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Composer.js","sourceRoot":"","sources":["../../../src/plugins/behaviors/Composer.ts"],"names":[],"mappings":";;AAsHA,oCAKC;AAbD;;;;;;;GAOG;AACH,SAAgB,YAAY,CACxB,QAA6B,EAC7B,IAAO;IAEP,OAAO,EAAE,GAAG,QAAQ,EAAE,IAAI,EAAE,CAAA;AAChC,CAAC"}

package/dist/plugins/behaviors/Diagnostics.d.ts

@@ -0,0 +1,8 @@
+import * as ts from 'ts-morph';
+import { SupportedKindName, SupportedNodeByKindName } from '@servicenow/sdk-project';
+import { Context } from '../Context';
+import { FluentDiagnostic } from '../Diagnostic';
+export type DiagnosticsFunction<K extends SupportedKindName | 'Node' = SupportedKindName> = (node: K extends SupportedKindName ? SupportedNodeByKindName<K> : K extends 'Node' ? ts.Node : any, context: Context) => FluentDiagnostic[];
+export type Diagnostics<NodeKinds extends SupportedKindName | 'Node'> = {
+    [K in NodeKinds]: DiagnosticsFunction<K>;
+};

package/dist/plugins/behaviors/Diagnostics.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Diagnostics.js.map

package/dist/plugins/behaviors/Diagnostics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Diagnostics.js","sourceRoot":"","sources":["../../../src/plugins/behaviors/Diagnostics.ts"],"names":[],"mappings":""}

package/dist/plugins/behaviors/Generator.d.ts

@@ -0,0 +1,21 @@
+import { LinkedDocument, UnlinkedDocument } from './Composer';
+import { Arranged } from './Arranger';
+import { Context } from '../Context';
+/**
+ * A generator function is a function that accepts an unlinked document of
+ * a known kind as input and returns the same document as a linked document.
+ * In practice, this means the generator's job is to create new AST nodes
+ * for documents that are not linked to any node. Documents without nodes
+ * are usually from XML files containing records that aren't defined in the
+ * source code yet.
+ *
+ * @see {@linkcode UnlinkedDocument}
+ * @see {@linkcode LinkedDocument}
+ */
+export type GeneratorFunction<DocumentKind extends string = string> = (document: UnlinkedDocument<DocumentKind> & Arranged, context: Context, linkedDocuments: LinkedDocument[]) => LinkedDocument<DocumentKind> | undefined;
+/**
+ * @see {@linkcode Plugin#generators}
+ */
+export type Generators<DocumentKinds extends string = string> = {
+    [K in DocumentKinds]: GeneratorFunction<K>;
+};

package/dist/plugins/behaviors/Generator.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Generator.js.map

package/dist/plugins/behaviors/Generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Generator.js","sourceRoot":"","sources":["../../../src/plugins/behaviors/Generator.ts"],"names":[],"mappings":""}

package/dist/plugins/behaviors/OwnedTables.d.ts

@@ -0,0 +1,6 @@
+import { Diagnostic } from '@servicenow/sdk-project';
+export type TableOwnership = {
+    [table: string]: {
+        diagnosticLevel: Diagnostic.Level;
+    };
+};

package/dist/plugins/behaviors/OwnedTables.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=OwnedTables.js.map

package/dist/plugins/behaviors/OwnedTables.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OwnedTables.js","sourceRoot":"","sources":["../../../src/plugins/behaviors/OwnedTables.ts"],"names":[],"mappings":""}

package/dist/plugins/behaviors/PostProcessor.d.ts

@@ -0,0 +1,5 @@
+import { Context } from '../Context';
+import { EntityData } from './extractors';
+export type PostProcessors = {
+    entities?: (entities: EntityData[], context: Context) => void;
+};

package/dist/plugins/behaviors/PostProcessor.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=PostProcessor.js.map

package/dist/plugins/behaviors/PostProcessor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostProcessor.js","sourceRoot":"","sources":["../../../src/plugins/behaviors/PostProcessor.ts"],"names":[],"mappings":""}

package/dist/plugins/behaviors/Serializer.d.ts

@@ -0,0 +1,29 @@
+import { Document } from './Composer';
+import { Arranged } from './Arranger';
+import { Context } from '../Context';
+/**
+ * A file is a data structure with a name, a target directory, and content
+ * as a string. The target directory must be the name of one of the magic
+ * directories that exist within a ServiceNow deployable app package.
+ */
+export type File = {
+    name: `${string}.xml`;
+    directory: 'dictionary' | 'unload' | 'unload.demo' | 'update' | 'apply_once' | '';
+    content: string;
+};
+/**
+ * A serializer function is a function which accepts a document of a known
+ * kind as input and returns one or more files derived from that document,
+ * or returns undefined to indicate it did not handle the document. In practice,
+ * this means generating the XML content that the build system will write to
+ * the filesystem during the final stages of a build.
+ *
+ * @see {@linkcode Document}
+ */
+export type SerializerFunction<DocumentKind extends string = string> = (document: Document<DocumentKind> & Arranged, context: Context) => File | File[] | undefined;
+/**
+ * @see {@linkcode Plugin#serializers}
+ */
+export type Serializers<DocumentKinds extends string = string> = {
+    [K in DocumentKinds]: SerializerFunction<K>;
+};

package/dist/plugins/behaviors/Serializer.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Serializer.js.map

package/dist/plugins/behaviors/Serializer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Serializer.js","sourceRoot":"","sources":["../../../src/plugins/behaviors/Serializer.ts"],"names":[],"mappings":""}

package/dist/plugins/behaviors/Transformer.d.ts

@@ -0,0 +1,23 @@
+import { SupportedKindName, SupportedNode, SupportedNodeByKindName } from '@servicenow/sdk-project';
+import { LinkedDocument } from './Composer';
+import { Arranged } from './Arranger';
+import { Context } from '../Context';
+/**
+ * A transformer function is a function which accepts a linked document of
+ * a known kind as input and returns a boolean indicating whether or not it
+ * handled the document. The implementation of a transformer function, if it
+ * chooses to handle the document, should perform the necessary transformations
+ * on the document's linked node to ensure the document's data is fully
+ * represented in the source code.
+ *
+ * @see {@linkcode LinkedDocument}
+ */
+export type TransformerFunction<DocumentKind extends string = string, Node extends SupportedNode = SupportedNode> = (document: LinkedDocument<DocumentKind, Node> & Arranged, context: Context) => boolean;
+/**
+ * @see {@linkcode Plugin#transformers}
+ */
+export type Transformers<DocumentKinds extends string = string> = {
+    [DK in DocumentKinds]: {
+        [NK in SupportedKindName]?: TransformerFunction<DK, SupportedNodeByKindName<NK>>;
+    };
+};

package/dist/plugins/behaviors/Transformer.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Transformer.js.map

package/dist/plugins/behaviors/Transformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Transformer.js","sourceRoot":"","sources":["../../../src/plugins/behaviors/Transformer.ts"],"names":[],"mappings":""}

package/dist/plugins/behaviors/extractors/Data.d.ts

@@ -0,0 +1,107 @@
+import { SupportedNode } from '@servicenow/sdk-project';
+/**
+ * Actions indicate what should take place in the database when the XML file
+ * is loaded. The platform understands these three actions: insert/update,
+ * delete, and delete multiple.
+ */
+export type Action = 'INSERT_OR_UPDATE' | 'DELETE' | 'delete_multiple';
+/**
+ * Utility type for data passed to XML extractors for processing.
+ */
+export type Xml = {
+    filePath: string;
+    data: any;
+};
+/**
+ * Utility type to represent a simple object structure with primitive values.
+ */
+export type PrimitiveData = {
+    [x: string]: PrimitiveData | PrimitiveData[] | string | number | boolean | undefined;
+};
+/**
+ * XML data is data from XML files (such as the parsed content of a record_update)
+ * which is not associated with any AST node.
+ */
+export declare class XmlData<D extends PrimitiveData = PrimitiveData> {
+    data: D;
+    readonly filePath: string;
+    readonly kind: string;
+    readonly action: Action;
+    constructor(data: D, filePath: string, kind: string, action?: Action);
+}
+export type WrappedData<D> = {
+    [K in keyof D]: D[K] extends string ? StringData<D[K]> : D[K] extends number ? NumberData<D[K]> : D[K] extends boolean ? BooleanData<D[K]> : D[K] extends Array<unknown> ? ArrayData<D[K]> : D[K] extends Record<string, unknown> ? ObjectData<D[K]> : Data<D[K]>;
+};
+export declare abstract class Data<D = unknown> {
+    private readonly node;
+    constructor(node: SupportedNode);
+    /**
+     * @deprecated Using this for an array or object is bad practice because all of the elements/properties
+     * will be assigned the same node as the array/object itself. This makes it difficult to bidrectionally
+     * sync data created this way because you don't have the granularity required to know where each of the
+     * element/property values (and any nested values) came from.
+     */
+    static fromValue<const D>(value: D, node: SupportedNode): Data<D>;
+    static isUndefined(data?: Data): data is UndefinedData;
+    static isString(data?: Data): data is StringData;
+    static isNumber(data?: Data): data is NumberData;
+    static isBoolean(data?: Data): data is BooleanData;
+    static isArray(data?: Data): data is ArrayData;
+    static isObject(data?: Data): data is ObjectData;
+    static isEntity(data?: Data): data is EntityData;
+    abstract getValue(): D;
+    getNode(): import("ts-morph").SourceFile | import("ts-morph").ShorthandPropertyAssignment | import("ts-morph").Identifier | import("ts-morph").ObjectLiteralExpression | import("ts-morph").Node<import("ts-morph").ts.EndOfFileToken> | import("ts-morph").TypeAliasDeclaration | import("ts-morph").TypeReferenceNode | import("ts-morph").TypeLiteralNode | import("ts-morph").PropertySignature | import("ts-morph").TupleTypeNode | import("ts-morph").FunctionExpression | import("ts-morph").FunctionDeclaration | import("ts-morph").ArrayLiteralExpression | import("ts-morph").CallExpression<import("ts-morph").ts.CallExpression> | import("ts-morph").StringLiteral | import("ts-morph").NumericLiteral | import("ts-morph").TrueLiteral | import("ts-morph").FalseLiteral | import("ts-morph").VariableDeclaration | import("ts-morph").ClassDeclaration | import("ts-morph").ExportDeclaration | import("ts-morph").AsExpression | import("ts-morph").ComputedPropertyName | import("ts-morph").PropertyAssignment | import("ts-morph").PropertyAccessExpression<import("ts-morph").ts.PropertyAccessExpression> | import("ts-morph").NoSubstitutionTemplateLiteral | import("ts-morph").ExpressionStatement | import("ts-morph").TaggedTemplateExpression | import("ts-morph").ExportAssignment | import("ts-morph").ElementAccessExpression<import("ts-morph").ts.ElementAccessExpression> | import("ts-morph").TemplateExpression | import("ts-morph").ImportClause | import("ts-morph").ImportSpecifier | import("ts-morph").ImportDeclaration | import("ts-morph").NamedImports | import("ts-morph").VariableStatement | import("ts-morph").VariableDeclarationList | import("ts-morph").Node<import("ts-morph").ts.PlusToken> | import("ts-morph").Node<import("ts-morph").ts.ExportKeyword> | import("ts-morph").Node<import("ts-morph").ts.KeywordTypeNode<import("ts-morph").ts.SyntaxKind.AnyKeyword>> | import("ts-morph").ModuleDeclaration | import("ts-morph").ModuleBlock | import("ts-morph").Block | import("ts-morph").ParameterDeclaration | import("ts-morph").Node<import("ts-morph").ts.EqualsGreaterThanToken> | import("ts-morph").ArrowFunction | import("ts-morph").TemplateHead | import("ts-morph").TemplateMiddle | import("ts-morph").TemplateSpan | import("ts-morph").TemplateTail | import("ts-morph").PrefixUnaryExpression;
+}
+export declare class UndefinedData extends Data<undefined> {
+    constructor(node: SupportedNode);
+    getValue(): undefined;
+}
+export declare class StringData<const D extends string = string> extends Data<D> {
+    private readonly value;
+    constructor(value: D, node: SupportedNode);
+    getValue(): D;
+}
+export declare class NumberData<const D extends number = number> extends Data<D> {
+    private readonly value;
+    constructor(value: D, node: SupportedNode);
+    getValue(): D;
+}
+export declare class BooleanData<const D extends boolean = boolean> extends Data<D> {
+    private readonly value;
+    constructor(value: D, node: SupportedNode);
+    getValue(): D;
+}
+export declare class ArrayData<const D extends unknown[] = unknown[]> extends Data<D> {
+    private readonly elements;
+    constructor(elements: WrappedData<D>, node: SupportedNode);
+    /**
+     * @deprecated Using this for arrays is bad practice because all of the array elements will be
+     * assigned the same node as the array itself. This makes it difficult to bidrectionally sync
+     * data created this way because you don't have the granularity required to know where each of
+     * the element values (and any nested values) came from.
+     */
+    static fromArrayValue<const D extends unknown[]>(value: D, node: SupportedNode): ArrayData<D>;
+    getValue(): D;
+    getElements(): WrappedData<D>;
+}
+export declare class ObjectData<const D extends Record<string, unknown> = Record<string, unknown>> extends Data<D> {
+    private readonly properties;
+    constructor(properties: WrappedData<D>, node: SupportedNode);
+    /**
+     * @deprecated Using this for objects is bad practice because all of the object properties will
+     * be assigned the same node as the object itself. This makes it difficult to bidrectionally sync
+     * data created this way because you don't have the granularity required to know where each of
+     * the property values (and any nested values) came from.
+     */
+    static fromObjectValue<const D extends Record<string, unknown>>(value: D, node: SupportedNode): ObjectData<D>;
+    getValue(): D;
+    getProperty<const K extends keyof D>(name: K): WrappedData<D>[K];
+    getProperties(): WrappedData<D>;
+}
+export declare class EntityData<const D extends Record<string, unknown> = Record<string, unknown>> extends ObjectData<D> {
+    private readonly kind;
+    private readonly guid;
+    constructor(kind: string, guid: string, entity: ObjectData<D>, node: SupportedNode);
+    getKind(): string;
+    getGuid(): string;
+}

package/dist/plugins/behaviors/extractors/Data.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityData = exports.ObjectData = exports.ArrayData = exports.BooleanData = exports.NumberData = exports.StringData = exports.UndefinedData = exports.Data = exports.XmlData = void 0;
+/**
+ * XML data is data from XML files (such as the parsed content of a record_update)
+ * which is not associated with any AST node.
+ */
+class XmlData {
+    data;
+    filePath;
+    kind;
+    action;
+    constructor(data, filePath, kind, action = 'INSERT_OR_UPDATE') {
+        this.data = data;
+        this.filePath = filePath;
+        this.kind = kind;
+        this.action = action;
+    }
+}
+exports.XmlData = XmlData;
+class Data {
+    node;
+    constructor(node) {
+        this.node = node;
+    }
+    /**
+     * @deprecated Using this for an array or object is bad practice because all of the elements/properties
+     * will be assigned the same node as the array/object itself. This makes it difficult to bidrectionally
+     * sync data created this way because you don't have the granularity required to know where each of the
+     * element/property values (and any nested values) came from.
+     */
+    static fromValue(value, node) {
+        if (value === undefined || value === null) {
+            return new UndefinedData(node); // TODO: How can we avoid this silly cast?
+        }
+        else if (typeof value === 'string') {
+            return new StringData(value, node);
+        }
+        else if (typeof value === 'number') {
+            return new NumberData(value, node);
+        }
+        else if (typeof value === 'boolean') {
+            return new BooleanData(value, node);
+        }
+        else if (Array.isArray(value)) {
+            return ArrayData.fromArrayValue(value, node);
+        }
+        else if (!!value && typeof value === 'object') {
+            const obj = Object.fromEntries(Object.entries(value).filter(([key]) => typeof key === 'string'));
+            return ObjectData.fromObjectValue(obj, node);
+        }
+        else {
+            throw new Error(`Unsupported data type: ${value} (Type: ${typeof value}, Class: ${value?.constructor?.name})`);
+        }
+    }
+    static isUndefined(data) {
+        return data instanceof UndefinedData;
+    }
+    static isString(data) {
+        return data instanceof StringData;
+    }
+    static isNumber(data) {
+        return data instanceof NumberData;
+    }
+    static isBoolean(data) {
+        return data instanceof BooleanData;
+    }
+    static isArray(data) {
+        return data instanceof ArrayData;
+    }
+    static isObject(data) {
+        return data instanceof ObjectData;
+    }
+    static isEntity(data) {
+        return data instanceof EntityData;
+    }
+    getNode() {
+        return this.node;
+    }
+}
+exports.Data = Data;
+class UndefinedData extends Data {
+    constructor(node) {
+        super(node);
+    }
+    getValue() {
+        return undefined;
+    }
+}
+exports.UndefinedData = UndefinedData;
+class StringData extends Data {
+    value;
+    constructor(value, node) {
+        super(node);
+        this.value = value;
+    }
+    getValue() {
+        return this.value;
+    }
+}
+exports.StringData = StringData;
+class NumberData extends Data {
+    value;
+    constructor(value, node) {
+        super(node);
+        this.value = value;
+    }
+    getValue() {
+        return this.value;
+    }
+}
+exports.NumberData = NumberData;
+class BooleanData extends Data {
+    value;
+    constructor(value, node) {
+        super(node);
+        this.value = value;
+    }
+    getValue() {
+        return this.value;
+    }
+}
+exports.BooleanData = BooleanData;
+class ArrayData extends Data {
+    elements;
+    constructor(elements, node) {
+        super(node);
+        this.elements = elements;
+    }
+    /**
+     * @deprecated Using this for arrays is bad practice because all of the array elements will be
+     * assigned the same node as the array itself. This makes it difficult to bidrectionally sync
+     * data created this way because you don't have the granularity required to know where each of
+     * the element values (and any nested values) came from.
+     */
+    static fromArrayValue(value, node) {
+        const elements = value.map((value) => Data.fromValue(value, node));
+        return new ArrayData(elements, node);
+    }
+    getValue() {
+        return this.elements.map((element) => element.getValue());
+    }
+    getElements() {
+        return this.elements;
+    }
+}
+exports.ArrayData = ArrayData;
+class ObjectData extends Data {
+    properties;
+    constructor(properties, node) {
+        super(node);
+        this.properties = properties;
+    }
+    /**
+     * @deprecated Using this for objects is bad practice because all of the object properties will
+     * be assigned the same node as the object itself. This makes it difficult to bidrectionally sync
+     * data created this way because you don't have the granularity required to know where each of
+     * the property values (and any nested values) came from.
+     */
+    static fromObjectValue(value, node) {
+        const properties = Object.fromEntries(Object.entries(value).map(([key, value]) => [key, Data.fromValue(value, node)]));
+        return new ObjectData(properties, node);
+    }
+    getValue() {
+        return Object.fromEntries(Object.entries(this.properties).map(([key, value]) => [key, value.getValue()]));
+    }
+    getProperty(name) {
+        return this.properties[name];
+    }
+    getProperties() {
+        return this.properties;
+    }
+}
+exports.ObjectData = ObjectData;
+class EntityData extends ObjectData {
+    kind;
+    guid;
+    constructor(kind, guid, entity, node) {
+        super(entity.getProperties(), node);
+        this.kind = kind;
+        this.guid = guid;
+    }
+    getKind() {
+        return this.kind;
+    }
+    getGuid() {
+        return this.guid;
+    }
+}
+exports.EntityData = EntityData;
+//# sourceMappingURL=Data.js.map

package/dist/plugins/behaviors/extractors/Data.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Data.js","sourceRoot":"","sources":["../../../../src/plugins/behaviors/extractors/Data.ts"],"names":[],"mappings":"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"}

package/dist/plugins/behaviors/extractors/Extractors.d.ts

@@ -0,0 +1,41 @@
+import { SupportedKindName, SupportedNodeByKindName } from '@servicenow/sdk-project';
+import { Data, EntityData, Xml, XmlData } from './Data';
+import { Context } from '../../Context';
+import { FluentDiagnostic } from '../../Diagnostic';
+export type ExtractionResult<D extends Data = Data> = {
+    handled: false;
+} | {
+    handled: true;
+    data: D[];
+    diagnostics: FluentDiagnostic[];
+};
+/**
+ * An XML extractor function accepts an {@linkcode Xml} object and returns one or
+ * more pieces of {@linkcode XmlData} extracted from that object. The function may
+ * also return undefined to indicate that it did not handle the object.
+ */
+export type XmlExtractorFunction = (xml: Xml, context: Context) => XmlData | XmlData[] | undefined;
+/**
+ * A raw extractor function accepts an AST node and returns one or more pieces of
+ * {@linkcode Data} extracted from that node which cannot be composed into documents
+ * on their own but could be part of an entity.
+ */
+export type RawExtractorFunction<N extends SupportedKindName | 'any' = SupportedKindName> = (node: N extends SupportedKindName ? SupportedNodeByKindName<N> : any, context: Context) => ExtractionResult<Data>;
+/**
+ * An entity extractor function accepts an AST node and returns one or more pieces
+ * of {@linkcode EntityData} extracted from that node which can then be composed
+ * into documents.
+ */
+export type EntityExtractorFunction<N extends SupportedKindName | 'any' = SupportedKindName> = (node: N extends SupportedKindName ? SupportedNodeByKindName<N> : any, context: Context) => ExtractionResult<EntityData>;
+/**
+ * @see {@linkcode Plugin#extractors}
+ */
+export type Extractors<RawNodeKinds extends SupportedKindName | 'any', EntityNodeKinds extends SupportedKindName | 'any'> = {
+    xml?: XmlExtractorFunction;
+    raw?: {
+        [K in RawNodeKinds]: RawExtractorFunction<K>;
+    };
+    entity?: {
+        [K in EntityNodeKinds]: EntityExtractorFunction<K>;
+    };
+};

package/dist/plugins/behaviors/extractors/Extractors.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Extractors.js.map

package/dist/plugins/behaviors/extractors/Extractors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Extractors.js","sourceRoot":"","sources":["../../../../src/plugins/behaviors/extractors/Extractors.ts"],"names":[],"mappings":""}

package/dist/plugins/behaviors/extractors/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Extractors';
+export * from './Data';

package/dist/plugins/behaviors/extractors/index.js

@@ -0,0 +1,19 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Extractors"), exports);
+__exportStar(require("./Data"), exports);
+//# sourceMappingURL=index.js.map

package/dist/plugins/behaviors/extractors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/plugins/behaviors/extractors/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,+CAA4B;AAC5B,yCAAsB"}

package/dist/plugins/behaviors/index.d.ts

@@ -0,0 +1,9 @@
+export * from './extractors';
+export * from './Composer';
+export * from './Arranger';
+export * from './Serializer';
+export * from './Generator';
+export * from './Transformer';
+export * from './PostProcessor';
+export * from './Diagnostics';
+export * from './OwnedTables';

package/dist/plugins/behaviors/index.js

@@ -0,0 +1,26 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./extractors"), exports);
+__exportStar(require("./Composer"), exports);
+__exportStar(require("./Arranger"), exports);
+__exportStar(require("./Serializer"), exports);
+__exportStar(require("./Generator"), exports);
+__exportStar(require("./Transformer"), exports);
+__exportStar(require("./PostProcessor"), exports);
+__exportStar(require("./Diagnostics"), exports);
+__exportStar(require("./OwnedTables"), exports);
+//# sourceMappingURL=index.js.map

package/dist/plugins/behaviors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/plugins/behaviors/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,+CAA4B;AAC5B,6CAA0B;AAC1B,6CAA0B;AAC1B,+CAA4B;AAC5B,8CAA2B;AAC3B,gDAA6B;AAC7B,kDAA+B;AAC/B,gDAA6B;AAC7B,gDAA6B"}

package/dist/plugins/index.d.ts

@@ -0,0 +1,5 @@
+export { Plugin } from './Plugin';
+export { type Context, type HandledStates } from './Context';
+export * from './behaviors';
+export * from './util';
+export * from './Diagnostic';

package/dist/plugins/index.js

@@ -0,0 +1,23 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Plugin = void 0;
+var Plugin_1 = require("./Plugin");
+Object.defineProperty(exports, "Plugin", { enumerable: true, get: function () { return Plugin_1.Plugin; } });
+__exportStar(require("./behaviors"), exports);
+__exportStar(require("./util"), exports);
+__exportStar(require("./Diagnostic"), exports);
+//# sourceMappingURL=index.js.map

package/dist/plugins/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/plugins/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,mCAAiC;AAAxB,gGAAA,MAAM,OAAA;AAEf,8CAA2B;AAC3B,yCAAsB;AACtB,+CAA4B"}