@accordproject/template-engine 2.0.3 → 2.2.0

package/dist/index.d.ts

@@ -1,2 +1,123 @@
-export { TemplateMarkInterpreter } from './TemplateMarkInterpreter';
-export { TemplateMarkToTypeScriptCompiler } from './TemplateMarkToTypeScriptCompiler';
+import * as _accordproject_concerto_core_types_lib_model_resource from '@accordproject/concerto-core/types/lib/model/resource';
+import { ModelManager, ClassDeclaration, Resource } from '@accordproject/concerto-core';
+import { FileWriter } from '@accordproject/concerto-util';
+
+type TemplateData = Record<string, unknown>;
+
+/**
+ * BEWARE - this type is duplicated in TypeScriptCompilationContext
+ * for use by code generation
+ */
+type GenerationOptions = {
+    now?: string;
+    locale?: string;
+};
+
+/**
+ * A template engine: merges the markup and logic of a template with
+ * JSON data to produce JSON data.
+ */
+declare class TemplateMarkInterpreter {
+    modelManager: ModelManager;
+    templateClass: ClassDeclaration;
+    clauseLibrary: object;
+    constructor(modelManager: ModelManager, clauseLibrary: object, templateConceptFqn?: string);
+    /**
+     * Checks that a TemplateMark JSON document is valid with respect to the
+     * TemplateMark model, as well as the template model.
+     *
+     * Checks:
+     * 1. Variable names are valid properties in the template model
+     * 2. Optional properties have guards
+     * @param {*} templateMark the TemplateMark JSON object
+     * @returns {*} TemplateMark JSON that has been typed checked and has type metadata added
+     * @throws {Error} if the templateMark document is invalid
+     */
+    checkTypes(templateMark: object): object;
+    /**
+     * Compiles the code nodes containing TS to code nodes containing JS.
+     * @param {*} templateMark the TemplateMark JSON object
+     * @returns {*} TemplateMark JSON with JS nodes
+     * @throws {Error} if the templateMark document is invalid
+     */
+    compileTypeScriptToJavaScript(templateMark: object): Promise<object>;
+    validateCiceroMark(ciceroMark: object): _accordproject_concerto_core_types_lib_model_resource;
+    generate(templateMark: object, data: TemplateData, options?: GenerationOptions): Promise<any>;
+}
+
+type CompilationOptions = {
+    skipGenerator?: boolean;
+    skipCopyRuntime?: boolean;
+};
+/**
+ * Converts TemplateMark DOM to a Typescript function, that, when run with JSON data
+ * that conforms to the template model will produce AgreementMark JSON output.
+ */
+declare class TemplateMarkToTypeScriptCompiler {
+    modelManager: ModelManager;
+    templateClass: ClassDeclaration;
+    constructor(modelManager: ModelManager, templateConceptFqn?: string);
+    writeFunction(fw: FileWriter, functionName: string, returnType: string, code: string): void;
+    /**
+     * Get a model manager with templatemark model
+     * @param {string} outputDir the output directory
+     * @returns {ModelManager} the model manager
+     */
+    getTemplateMarkModelManager(): ModelManager;
+    /**
+     * Get a model manager with templatemark model
+     * @param {string} outputDir the output directory
+     * @returns {ModelManager} the model manager
+     */
+    getCiceroMarkModelManager(): ModelManager;
+    generateTypeScript(modelManager: ModelManager, outputDir: string): void;
+    generateSampleData(modelManager: ModelManager, outputDir: string): void;
+    /**
+     * The main iteration function over templatemark. This function
+     * looks up an INodeCompiler that can handle each templatemark node
+     * and delegates to it for code generation.
+     * Note that the result of code generation (a CiceroMark node) is left in
+     * the $result global varianble.
+     * @param {FileWriter} fw  the file writer to use
+     * @param {number} level the indentation level
+     * @param {object} templateMark the templatemark node to iterate over
+     */
+    static doIt(fw: FileWriter, level: number, templateMark: any): void;
+    /**
+     * Converts a TemplateMark document to typescript code that is parameterised
+     * by the 'data' argument.
+     *
+     * The strategy is to traverse the template mark json, converting each node into
+     * typescript statements that add an equivalent ciceromark node. Variables will
+     * pull values from 'data'.
+     *
+     * Conditionals and formulae will call the functions produced by
+     * compileUserCode.
+     *
+     * Note that code generation process is itself recursive, for example, when
+     * a list definition node is encountered the list must be iterated over
+     * based on a variable value coming from data, and code must be
+     * generated to produce each list item.
+     *
+     * All internal variables are prefixed with '$' to ensure (?)
+     * that they cannot collide with end user variable names.
+     *
+     * @param {IDocument} templateMark the TemplateMark Concerto resource
+     * @param {string} outputDir the output directory for code
+     */
+    compileGenerator(templateMark: any, outputDir: string): void;
+    /**
+     * Decompresses the base64 zipped runtime into an output folder.
+     * @param {string} outputDir the output directory to copy the runtime to
+     */
+    copyRuntime(outputDir: string): void;
+    /**
+     * Create package.json for the generated code
+     * @param {string} outputDir the output directory to copy the runtime to
+     */
+    createPackage(outputDir: string): void;
+    compile(templateMark: Resource | any, outputDir: string, options?: CompilationOptions): void;
+    compileUserCode(templateMark: any, outputDir: string): void;
+}
+
+export { TemplateMarkInterpreter, TemplateMarkToTypeScriptCompiler };