@coolon/i18n-resource-generator 1.0.1

package/build/module/lib/ast/objectDef.class.js

@@ -0,0 +1,59 @@
+import * as _ from 'lodash';
+import { AbstractContainerElement } from "./abstractContainerElement";
+import { NamespaceDef } from "./namespaceDef.class";
+import { FunctionDef } from "./functionDef.class";
+import { capitalize } from '../stringUtil';
+export class ObjectDef extends AbstractContainerElement {
+    constructor(name) {
+        super(name);
+        this._typeName = null;
+    }
+    asType(typeName) {
+        this._typeName = typeName;
+        return this;
+    }
+    typeName() {
+        return this._typeName;
+    }
+    nestedContainer(name, configure) {
+        this.addElement(new ObjectDef(name), configure);
+    }
+    defineInterface(name, configure) {
+        return this.nearestNamespace().defineInterface(this.fqName(name), configure);
+    }
+    defineClass(name, args, configure) {
+        return this.nearestNamespace().defineClass(this.fqName(name), null, configure);
+    }
+    defineType(name, value) {
+        return this.nearestNamespace().defineType(name, value);
+    }
+    createObject(name, configure) {
+        return this.addElement(new ObjectDef(name), configure);
+    }
+    createFunction(name, args, returnType, bodyContent) {
+        this.addElement(new FunctionDef(name, args, returnType, bodyContent));
+    }
+    nearestNamespace() {
+        return _.findLast(this.pathToRoot(), element => element instanceof NamespaceDef);
+    }
+    fqName(rawName) {
+        const namespaceDef = this.nearestNamespace();
+        return this.pathTo(namespaceDef).slice(1, -1).map(e => capitalize(e.name)).join('') + rawName;
+    }
+    asTypeDecl() {
+        return this.typeName() ? ` as ${this.typeName()}` : '';
+    }
+    writeBody(writer) {
+        this.forEach(FunctionDef, def => {
+            writer.println(`${def.name}(${def.args.asParameterDeclaration()}):${def.returnType} {`);
+            writer.indent(writer => def.writeBody(writer));
+            writer.println(`},`);
+        });
+        this.forEach(ObjectDef, def => {
+            writer.println(`${def.name}: {`);
+            writer.indent(writer => def.writeBody(writer));
+            writer.println(`}${def.asTypeDecl()},`);
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2JqZWN0RGVmLmNsYXNzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9hc3Qvb2JqZWN0RGVmLmNsYXNzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxDQUFDLE1BQU0sUUFBUSxDQUFDO0FBSTVCLE9BQU8sRUFBQyx3QkFBd0IsRUFBQyxNQUFNLDRCQUE0QixDQUFDO0FBSXBFLE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSxzQkFBc0IsQ0FBQztBQUNsRCxPQUFPLEVBQUMsV0FBVyxFQUFDLE1BQU0scUJBQXFCLENBQUM7QUFDaEQsT0FBTyxFQUFDLFVBQVUsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUd6QyxNQUFNLE9BQU8sU0FBVSxTQUFRLHdCQUF3QjtJQUluRCxZQUFZLElBQVc7UUFDbkIsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDO1FBSFIsY0FBUyxHQUFVLElBQUksQ0FBQztJQUloQyxDQUFDO0lBRUQsTUFBTSxDQUFDLFFBQWU7UUFDbEIsSUFBSSxDQUFDLFNBQVMsR0FBRyxRQUFRLENBQUM7UUFDMUIsT0FBTyxJQUFJLENBQUM7SUFDaEIsQ0FBQztJQUVELFFBQVE7UUFDSixPQUFPLElBQUksQ0FBQyxTQUFTLENBQUM7SUFDMUIsQ0FBQztJQUVELGVBQWUsQ0FBQyxJQUFZLEVBQUUsU0FBOEM7UUFDeEUsSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLFNBQVMsQ0FBQyxJQUFJLENBQUMsRUFBRSxTQUFTLENBQUMsQ0FBQTtJQUNuRCxDQUFDO0lBRUQsZUFBZSxDQUFDLElBQVksRUFBRSxTQUFzQztRQUNoRSxPQUFPLElBQUksQ0FBQyxnQkFBZ0IsRUFBRSxDQUFDLGVBQWUsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxFQUFFLFNBQVMsQ0FBQyxDQUFDO0lBQ2pGLENBQUM7SUFFRCxXQUFXLENBQUMsSUFBWSxFQUFFLElBQWUsRUFBRSxTQUFrQztRQUN6RSxPQUFPLElBQUksQ0FBQyxnQkFBZ0IsRUFBRSxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxFQUFFLElBQUksRUFBRSxTQUFTLENBQUMsQ0FBQztJQUNuRixDQUFDO0lBRUQsVUFBVSxDQUFDLElBQVksRUFBRSxLQUFZO1FBQ2pDLE9BQU8sSUFBSSxDQUFDLGdCQUFnQixFQUFFLENBQUMsVUFBVSxDQUFDLElBQUksRUFBRSxLQUFLLENBQUMsQ0FBQztJQUMzRCxDQUFDO0lBRUQsWUFBWSxDQUFDLElBQVksRUFBRSxTQUFtQztRQUMxRCxPQUFPLElBQUksQ0FBQyxVQUFVLENBQUMsSUFBSSxTQUFTLENBQUMsSUFBSSxDQUFDLEVBQUUsU0FBUyxDQUFDLENBQUM7SUFDM0QsQ0FBQztJQUVELGNBQWMsQ0FBQyxJQUFZLEVBQUUsSUFBZSxFQUFFLFVBQWtCLEVBQUUsV0FBa0M7UUFDaEcsSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLFdBQVcsQ0FBQyxJQUFJLEVBQUUsSUFBSSxFQUFFLFVBQVUsRUFBRSxXQUFXLENBQUMsQ0FBQyxDQUFBO0lBQ3pFLENBQUM7SUFFUyxnQkFBZ0I7UUFDdEIsT0FBTyxDQUFDLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxVQUFVLEVBQUUsRUFBRSxPQUFPLENBQUMsRUFBRSxDQUFDLE9BQU8sWUFBWSxZQUFZLENBQWlCLENBQUM7SUFDckcsQ0FBQztJQUVTLE1BQU0sQ0FBQyxPQUFjO1FBQzNCLE1BQU0sWUFBWSxHQUFHLElBQUksQ0FBQyxnQkFBZ0IsRUFBRSxDQUFDO1FBQzdDLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxZQUFZLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsR0FBRyxPQUFPLENBQUM7SUFDakcsQ0FBQztJQUVELFVBQVU7UUFDTixPQUFPLElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQyxDQUFDLENBQUMsT0FBTyxJQUFJLENBQUMsUUFBUSxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDO0lBQzNELENBQUM7SUFFRCxTQUFTLENBQUMsTUFBYztRQUNwQixJQUFJLENBQUMsT0FBTyxDQUFDLFdBQVcsRUFBRSxHQUFHLENBQUMsRUFBRTtZQUM1QixNQUFNLENBQUMsT0FBTyxDQUFDLEdBQUcsR0FBRyxDQUFDLElBQUksSUFBSSxHQUFHLENBQUMsSUFBSSxDQUFDLHNCQUFzQixFQUFFLEtBQUssR0FBRyxDQUFDLFVBQVUsSUFBSSxDQUFDLENBQUM7WUFDeEYsTUFBTSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLEdBQUcsQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQztZQUMvQyxNQUFNLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ3pCLENBQUMsQ0FBQyxDQUFDO1FBRUgsSUFBSSxDQUFDLE9BQU8sQ0FBQyxTQUFTLEVBQUUsR0FBRyxDQUFDLEVBQUU7WUFDMUIsTUFBTSxDQUFDLE9BQU8sQ0FBQyxHQUFHLEdBQUcsQ0FBQyxJQUFJLEtBQUssQ0FBQyxDQUFDO1lBQ2pDLE1BQU0sQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxHQUFHLENBQUMsU0FBUyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUM7WUFDL0MsTUFBTSxDQUFDLE9BQU8sQ0FBQyxJQUFJLEdBQUcsQ0FBQyxVQUFVLEVBQUUsR0FBRyxDQUFDLENBQUM7UUFDNUMsQ0FBQyxDQUFDLENBQUE7SUFDTixDQUFDO0NBRUoifQ==

package/build/module/lib/ast/tempContainer.class.d.ts

@@ -0,0 +1,4 @@
+import { ObjectDef } from "./objectDef.class";
+export declare class TempContainer extends ObjectDef {
+    constructor();
+}

package/build/module/lib/ast/tempContainer.class.js

@@ -0,0 +1,9 @@
+import { ObjectDef } from "./objectDef.class";
+// Exists to create structures that don't automatically get
+// written out by their parents.
+export class TempContainer extends ObjectDef {
+    constructor() {
+        super('!!temp!!');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVtcENvbnRhaW5lci5jbGFzcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvYXN0L3RlbXBDb250YWluZXIuY2xhc3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFDLFNBQVMsRUFBQyxNQUFNLG1CQUFtQixDQUFDO0FBRTVDLDJEQUEyRDtBQUMzRCxnQ0FBZ0M7QUFDaEMsTUFBTSxPQUFPLGFBQWMsU0FBUSxTQUFTO0lBQ3hDO1FBQ0ksS0FBSyxDQUFDLFVBQVUsQ0FBQyxDQUFDO0lBQ3RCLENBQUM7Q0FDSiJ9

package/build/module/lib/ast/typeDef.class.d.ts

@@ -0,0 +1,7 @@
+import { Writer } from "../writer.class";
+import { AbstractElement } from "./abstractElement";
+export declare class TypeDef extends AbstractElement {
+    readonly value: string;
+    constructor(name: string, value: string);
+    writeBody(writer: Writer): void;
+}

package/build/module/lib/ast/typeDef.class.js

@@ -0,0 +1,11 @@
+import { AbstractElement } from "./abstractElement";
+export class TypeDef extends AbstractElement {
+    constructor(name, value) {
+        super(name);
+        this.value = value;
+    }
+    writeBody(writer) {
+        // noop
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZURlZi5jbGFzcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvYXN0L3R5cGVEZWYuY2xhc3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFDLGVBQWUsRUFBQyxNQUFNLG1CQUFtQixDQUFDO0FBRWxELE1BQU0sT0FBTyxPQUFRLFNBQVEsZUFBZTtJQUV4QyxZQUFZLElBQVksRUFBa0IsS0FBWTtRQUNsRCxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUM7UUFEMEIsVUFBSyxHQUFMLEtBQUssQ0FBTztJQUV0RCxDQUFDO0lBRUQsU0FBUyxDQUFDLE1BQWM7UUFDcEIsT0FBTztJQUNYLENBQUM7Q0FDSiJ9

package/build/module/lib/bin/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/module/lib/bin/cli.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import * as fs from 'fs';
+import program from 'commander';
+import glob from "glob";
+import { I18nGenerator } from "../i18nGenerator";
+let globPattern;
+let outputFile;
+program
+    .version('0.1.0')
+    .arguments('<glob> <out>')
+    .action(function (glob, out) {
+    globPattern = glob;
+    outputFile = out;
+})
+    .parse(process.argv);
+if (typeof globPattern === 'undefined') {
+    console.error('no glob pattern specified!');
+    process.exit(1);
+}
+if (typeof outputFile === 'undefined') {
+    console.error('no output file specified!');
+    process.exit(1);
+}
+glob(`${globPattern}`, {}, function (error, files) {
+    // files is an array of filenames.
+    // If the `nonull` option is set, and nothing
+    // was found, then files is ["**/*.js"]
+    // er is an error object or null.
+    if (error) {
+        console.error(error);
+        process.exit(1);
+    }
+    if (files.length < 1) {
+        console.log('no files found.');
+    }
+    else {
+        const gen = new I18nGenerator();
+        files.forEach(f => gen.readFile(f));
+        fs.writeFileSync(outputFile, gen.toString());
+    }
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9iaW4vY2xpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFDQSxPQUFPLEtBQUssRUFBRSxNQUFNLElBQUksQ0FBQztBQUN6QixPQUFPLE9BQU8sTUFBTSxXQUFXLENBQUM7QUFDaEMsT0FBTyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBRXhCLE9BQU8sRUFBQyxhQUFhLEVBQUMsTUFBTSxrQkFBa0IsQ0FBQztBQUUvQyxJQUFJLFdBQVcsQ0FBQztBQUNoQixJQUFJLFVBQVUsQ0FBQztBQUVmLE9BQU87S0FDSixPQUFPLENBQUMsT0FBTyxDQUFDO0tBQ2hCLFNBQVMsQ0FBQyxjQUFjLENBQUM7S0FDekIsTUFBTSxDQUFDLFVBQVUsSUFBSSxFQUFFLEdBQUc7SUFDekIsV0FBVyxHQUFHLElBQUksQ0FBQztJQUNuQixVQUFVLEdBQUcsR0FBRyxDQUFDO0FBQ25CLENBQUMsQ0FBQztLQUNELEtBQUssQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUM7QUFFdkIsSUFBSSxPQUFPLFdBQVcsS0FBSyxXQUFXLEVBQUU7SUFDdEMsT0FBTyxDQUFDLEtBQUssQ0FBQyw0QkFBNEIsQ0FBQyxDQUFDO0lBQzVDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUM7Q0FDakI7QUFFRCxJQUFJLE9BQU8sVUFBVSxLQUFLLFdBQVcsRUFBRTtJQUNyQyxPQUFPLENBQUMsS0FBSyxDQUFDLDJCQUEyQixDQUFDLENBQUM7SUFDM0MsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztDQUNqQjtBQUVELElBQUksQ0FBQyxHQUFHLFdBQVcsRUFBRSxFQUFFLEVBQUUsRUFBRSxVQUFVLEtBQUssRUFBRSxLQUFLO0lBQy9DLGtDQUFrQztJQUNsQyw2Q0FBNkM7SUFDN0MsdUNBQXVDO0lBQ3ZDLGlDQUFpQztJQUNqQyxJQUFJLEtBQUssRUFBRTtRQUNULE9BQU8sQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDckIsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztLQUNqQjtJQUNELElBQUksS0FBSyxDQUFDLE1BQU0sR0FBRyxDQUFDLEVBQUU7UUFDcEIsT0FBTyxDQUFDLEdBQUcsQ0FBQyxpQkFBaUIsQ0FBQyxDQUFBO0tBQy9CO1NBQU07UUFDTCxNQUFNLEdBQUcsR0FBRyxJQUFJLGFBQWEsRUFBRSxDQUFDO1FBQ2hDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDcEMsRUFBRSxDQUFDLGFBQWEsQ0FBQyxVQUFVLEVBQUUsR0FBRyxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUM7S0FDOUM7QUFDSCxDQUFDLENBQUMsQ0FBQyJ9

package/build/module/lib/constructor.class.d.ts

@@ -0,0 +1,3 @@
+export declare type Constructor<T> = {
+    new (...args: any[]): T;
+};

package/build/module/lib/constructor.class.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RydWN0b3IuY2xhc3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL2NvbnN0cnVjdG9yLmNsYXNzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/build/module/lib/customTypeArrayNode.class.d.ts

@@ -0,0 +1,10 @@
+import { ContainerElement } from "./ast/containerElement.class";
+import { Constructor } from "./constructor.class";
+import { I18nNode } from './i18nNode.class';
+export declare class CustomTypeArrayNode extends I18nNode {
+    private customType;
+    static matches(yamlData: any): boolean;
+    parse(container: any): any;
+    protected parseEntry<T extends I18nNode>(name: string, data: any, defaultNodeType: Constructor<T>): I18nNode;
+    compile(parent: ContainerElement): void;
+}

package/build/module/lib/customTypeArrayNode.class.js

@@ -0,0 +1,22 @@
+import { CustomTypeNode } from "./customTypeNode.class";
+import { I18nNode } from './i18nNode.class';
+export class CustomTypeArrayNode extends I18nNode {
+    static matches(yamlData) {
+        return yamlData && yamlData['constructor'] && yamlData['constructor'].name == 'CustomTypeArrayContainer';
+    }
+    parse(container) {
+        this.customType = container['customType'];
+        return super.parse(container['content']);
+    }
+    parseEntry(name, data, defaultNodeType) {
+        return super.parseEntry(name, { customType: this.customType, content: data }, CustomTypeNode);
+    }
+    compile(parent) {
+        parent.nestedContainer(this.namespaceName, namespace => {
+            this.eachChild(child => {
+                child.compile(namespace);
+            });
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VzdG9tVHlwZUFycmF5Tm9kZS5jbGFzcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvY3VzdG9tVHlwZUFycmF5Tm9kZS5jbGFzcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUMsY0FBYyxFQUFDLE1BQU0sd0JBQXdCLENBQUM7QUFFdEQsT0FBTyxFQUFDLFFBQVEsRUFBQyxNQUFNLGtCQUFrQixDQUFDO0FBRzFDLE1BQU0sT0FBTyxtQkFBb0IsU0FBUSxRQUFRO0lBRy9DLE1BQU0sQ0FBQyxPQUFPLENBQUMsUUFBYTtRQUMxQixPQUFPLFFBQVEsSUFBSSxRQUFRLENBQUMsYUFBYSxDQUFDLElBQUksUUFBUSxDQUFDLGFBQWEsQ0FBQyxDQUFDLElBQUksSUFBSSwwQkFBMEIsQ0FBQTtJQUMxRyxDQUFDO0lBRUQsS0FBSyxDQUFDLFNBQWM7UUFDbEIsSUFBSSxDQUFDLFVBQVUsR0FBRyxTQUFTLENBQUMsWUFBWSxDQUFlLENBQUM7UUFDeEQsT0FBTyxLQUFLLENBQUMsS0FBSyxDQUFDLFNBQVMsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDO0lBQzNDLENBQUM7SUFFUyxVQUFVLENBQXFCLElBQVksRUFBRSxJQUFTLEVBQUUsZUFBK0I7UUFDL0YsT0FBTyxLQUFLLENBQUMsVUFBVSxDQUFDLElBQUksRUFBRSxFQUFDLFVBQVUsRUFBRSxJQUFJLENBQUMsVUFBVSxFQUFFLE9BQU8sRUFBRSxJQUFJLEVBQUMsRUFBRSxjQUFjLENBQUMsQ0FBQztJQUM5RixDQUFDO0lBRUQsT0FBTyxDQUFDLE1BQXdCO1FBQzlCLE1BQU0sQ0FBQyxlQUFlLENBQUMsSUFBSSxDQUFDLGFBQWEsRUFBRSxTQUFTLENBQUMsRUFBRTtZQUNyRCxJQUFJLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxFQUFFO2dCQUNyQixLQUFLLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxDQUFDO1lBQzNCLENBQUMsQ0FBQyxDQUFDO1FBQ0wsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDO0NBRUYifQ==

package/build/module/lib/customTypeNode.class.d.ts

@@ -0,0 +1,23 @@
+import { I18nNode } from "./i18nNode.class";
+import { TextNode } from "./textNode.class";
+import { TextArrayNode } from "./textArrayNode.class";
+import { ContainerElement } from "./ast/containerElement.class";
+import { Constructor } from "./constructor.class";
+declare class CustomTextNode extends TextNode {
+    static matches(yamlData: any): boolean;
+    compile(container: ContainerElement): void;
+}
+declare class CustomTextArrayNode extends TextArrayNode {
+    static matches(yamlData: any): boolean;
+    compile(container: ContainerElement): void;
+    createFunctionBody(out: any): void;
+}
+export declare class CustomTypeNode extends I18nNode {
+    private customType;
+    static matches(yamlData: any): boolean;
+    supportedChildNodeTypes(): (typeof CustomTextArrayNode | typeof CustomTextNode)[];
+    parse(container: any): void;
+    protected parseEntry<T extends I18nNode>(name: string, data: any, defaultNodeType: Constructor<T>): I18nNode;
+    compile(parent: ContainerElement): any;
+}
+export {};

package/build/module/lib/customTypeNode.class.js

@@ -0,0 +1,68 @@
+import { I18nNode } from "./i18nNode.class";
+import { TextNode } from "./textNode.class";
+import { TextArrayNode } from "./textArrayNode.class";
+import { Arguments } from "./arguments.class";
+import { ObjectDef } from "./ast/objectDef.class";
+class CustomTextNode extends TextNode {
+    static matches(yamlData) {
+        return TextNode.matches(yamlData);
+    }
+    compile(container) {
+        // we get our args from our outer function.
+        container.createFunction(this.javaScriptName, Arguments.empty(), 'string', out => {
+            this.createFunctionBody(out);
+        });
+    }
+}
+class CustomTextArrayNode extends TextArrayNode {
+    static matches(yamlData) {
+        return TextArrayNode.matches(yamlData);
+    }
+    compile(container) {
+        container.createFunction(this.javaScriptName, Arguments.empty(), 'string[]', out => {
+            this.createFunctionBody(out);
+        });
+    }
+    createFunctionBody(out) {
+        out.println(`return [`);
+        this.eachChild(node => {
+            out.indent(out => {
+                out.println(`function() {`); // we get our args from our outer function.
+                out.indent(out => node.createFunctionBody(out));
+                out.println(`}(),`);
+            });
+        });
+        out.println(`];`);
+    }
+}
+export class CustomTypeNode extends I18nNode {
+    static matches(yamlData) {
+        return yamlData && yamlData['constructor'] && yamlData['constructor'].name == 'CustomTypeContainer';
+    }
+    supportedChildNodeTypes() {
+        return [CustomTextArrayNode, CustomTextNode];
+    }
+    parse(container) {
+        this.customType = container['customType'];
+        super.parse(container['content']);
+        this.eachChild(child => this.getArgs().merge(child.getArgs()));
+    }
+    parseEntry(name, data, defaultNodeType) {
+        // console.log(defaultNodeType);
+        return super.parseEntry(name, data, defaultNodeType);
+    }
+    compile(parent) {
+        const tempContainer = new ObjectDef('!temp!');
+        this.eachChild(child => {
+            child.compile(tempContainer);
+        });
+        parent.createFunction(this.javaScriptName, this.getArgs(), this.customType.className, body => {
+            body.println('return {');
+            body.indent(out => {
+                tempContainer.writeBody(out);
+            });
+            body.println('}');
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/lib/enumNode.class.d.ts

@@ -0,0 +1,10 @@
+import { I18nNode } from './i18nNode.class';
+import { ContainerElement } from "./ast/containerElement.class";
+import { Constructor } from "./constructor.class";
+export declare class EnumNode extends I18nNode {
+    static matches(yamlData: any): boolean;
+    parse(enumResourceContainer: any): any;
+    protected parseEntry<T extends I18nNode>(name: string, data: any, defaultNodeType: Constructor<T>): I18nNode;
+    compile(parent: ContainerElement): void;
+    lookupKeys(): string[];
+}

package/build/module/lib/enumNode.class.js

@@ -0,0 +1,105 @@
+import { I18nNode } from './i18nNode.class';
+import { TextNode } from "./textNode.class";
+import { Arguments } from "./arguments.class";
+import { ObjectDef } from "./ast/objectDef.class";
+import { FunctionDef } from "./ast/functionDef.class";
+import { NameSpaceNode } from "./namespaceNode.class";
+class EnumMethodNode extends TextNode {
+}
+class EnumEntryNode extends I18nNode {
+    // static matches(data:any) {
+    //     return true;
+    // }
+    compile(parent, typeName) {
+        parent.createObject(this.namespaceName, def => {
+            def.asType(typeName);
+            this.eachChild(child => child.compile(def));
+        });
+    }
+}
+export class EnumNode extends I18nNode {
+    static matches(yamlData) {
+        return yamlData && yamlData['constructor'] && yamlData['constructor'].name === 'EnumResourceContainer';
+    }
+    // protected supportedChildNodeTypes(): NodeConstructor<any>[] {
+    //     return [EnumEntryNode];
+    // }
+    parse(enumResourceContainer) {
+        return super.parse(enumResourceContainer['content']);
+    }
+    parseEntry(name, data, defaultNodeType) {
+        if (defaultNodeType['name'] === NameSpaceNode['name']) {
+            return super.parseEntry(name, data, EnumEntryNode);
+        }
+        else {
+            throw new Error(`entry '${name}' in '${this.accessor}' is not an object. !Enum children to be an object.`);
+        }
+    }
+    compile(parent) {
+        parent.nestedContainer(this.namespaceName, namespace => {
+            const enumType = namespace.defineInterface(`${this.className}Entry`);
+            // only process enum entry nodes for now so we guarantee all the children
+            // are enum types.
+            this.eachChild(child => {
+                child.compile(namespace, enumType.name);
+            });
+            const enums = namespace.allOfType(ObjectDef);
+            enums[0].forEach(FunctionDef, f => {
+                enumType.createFunction(f.name, f.args, f.returnType);
+            });
+            enums[0].forEach(ObjectDef, f => {
+                enumType.createObject(f.name, f.typeName());
+            });
+            // compile the rest of the children.
+            // this.eachChild(child => {
+            // if (!(child instanceof EnumEntryNode)) {
+            //     child.compile(namespace);
+            // }
+            // });
+            const enumKeyType = `${this.fqClassName}Key`;
+            namespace.defineType(enumKeyType, this.children.map(child => `'${child.camelCaseName}'`).join('|'));
+            // now create our lookup functions for the enum notes
+            namespace.createFunction('lookup', Arguments.create('key', enumKeyType), enumType.name, out => {
+                // this.eachChild(child => {
+                // if (child instanceof EnumEntryNode) {
+                //     out.println(`if (key === '${child.camelCaseName}') { return I18n.${child.accessor}; }`);
+                // }
+                // });
+                out.println(`const result = this.tryLookup(key);`);
+                out.println(`if (!result) {`);
+                out.println(`   throw new Error("Unknown enum key '" + key + "'. Must be one of ${this.lookupKeys().join(', ')}")`);
+                out.println(`}`);
+                out.println(`return result;`);
+            });
+            namespace.createFunction('tryLookup', Arguments.create('key', 'string'), enumType.name, out => {
+                this.eachChild(child => {
+                    // if (child instanceof EnumEntryNode) {
+                    out.println(`if (key === '${child.camelCaseName}') { return I18n.${child.accessor}; }`);
+                    // }
+                });
+                out.println(`return null;`);
+            });
+            namespace.createFunction('nameOf', Arguments.create('option', enumType.name), enumKeyType, out => {
+                this.eachChild(child => {
+                    // if (child instanceof EnumEntryNode) {
+                    out.println(`if (option === I18n.${child.accessor}) { return '${child.camelCaseName}'; }`);
+                    // }
+                });
+                out.println(`throw new Error("Unknown enum")`);
+            });
+            namespace.createFunction('asArray', Arguments.empty(), `${enumType.name}[]`, out => {
+                out.println(`return [`);
+                this.eachChild(child => {
+                    // if (child instanceof EnumEntryNode) {
+                    out.indent(_out => _out.println(`I18n.${child.accessor},`));
+                    // }
+                });
+                out.println(']');
+            });
+        });
+    }
+    lookupKeys() {
+        return this.children.map(child => child.camelCaseName);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/lib/i18nGenerator.d.ts

@@ -0,0 +1,18 @@
+import * as yaml from 'js-yaml';
+export declare class CustomType {
+    readonly className: string;
+    readonly importDeclaration: string;
+    constructor(className: string, importDeclaration: string);
+    asYamlType(): yaml.Type;
+    asYamlListType(): yaml.Type;
+}
+export declare class I18nGenerator {
+    private rootNode;
+    private customTypes;
+    private _schema;
+    constructor();
+    registerType(typeName: string, importDeclaration: string): void;
+    readFile(fileName: string): void;
+    getSchema(): yaml.Schema;
+    toString(): string;
+}

package/build/module/lib/i18nGenerator.js

@@ -0,0 +1,124 @@
+import * as fs from 'fs';
+import * as yaml from 'js-yaml';
+import { Module } from "./ast/moduleDef.class";
+import { CustomTypeArrayNode } from "./customTypeArrayNode.class";
+import { CustomTypeNode } from "./customTypeNode.class";
+import { EnumNode } from "./enumNode.class";
+import { NameSpaceNode } from "./namespaceNode.class";
+import { RootNode } from "./rootNode.class";
+import { TextArrayNode } from "./textArrayNode.class";
+import { TextNode } from "./textNode.class";
+import { ValueNode } from "./valueNode.class";
+import { RootWriter } from "./writer.class";
+// TODO: use factories
+// interface NodeFactory<T extends Node> {
+//     matches(data:any):boolean;
+//     create(name:string, data:any):T;
+// }
+class EnumResourceContainer {
+    constructor(content) {
+        this.content = content;
+    }
+}
+class CustomTypeContainer {
+    constructor(customType, content) {
+        this.customType = customType;
+        this.content = content;
+    }
+}
+class CustomTypeArrayContainer {
+    constructor(customType, content) {
+        this.customType = customType;
+        this.content = content;
+    }
+}
+// TODO: merge this with nodes, so nodes become a type, not sure if this will be easy to do or not as
+// we don't have the key name at this point.  Might have to put it all in the factory so it can be called
+// to embed a marker in the data and use that when checking the node type.
+const EnumResourceType = new yaml.Type('!Enum', {
+    kind: 'mapping',
+    construct: function (data) {
+        data = data || {}; // in case of empty node
+        return new EnumResourceContainer(data);
+    },
+    instanceOf: EnumResourceContainer
+    // `represent` is omitted here. So, Space objects will be dumped as is.
+    // That is regular mapping with three key-value pairs but with !space tag.
+});
+export class CustomType {
+    constructor(className, importDeclaration) {
+        this.className = className;
+        this.importDeclaration = importDeclaration;
+    }
+    asYamlType() {
+        const self = this;
+        return new yaml.Type(`!${this.className}`, {
+            kind: 'mapping',
+            construct: function (data) {
+                data = data || {}; // in case of empty node
+                return new CustomTypeContainer(self, data);
+            },
+            instanceOf: CustomTypeContainer
+            // `represent` is omitted here. So, Space objects will be dumped as is.
+            // That is regular mapping with three key-value pairs but with !space tag.
+        });
+    }
+    asYamlListType() {
+        const self = this;
+        return new yaml.Type(`!List(${this.className})`, {
+            kind: 'mapping',
+            construct: function (data) {
+                data = data || {}; // in case of empty node
+                return new CustomTypeArrayContainer(self, data);
+            },
+            instanceOf: CustomTypeArrayContainer
+            // `represent` is omitted here. So, Space objects will be dumped as is.
+            // That is regular mapping with three key-value pairs but with !space tag.
+        });
+    }
+}
+// TODO: replace custom gulp task with https://www.npmjs.com/package/gulp-reduce-file
+export class I18nGenerator {
+    constructor() {
+        this.customTypes = [];
+        this.rootNode = new RootNode();
+        this.rootNode.registerNodeTypes([
+            CustomTypeArrayNode, CustomTypeNode, EnumNode, TextNode, TextArrayNode, ValueNode, NameSpaceNode
+        ]);
+        this.registerType('Alert', 'import {Alert} from "@coolon/i18n-resource"');
+        this.registerType('Confirm', 'import {Confirm} from "@coolon/i18n-resource"');
+    }
+    registerType(typeName, importDeclaration) {
+        this.customTypes.push(new CustomType(typeName, importDeclaration));
+    }
+    readFile(fileName) {
+        let options = { schema: this.getSchema() };
+        console.log(`Loading: ${fileName}`);
+        const yamlData = yaml.safeLoad(fs.readFileSync(fileName, 'utf8'), { schema: this.getSchema() });
+        try {
+            this.rootNode.parse(yamlData);
+        }
+        catch (e) {
+            throw new Error(`Failed to parse file:${fileName}\n-> ${e.message}\n-> ${e.stack}`);
+        }
+    }
+    getSchema() {
+        if (!this._schema) {
+            let types = [].concat(EnumResourceType, this.customTypes.map(type => type.asYamlType()), this.customTypes.map(type => type.asYamlListType()));
+            this._schema = yaml.Schema.create(types);
+            console.log(`using schema: ${JSON.stringify(this._schema)}`);
+        }
+        return this._schema;
+    }
+    toString() {
+        const writer = new RootWriter();
+        const module = new Module();
+        this.customTypes.forEach(type => {
+            module.addImport(type.importDeclaration);
+        });
+        this.rootNode.compile(module);
+        module.writeBody(writer);
+        return writer.toString();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaTE4bkdlbmVyYXRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvaTE4bkdlbmVyYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxNQUFNLElBQUksQ0FBQztBQUN6QixPQUFPLEtBQUssSUFBSSxNQUFNLFNBQVMsQ0FBQztBQUNoQyxPQUFPLEVBQUMsTUFBTSxFQUFDLE1BQU0sdUJBQXVCLENBQUM7QUFDN0MsT0FBTyxFQUFDLG1CQUFtQixFQUFDLE1BQU0sNkJBQTZCLENBQUM7QUFDaEUsT0FBTyxFQUFDLGNBQWMsRUFBQyxNQUFNLHdCQUF3QixDQUFDO0FBRXRELE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxrQkFBa0IsQ0FBQztBQUMxQyxPQUFPLEVBQUMsYUFBYSxFQUFDLE1BQU0sdUJBQXVCLENBQUM7QUFDcEQsT0FBTyxFQUFDLFFBQVEsRUFBQyxNQUFNLGtCQUFrQixDQUFDO0FBQzFDLE9BQU8sRUFBQyxhQUFhLEVBQUMsTUFBTSx1QkFBdUIsQ0FBQztBQUNwRCxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sa0JBQWtCLENBQUM7QUFDMUMsT0FBTyxFQUFDLFNBQVMsRUFBQyxNQUFNLG1CQUFtQixDQUFDO0FBQzVDLE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSxnQkFBZ0IsQ0FBQztBQUkxQyxzQkFBc0I7QUFDdEIsMENBQTBDO0FBQzFDLGlDQUFpQztBQUNqQyx1Q0FBdUM7QUFDdkMsSUFBSTtBQUVKLE1BQU0scUJBQXFCO0lBQ3pCLFlBQTRCLE9BQVk7UUFBWixZQUFPLEdBQVAsT0FBTyxDQUFLO0lBQ3hDLENBQUM7Q0FDRjtBQUVELE1BQU0sbUJBQW1CO0lBQ3ZCLFlBQTRCLFVBQXNCLEVBQWtCLE9BQVk7UUFBcEQsZUFBVSxHQUFWLFVBQVUsQ0FBWTtRQUFrQixZQUFPLEdBQVAsT0FBTyxDQUFLO0lBQ2hGLENBQUM7Q0FDRjtBQUVELE1BQU0sd0JBQXdCO0lBQzVCLFlBQTRCLFVBQXNCLEVBQWtCLE9BQVk7UUFBcEQsZUFBVSxHQUFWLFVBQVUsQ0FBWTtRQUFrQixZQUFPLEdBQVAsT0FBTyxDQUFLO0lBQ2hGLENBQUM7Q0FDRjtBQUVELHFHQUFxRztBQUNyRyx5R0FBeUc7QUFDekcsMEVBQTBFO0FBQzFFLE1BQU0sZ0JBQWdCLEdBQUcsSUFBSSxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRTtJQUM5QyxJQUFJLEVBQUUsU0FBUztJQUNmLFNBQVMsRUFBRSxVQUFVLElBQUk7UUFDdkIsSUFBSSxHQUFHLElBQUksSUFBSSxFQUFFLENBQUMsQ0FBQyx3QkFBd0I7UUFDM0MsT0FBTyxJQUFJLHFCQUFxQixDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ3pDLENBQUM7SUFDRCxVQUFVLEVBQUUscUJBQXFCO0lBQ2pDLHVFQUF1RTtJQUN2RSwwRUFBMEU7Q0FDM0UsQ0FBQyxDQUFDO0FBR0gsTUFBTSxPQUFPLFVBQVU7SUFDckIsWUFBNEIsU0FBaUIsRUFBa0IsaUJBQXlCO1FBQTVELGNBQVMsR0FBVCxTQUFTLENBQVE7UUFBa0Isc0JBQWlCLEdBQWpCLGlCQUFpQixDQUFRO0lBQ3hGLENBQUM7SUFFRCxVQUFVO1FBQ1IsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDO1FBQ2xCLE9BQU8sSUFBSSxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksSUFBSSxDQUFDLFNBQVMsRUFBRSxFQUFFO1lBQ3pDLElBQUksRUFBRSxTQUFTO1lBQ2YsU0FBUyxFQUFFLFVBQVUsSUFBSTtnQkFDdkIsSUFBSSxHQUFHLElBQUksSUFBSSxFQUFFLENBQUMsQ0FBQyx3QkFBd0I7Z0JBQzNDLE9BQU8sSUFBSSxtQkFBbUIsQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLENBQUM7WUFDN0MsQ0FBQztZQUNELFVBQVUsRUFBRSxtQkFBbUI7WUFDL0IsdUVBQXVFO1lBQ3ZFLDBFQUEwRTtTQUMzRSxDQUFDLENBQUE7SUFDSixDQUFDO0lBRUQsY0FBYztRQUNaLE1BQU0sSUFBSSxHQUFHLElBQUksQ0FBQztRQUNsQixPQUFPLElBQUksSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLElBQUksQ0FBQyxTQUFTLEdBQUcsRUFBRTtZQUMvQyxJQUFJLEVBQUUsU0FBUztZQUNmLFNBQVMsRUFBRSxVQUFVLElBQUk7Z0JBQ3ZCLElBQUksR0FBRyxJQUFJLElBQUksRUFBRSxDQUFDLENBQUMsd0JBQXdCO2dCQUMzQyxPQUFPLElBQUksd0JBQXdCLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxDQUFDO1lBQ2xELENBQUM7WUFDRCxVQUFVLEVBQUUsd0JBQXdCO1lBQ3BDLHVFQUF1RTtZQUN2RSwwRUFBMEU7U0FDM0UsQ0FBQyxDQUFBO0lBQ0osQ0FBQztDQUNGO0FBR0QscUZBQXFGO0FBQ3JGLE1BQU0sT0FBTyxhQUFhO0lBTXhCO1FBSFEsZ0JBQVcsR0FBaUIsRUFBRSxDQUFDO1FBSXJDLElBQUksQ0FBQyxRQUFRLEdBQUcsSUFBSSxRQUFRLEVBQUUsQ0FBQztRQUMvQixJQUFJLENBQUMsUUFBUSxDQUFDLGlCQUFpQixDQUFDO1lBQzlCLG1CQUFtQixFQUFFLGNBQWMsRUFBRSxRQUFRLEVBQUUsUUFBUSxFQUFFLGFBQWEsRUFBRSxTQUFTLEVBQUUsYUFBYTtTQUNqRyxDQUFDLENBQUM7UUFDSCxJQUFJLENBQUMsWUFBWSxDQUFDLE9BQU8sRUFBRSw2Q0FBNkMsQ0FBQyxDQUFDO1FBQzFFLElBQUksQ0FBQyxZQUFZLENBQUMsU0FBUyxFQUFFLCtDQUErQyxDQUFDLENBQUM7SUFDaEYsQ0FBQztJQUVELFlBQVksQ0FBQyxRQUFnQixFQUFFLGlCQUF5QjtRQUN0RCxJQUFJLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQyxJQUFJLFVBQVUsQ0FBQyxRQUFRLEVBQUUsaUJBQWlCLENBQUMsQ0FBQyxDQUFDO0lBQ3JFLENBQUM7SUFHRCxRQUFRLENBQUMsUUFBZ0I7UUFDdkIsSUFBSSxPQUFPLEdBQUcsRUFBQyxNQUFNLEVBQUUsSUFBSSxDQUFDLFNBQVMsRUFBRSxFQUFDLENBQUM7UUFDekMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxZQUFZLFFBQVEsRUFBRSxDQUFDLENBQUM7UUFDcEMsTUFBTSxRQUFRLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxFQUFFLENBQUMsWUFBWSxDQUFDLFFBQVEsRUFBRSxNQUFNLENBQUMsRUFBRSxFQUFDLE1BQU0sRUFBRSxJQUFJLENBQUMsU0FBUyxFQUFFLEVBQUMsQ0FBQyxDQUFDO1FBQzlGLElBQUk7WUFDRixJQUFJLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxRQUFRLENBQUMsQ0FBQztTQUMvQjtRQUFDLE9BQU8sQ0FBQyxFQUFFO1lBQ1YsTUFBTSxJQUFJLEtBQUssQ0FBQyx3QkFBd0IsUUFBUSxRQUFRLENBQUMsQ0FBQyxPQUFPLFFBQVEsQ0FBQyxDQUFDLEtBQUssRUFBRSxDQUFDLENBQUE7U0FDcEY7SUFDSCxDQUFDO0lBRUQsU0FBUztRQUNQLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFO1lBQ2pCLElBQUksS0FBSyxHQUFHLEVBQUUsQ0FBQyxNQUFNLENBQ25CLGdCQUFnQixFQUNoQixJQUFJLENBQUMsV0FBVyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQyxFQUMvQyxJQUFJLENBQUMsV0FBVyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxjQUFjLEVBQUUsQ0FBQyxDQUNwRCxDQUFDO1lBQ0YsSUFBSSxDQUFDLE9BQU8sR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQztZQUN6QyxPQUFPLENBQUMsR0FBRyxDQUFDLGlCQUFpQixJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDLENBQUE7U0FDN0Q7UUFDRCxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUM7SUFDdEIsQ0FBQztJQUVELFFBQVE7UUFDTixNQUFNLE1BQU0sR0FBRyxJQUFJLFVBQVUsRUFBRSxDQUFDO1FBQ2hDLE1BQU0sTUFBTSxHQUFHLElBQUksTUFBTSxFQUFFLENBQUM7UUFDNUIsSUFBSSxDQUFDLFdBQVcsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLEVBQUU7WUFDOUIsTUFBTSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsaUJBQWlCLENBQUMsQ0FBQztRQUMzQyxDQUFDLENBQUMsQ0FBQztRQUNILElBQUksQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQzlCLE1BQU0sQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLENBQUM7UUFDekIsT0FBTyxNQUFNLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDM0IsQ0FBQztDQUVGIn0=

package/build/module/lib/i18nNode.class.d.ts

@@ -0,0 +1,43 @@
+import { Arguments } from "./arguments.class";
+import { ContainerElement } from "./ast/containerElement.class";
+import { Constructor } from "./constructor.class";
+export declare type NodeConstructor<T extends I18nNode> = {
+    matches(data: any): boolean;
+    new (...args: any[]): T;
+    prototype: T;
+};
+export declare class I18nNode {
+    protected parent: I18nNode;
+    readonly name: string;
+    private childNodes;
+    private templateArgs;
+    constructor(parent: I18nNode, name: string);
+    readonly key: string;
+    /**
+     * Returns the full path to this nodes namespace as used in code.  Doesn't include the I18n prefix.
+     */
+    readonly accessor: string;
+    appendNamespaceTo(collector: string[]): void;
+    isRoot(): boolean;
+    pathToRoot(): I18nNode[];
+    parse(yamlData: any): void;
+    protected parseEntry<T extends I18nNode>(name: string, data: any, defaultNodeType: Constructor<T>): I18nNode;
+    getOrCreatNode(name: any, type: typeof I18nNode): I18nNode;
+    rootNode(): I18nNode;
+    nodeTypes(): NodeConstructor<any>[];
+    protected computeNodeTypeOf(data: any): NodeConstructor<any>;
+    protected supportedChildNodeTypes(): NodeConstructor<any>[];
+    protected withEachProperty(yamlData: any, cb: (name: string, data: any) => void): void;
+    protected readonly children: I18nNode[];
+    protected eachChild(cb: (node: I18nNode) => void): void;
+    getArgs(): Arguments;
+    hasArgs(): boolean;
+    readonly safeName: string;
+    readonly javaScriptName: string;
+    readonly camelCaseName: string;
+    readonly namespaceName: string;
+    readonly className: string;
+    readonly fqClassName: string;
+    readonly snakeCaseName: string;
+    compile(parent: ContainerElement): void;
+}