@accordproject/template-engine 1.0.0 → 1.0.2

package/src/compilers/Common.ts

@@ -1,215 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { INode } from '../model-gen/org.accordproject.commonmark@0.5.0';
-import { CommonMarkModel,TemplateMarkModel,CiceroMarkModel } from '@accordproject/markdown-common';
-import { FileWriter } from '@accordproject/concerto-util';
-import { ClassDeclaration, ModelUtil } from '@accordproject/concerto-core';
-import { ProcessingFunction } from '../TemplateMarkToTypeScriptCompiler';
-
-export function writeDebug(fw:FileWriter, level:number, concept:any) {
-    fw.writeLine(level, `// ${ModelUtil.getShortName(concept.$class)} ${concept.name ? `(${concept.name})` : ''}`);
-}
-
-export const RUNTIME_DIR = 'runtime';
-
-export function writeImports(fw:FileWriter, level:number, templateClass:ClassDeclaration) {
-    fw.writeLine(level, `import * as CommonMark from './${CommonMarkModel.NAMESPACE}';`);
-    fw.writeLine(level, `import * as CiceroMark from './${CiceroMarkModel.NAMESPACE}';`);
-    fw.writeLine(level, `import * as TemplateModel from './${templateClass.getNamespace()}';`);
-    fw.writeLine(level, 'import dayjs from \'dayjs\';');
-    fw.writeLine(level, 'import * as UserCode from \'./usercode\';');
-    fw.writeLine(level, `import { draftingMap as $draftingMap } from './${RUNTIME_DIR}/drafting';`);
-    fw.writeLine(level, `import * as Runtime from './${RUNTIME_DIR}/TypeScriptRuntime';`);
-}
-export function writeProlog(fw:FileWriter, level:number, templateClass:ClassDeclaration) {
-    fw.writeLine(level, `export function generator(data:TemplateModel.I${templateClass.getName()}, library:any, now:dayjs.Dayjs) : CommonMark.IDocument {`);
-    fw.writeLine(level, `const docNode = {$class: '${CommonMarkModel.NAMESPACE}.Document', xmlns: '${CommonMarkModel.NAMESPACE}', nodes: []} as CommonMark.INode;`);
-    fw.writeLine(level, 'const $nodes:CommonMark.INode[] = [];'); // the stack of output CiceroMark nodes
-    fw.writeLine(level, 'const $data:any[] = [];'); // the stack of 'this' used for data access
-    fw.writeLine(level, 'let $result:any = docNode;'); // document root, or the return value
-    fw.writeLine(level, 'Runtime.push($data, data);'); // push the 'data' to the stack so we have an initial 'this';
-}
-
-export function writeEpilog(fw:FileWriter, level:number) {
-    fw.writeLine(level, 'return $result as CommonMark.IDocument;');
-    fw.writeLine(level, '}');
-}
-
-// allows us to declare local variables without fear of collision
-export function writeOpenGenerateScope(fw:FileWriter, level:number) {
-    fw.writeLine(level, '$result = (() => {');
-}
-
-// closes the scope, calling the anon-function
-// and then pushes the result as a child of the last element of $nodes
-export function writeCloseGenerateScope(fw:FileWriter, level:number) {
-    fw.writeLine(level, '})();');
-    fw.writeLine(level, 'Runtime.addChild($nodes, $result);');
-}
-
-// save $curNode into $stack, so we can pop it when the scope closes
-export function writeOpenNodeScope(fw:FileWriter, level:number) {
-    fw.writeLine(level, 'Runtime.push($nodes, $result);');
-}
-
-// closes the scope, popping the stack and setting $curNode
-export function writeCloseNodeScope(fw:FileWriter, level:number) {
-    fw.writeLine(level, '$result = Runtime.pop($nodes);');
-}
-
-// save $curNode into $stack, so we can pop it when the scope closes
-export function writeOpenDataScope(fw:FileWriter, level:number, name:string, allowUndefined=false) {
-    fw.writeLine(level, `Runtime.push($data, Runtime.peekProperty($data, '${name}', ${allowUndefined}));`);
-}
-
-// closes the scope, popping the stack and setting $curNode
-export function writeCloseDataScope(fw:FileWriter, level:number) {
-    fw.writeLine(level, 'Runtime.pop($data);');
-}
-
-export function getTypeScriptType(ctoFqn: string): string {
-    const ns = ModelUtil.getNamespace(ctoFqn);
-    const type = ModelUtil.getShortName(ctoFqn);
-
-    if (ns === CommonMarkModel.NAMESPACE) {
-        return `CommonMark.I${type}`;
-    }
-    else if (ns === CiceroMarkModel.NAMESPACE) {
-        return `CiceroMark.I${type}`;
-    }
-    else if (ns === TemplateMarkModel.NAMESPACE) {
-        return `CiceroMark.I${type.substring(0, type.length - 'Definition'.length)}`;
-    }
-    else {
-        throw new Error(`No type mapping for ${ctoFqn}`);
-    }
-}
-
-/**
- * Map of a node from template mark to ciceromark
- * @param {INode} templateMarkNode the template mark.
- * @param {boolean} deep when deep is false (the default) child nodes are not copied
- * @returns {INode} the mapped node
- */
-export function makeCiceroMark(templateMarkNode:INode, deep=false): INode {
-    if(!templateMarkNode.$class) {
-        throw new Error('Not a concerto type.');
-    }
-    const json = JSON.parse(JSON.stringify(templateMarkNode));
-    delete json.elementType;
-    if(!deep) {
-        delete json.nodes;
-    }
-    else {
-        if(json.nodes) {
-            json.nodes = json.nodes.map((n:INode) => makeCiceroMark(n,deep));
-        }
-    }
-
-    const ns = ModelUtil.getNamespace(json.$class);
-    const type = ModelUtil.getShortName(json.$class);
-
-    if (ns === TemplateMarkModel.NAMESPACE) {
-        json.$class = `${CiceroMarkModel.NAMESPACE}.${type.substring(0, type.length - 'Definition'.length)}`;
-    }
-
-    return json;
-}
-
-export interface INodeCompiler {
-    enter(fw:FileWriter, level:number, templateMarkNode:INode) : void;
-    generate(fw:FileWriter, level:number, templateMarkNode:INode, doIt:ProcessingFunction) : void;
-    exit(fw:FileWriter, level:number, templateMarkNode:INode) : void;
-}
-
-/**
- * A node compiler that allows code to run on node enter, exit and
- * with a generate method to generate code for the node.
- */
-export abstract class AbstractComplexCompiler implements INodeCompiler {
-
-    leaf:boolean;
-
-    constructor(leaf:boolean) {
-        this.leaf = leaf;
-    }
-
-    isLeaf() : boolean {
-        return this.leaf;
-    }
-
-    enter(fw:FileWriter, level:number,templateMarkNode:INode) {
-        writeDebug(fw, level, templateMarkNode);
-        writeOpenNodeScope(fw,level);
-    }
-
-    abstract generate(fw:FileWriter, level:number, templateMarkNode:INode, doIt:ProcessingFunction) : void;
-
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    exit(fw:FileWriter, level:number) {
-        writeCloseNodeScope(fw,level);
-    }
-}
-
-/**
- * A node compiler that allows a JSON node to be constructed from
- * the data in a templatemark node.
- */
-export abstract class AbstractSimpleCompiler extends AbstractComplexCompiler {
-
-    constructor(leaf:boolean) {
-        super(leaf);
-    }
-
-    abstract getNode(templateMarkNode:INode):INode;
-
-    generate(fw:FileWriter, level:number, templateMarkNode:INode) {
-        const node = this.getNode(templateMarkNode);
-        if(this.isLeaf()) {
-            node.nodes = []; // we are a leaf node, null out child nodes
-        }
-        writeOpenGenerateScope(fw,level);
-        fw.writeLine(level, `return ${JSON.stringify(node)} as ${getTypeScriptType(node.$class)};`);
-        writeCloseGenerateScope(fw,level);
-    }
-}
-
-/**
- * PassThroughNode simply maps data from TemplateMark to
- * CiceroMark, updating namespaces but otherwise leaving
- * the data alone.
- */
-export class PassThrough extends AbstractSimpleCompiler {
-    constructor(leaf:boolean) {
-        super(leaf);
-    }
-    getNode(templateMarkNode:INode):INode {
-        return makeCiceroMark(templateMarkNode) as INode;
-    }
-}
-
-/**
- * Ignore doesn't write any output for a node type
- */
-export class Ignore implements INodeCompiler {
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    enter(fw: FileWriter, level: number, templateMarkNode: INode): void {
-    }
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    generate(fw: FileWriter, level: number, templateMarkNode: INode): void {
-    }
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    exit(fw: FileWriter, level: number, templateMarkNode: INode): void {
-    }
-}

package/src/compilers/Conditional.ts

@@ -1,53 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { FileWriter } from '@accordproject/concerto-util';
-import { TemplateMarkModel } from '@accordproject/markdown-common';
-import { IConditional } from '../model-gen/org.accordproject.ciceromark@0.6.0';
-import { IConditionalDefinition } from '../model-gen/org.accordproject.templatemark@0.4.0';
-import { AbstractComplexCompiler, getTypeScriptType, makeCiceroMark, writeCloseDataScope, writeCloseGenerateScope, writeOpenDataScope, writeOpenGenerateScope } from './Common';
-
-interface INamedConditionalDefinition extends IConditionalDefinition {
-    readonly functionName: string;
-}
-
-export class Conditional extends AbstractComplexCompiler {
-    static TYPE = `${TemplateMarkModel.NAMESPACE}.ConditionalDefinition`;
-    constructor() {
-        super(false);
-    }
-    generate(fw:FileWriter, level:number, templateMarkNode:INamedConditionalDefinition) {
-        const clone = makeCiceroMark(templateMarkNode, true) as IConditional;
-        delete (clone as any).condition;
-        delete (clone as any).dependencies;
-        delete (clone as any).functionName;
-        clone.isTrue = true;
-        writeOpenGenerateScope(fw,level);
-        if(templateMarkNode.condition) {
-            fw.writeLine(level, `const isTrue:boolean = UserCode.${templateMarkNode.functionName}(data,library,now)`);
-        }
-        else {
-            writeOpenDataScope(fw,level,templateMarkNode.name);
-            fw.writeLine(level, 'const isTrue:boolean = Runtime.peek($data);');
-            writeCloseDataScope(fw,level);
-        }
-        fw.writeLine(level, `const curNode = ${JSON.stringify(clone)} as ${getTypeScriptType(templateMarkNode.$class)};`);
-        fw.writeLine(level, '(curNode as CiceroMark.IConditional).isTrue = isTrue;');
-        fw.writeLine(level, 'return curNode;');
-        writeCloseGenerateScope(fw,level);
-        delete templateMarkNode.condition;
-        delete (templateMarkNode as any).whenTrue;
-        delete (templateMarkNode as any).whenFalse;
-
-    }
-}

package/src/compilers/ContractDefinition.ts

@@ -1,31 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { TemplateMarkModel,CiceroMarkModel } from '@accordproject/markdown-common';
-import { IContract } from '../model-gen/org.accordproject.ciceromark@0.6.0';
-import { IContractDefinition } from '../model-gen/org.accordproject.templatemark@0.4.0';
-import { AbstractSimpleCompiler } from './Common';
-
-export class ContractDefinition extends AbstractSimpleCompiler {
-    static TYPE = `${TemplateMarkModel.NAMESPACE}.ContractDefinition`;
-    constructor() {
-        super(false);
-    }
-    getNode(templateMarkNode:IContractDefinition) {
-        return {
-            $class: `${CiceroMarkModel.NAMESPACE}.Contract`,
-            name: templateMarkNode.name,
-            nodes: []
-        } as IContract;
-    }
-}

package/src/compilers/FormattedVariable.ts

@@ -1,41 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { FileWriter } from '@accordproject/concerto-util';
-import { TemplateMarkModel } from '@accordproject/markdown-common';
-import { IFormattedVariable } from '../model-gen/org.accordproject.ciceromark@0.6.0';
-import { IFormattedVariableDefinition } from '../model-gen/org.accordproject.templatemark@0.4.0';
-import { AbstractComplexCompiler, getTypeScriptType, makeCiceroMark, writeCloseDataScope, writeCloseGenerateScope, writeOpenDataScope, writeOpenGenerateScope } from './Common';
-
-export class FormattedVariable extends AbstractComplexCompiler {
-    static TYPE = `${TemplateMarkModel.NAMESPACE}.FormattedVariableDefinition`;
-    constructor() {
-        super(true);
-    }
-    generate(fw:FileWriter, level:number, templateMarkNode:IFormattedVariableDefinition) {
-        const clone = makeCiceroMark(templateMarkNode) as IFormattedVariable;
-        writeOpenGenerateScope(fw,level);
-        if(templateMarkNode.name !== 'this') {
-            writeOpenDataScope(fw,level,templateMarkNode.name);
-        }
-        fw.writeLine(level, `const drafter = $draftingMap.get('${templateMarkNode.elementType}');`);
-        fw.writeLine(level, `const text = drafter ? drafter(Runtime.peek($data), '${templateMarkNode.format}') : JSON.stringify(Runtime.peek($data)) as string;`);
-        if(templateMarkNode.name !== 'this') {
-            writeCloseDataScope(fw,level);
-        }
-        fw.writeLine(level, `const variable:any = ${JSON.stringify(clone)};`);
-        fw.writeLine(level, 'variable.value = text;');
-        fw.writeLine(level, `return variable as ${getTypeScriptType(clone.$class)};`);
-        writeCloseGenerateScope(fw,level);
-    }
-}

package/src/compilers/Formula.ts

@@ -1,36 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { FileWriter } from '@accordproject/concerto-util';
-import { TemplateMarkModel } from '@accordproject/markdown-common';
-import { IFormula } from '../model-gen/org.accordproject.ciceromark@0.6.0';
-import { IFormulaDefinition } from '../model-gen/org.accordproject.templatemark@0.4.0';
-import { AbstractComplexCompiler, getTypeScriptType, makeCiceroMark, writeCloseGenerateScope, writeOpenGenerateScope } from './Common';
-
-export class Formula extends AbstractComplexCompiler {
-    static TYPE = `${TemplateMarkModel.NAMESPACE}.FormulaDefinition`;
-    constructor() {
-        super(true);
-    }
-    generate(fw:FileWriter, level:number, templateMarkNode:IFormulaDefinition) {
-        const clone = makeCiceroMark(templateMarkNode) as IFormula;
-        writeOpenGenerateScope(fw,level);
-        fw.writeLine(level, `const formulaResult = UserCode.${templateMarkNode.name}(data,library,now);`);
-        fw.writeLine(level, 'const text = JSON.stringify(formulaResult);');
-        fw.writeLine(level, `const formula:any = ${JSON.stringify(clone)};`);
-        fw.writeLine(level, 'formula.value = text;');
-        fw.writeLine(level, `formula.code = ${JSON.stringify(templateMarkNode.code.contents)};`); // HACK - update model
-        fw.writeLine(level, `return formula as ${getTypeScriptType(clone.$class)};`);
-        writeCloseGenerateScope(fw,level);
-    }
-}

package/src/compilers/Join.ts

@@ -1,33 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { FileWriter } from '@accordproject/concerto-util';
-import { TemplateMarkModel,CommonMarkModel } from '@accordproject/markdown-common';
-import { IJoinDefinition } from '../model-gen/org.accordproject.templatemark@0.4.0';
-import { AbstractComplexCompiler, getTypeScriptType, writeCloseDataScope, writeCloseGenerateScope, writeOpenDataScope, writeOpenGenerateScope } from './Common';
-
-export class Join extends AbstractComplexCompiler {
-    static TYPE = `${TemplateMarkModel.NAMESPACE}.JoinDefinition`;
-    constructor() {
-        super(true);
-    }
-    generate(fw:FileWriter, level:number, templateMarkNode:IJoinDefinition) {
-        writeOpenGenerateScope(fw,level);
-        writeOpenDataScope(fw,level,templateMarkNode.name);
-        fw.writeLine(level, `const text = Runtime.peek($data).join('${templateMarkNode.separator}');`);
-        writeCloseDataScope(fw,level);
-        fw.writeLine(level, `return { $class: '${CommonMarkModel.NAMESPACE}.Text', text: text } as ${getTypeScriptType(CommonMarkModel.NAMESPACE + '.Text')};`);
-        writeCloseGenerateScope(fw,level);
-        delete templateMarkNode.nodes; // ignore child nodes, like {{this}}
-    }
-}

package/src/compilers/ListBlock.ts

@@ -1,55 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { FileWriter } from '@accordproject/concerto-util';
-import { TemplateMarkModel } from '@accordproject/markdown-common';
-import { ProcessingFunction } from '../TemplateMarkToTypeScriptCompiler';
-import { IList } from '../model-gen/org.accordproject.commonmark@0.5.0';
-import { IListBlockDefinition, IWithDefinition } from '../model-gen/org.accordproject.templatemark@0.4.0';
-import { AbstractComplexCompiler, getTypeScriptType, makeCiceroMark, writeCloseDataScope, writeCloseGenerateScope, writeCloseNodeScope, writeDebug, writeOpenDataScope, writeOpenGenerateScope, writeOpenNodeScope } from './Common';
-
-export class ListBlock extends AbstractComplexCompiler {
-    static TYPE = `${TemplateMarkModel.NAMESPACE}.ListBlockDefinition`;
-    constructor() {
-        super(false);
-    }
-
-    enter(fw:FileWriter, level:number,templateMarkNode:IWithDefinition) {
-        writeDebug(fw, level, templateMarkNode);
-        writeOpenNodeScope(fw,level);
-        writeOpenDataScope(fw,level,templateMarkNode.name);
-    }
-
-    generate(fw:FileWriter, level:number, templateMarkNode:IListBlockDefinition, doIt:ProcessingFunction) {
-        if(templateMarkNode?.nodes?.[0]) {
-            const clone = makeCiceroMark(templateMarkNode?.nodes?.[0]) as IList;
-            writeOpenGenerateScope(fw, level);
-            fw.writeLine(level, `const result = ${JSON.stringify(clone)} as ${getTypeScriptType(templateMarkNode.$class)};`);
-            fw.writeLine(level, 'Runtime.peek($data).forEach( (item:any) => {');
-            fw.writeLine(level, 'Runtime.push($data,item);');
-            if(templateMarkNode.nodes?.[0].nodes?.[0]) {
-                doIt(fw, level+1, templateMarkNode.nodes[0].nodes[0]);
-                delete templateMarkNode.nodes; // already handled children ^^^
-            }
-            fw.writeLine(level, 'Runtime.pop($data);');
-            fw.writeLine(level, '});');
-            fw.writeLine(level, 'return result;');
-            writeCloseGenerateScope(fw, level);
-        }
-    }
-
-    exit(fw:FileWriter, level:number) {
-        writeCloseDataScope(fw,level);
-        writeCloseNodeScope(fw,level);
-    }
-}

package/src/compilers/NodeCompilers.ts

@@ -1,90 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { CommonMarkModel,TemplateMarkModel } from '@accordproject/markdown-common';
-
-import { Clause } from './Clause';
-import { Ignore, INodeCompiler, PassThrough } from './Common';
-import { Conditional } from './Conditional';
-import { ContractDefinition } from './ContractDefinition';
-import { FormattedVariable } from './FormattedVariable';
-import { Formula } from './Formula';
-import { Join } from './Join';
-import { ListBlock } from './ListBlock';
-import { Optional } from './Optional';
-import { Variable } from './Variable';
-import { With } from './With';
-
-/**
- * Registry of node compilers
- */
-const NODE_COMPILERS:Record<string,INodeCompiler> = {
-};
-
-// templatemark
-NODE_COMPILERS[ContractDefinition.TYPE] = new ContractDefinition();
-NODE_COMPILERS[Variable.TYPE] = new Variable();
-NODE_COMPILERS[FormattedVariable.TYPE] = new FormattedVariable();
-NODE_COMPILERS[Formula.TYPE] = new Formula();
-NODE_COMPILERS[Conditional.TYPE] = new Conditional();
-NODE_COMPILERS[Join.TYPE] = new Join();
-NODE_COMPILERS[With.TYPE] = new With();
-NODE_COMPILERS[Clause.TYPE] = new Clause();
-NODE_COMPILERS[Optional.TYPE] = new Optional();
-NODE_COMPILERS[ListBlock.TYPE] = new ListBlock();
-
-// ignored
-NODE_COMPILERS[`${TemplateMarkModel.NAMESPACE}.Code`] = new Ignore();
-NODE_COMPILERS[`${CommonMarkModel.NAMESPACE}.Document`] = new Ignore();
-
-// commonmark
-NODE_COMPILERS[`${CommonMarkModel.NAMESPACE}.Paragraph`] = new PassThrough(false);
-NODE_COMPILERS[`${CommonMarkModel.NAMESPACE}.Text`] = new PassThrough(true);
-NODE_COMPILERS[`${CommonMarkModel.NAMESPACE}.Attribute`] = new PassThrough(false);
-NODE_COMPILERS[`${CommonMarkModel.NAMESPACE}.TagInfo`] = new PassThrough(false);
-NODE_COMPILERS[`${CommonMarkModel.NAMESPACE}.CodeBlock`] = new PassThrough(false);
-NODE_COMPILERS[`${CommonMarkModel.NAMESPACE}.Code`] = new PassThrough(false);
-NODE_COMPILERS[`${CommonMarkModel.NAMESPACE}.HtmlInline`] = new PassThrough(false);
-NODE_COMPILERS[`${CommonMarkModel.NAMESPACE}.HtmlBlock`] = new PassThrough(false);
-NODE_COMPILERS[`${CommonMarkModel.NAMESPACE}.Emph`] = new PassThrough(false);
-NODE_COMPILERS[`${CommonMarkModel.NAMESPACE}.Strong`] = new PassThrough(false);
-NODE_COMPILERS[`${CommonMarkModel.NAMESPACE}.BlockQuote`] = new PassThrough(false);
-NODE_COMPILERS[`${CommonMarkModel.NAMESPACE}.Heading`] = new PassThrough(false);
-NODE_COMPILERS[`${CommonMarkModel.NAMESPACE}.ThematicBreak`] = new PassThrough(false);
-NODE_COMPILERS[`${CommonMarkModel.NAMESPACE}.Softbreak`] = new PassThrough(false);
-NODE_COMPILERS[`${CommonMarkModel.NAMESPACE}.Linebreak`] = new PassThrough(false);
-NODE_COMPILERS[`${CommonMarkModel.NAMESPACE}.Link`] = new PassThrough(false);
-NODE_COMPILERS[`${CommonMarkModel.NAMESPACE}.Image`] = new PassThrough(false);
-NODE_COMPILERS[`${CommonMarkModel.NAMESPACE}.List`] = new PassThrough(false);
-NODE_COMPILERS[`${CommonMarkModel.NAMESPACE}.Item`] = new PassThrough(false);
-NODE_COMPILERS[`${CommonMarkModel.NAMESPACE}.Table`] = new PassThrough(false);
-NODE_COMPILERS[`${CommonMarkModel.NAMESPACE}.TableHead`] = new PassThrough(false);
-NODE_COMPILERS[`${CommonMarkModel.NAMESPACE}.TableBody`] = new PassThrough(false);
-NODE_COMPILERS[`${CommonMarkModel.NAMESPACE}.TableRow`] = new PassThrough(false);
-NODE_COMPILERS[`${CommonMarkModel.NAMESPACE}.TableRow`] = new PassThrough(false);
-NODE_COMPILERS[`${CommonMarkModel.NAMESPACE}.HeaderCell`] = new PassThrough(false);
-NODE_COMPILERS[`${CommonMarkModel.NAMESPACE}.TableCell`] = new PassThrough(false);
-
-/**
- * Lookup a node compiler
- * @param {string} fqn the Concerto FQN of the node $class
- * @returns {INodeCompiler} the compiler to use for this node
- */
-export function getCompiler(fqn:string) : INodeCompiler {
-    const compiler = NODE_COMPILERS[fqn];
-    if(!compiler) {
-        throw new Error(`No compiler found for node ${fqn}`);
-    }
-    return compiler;
-}

package/src/compilers/Optional.ts

@@ -1,65 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { FileWriter } from '@accordproject/concerto-util';
-import { CommonMarkModel,TemplateMarkModel } from '@accordproject/markdown-common';
-
-import { ProcessingFunction } from '../TemplateMarkToTypeScriptCompiler';
-import { IOptionalDefinition } from '../model-gen/org.accordproject.templatemark@0.4.0';
-import { AbstractComplexCompiler, getTypeScriptType, makeCiceroMark, writeCloseDataScope, writeCloseGenerateScope, writeCloseNodeScope, writeDebug, writeOpenDataScope, writeOpenGenerateScope, writeOpenNodeScope } from './Common';
-
-
-export class Optional extends AbstractComplexCompiler {
-    static TYPE = `${TemplateMarkModel.NAMESPACE}.OptionalDefinition`;
-    constructor() {
-        super(false);
-    }
-
-    enter(fw:FileWriter, level:number,templateMarkNode:IOptionalDefinition) {
-        writeDebug(fw, level, templateMarkNode);
-        writeOpenNodeScope(fw,level);
-        writeOpenDataScope(fw,level,templateMarkNode.name, true); // allow pushing undefined onto the stack
-    }
-
-    generate(fw:FileWriter, level:number, templateMarkNode:IOptionalDefinition, doIt:ProcessingFunction) {
-        const clone = makeCiceroMark(templateMarkNode) as any;
-        delete clone.nodes;
-        delete clone.whenSome; // replaced below
-        delete clone.whenNone;
-        writeOpenGenerateScope(fw, level);
-        fw.writeLine(level, `const result = ${JSON.stringify(clone)} as ${getTypeScriptType(templateMarkNode.$class)};`);
-        fw.writeLine(level, 'const hasSome:boolean = !(Runtime.peek($data) === null || Runtime.peek($data) === undefined);');
-        fw.writeLine(level, '(result as CiceroMark.IOptional).hasSome = hasSome;');
-        fw.writeLine(level, 'if(hasSome) {');
-        doIt(fw, level+1, {$class: `${CommonMarkModel.NAMESPACE}.Paragraph`, nodes: templateMarkNode.whenSome});
-        fw.writeLine(level, '(result as CiceroMark.IOptional).whenSome = $result.nodes[0];');
-        fw.writeLine(level, '(result as CiceroMark.IOptional).whenNone = $result.nodes[0];'); // HACK - model needs to be updated
-        fw.writeLine(level, 'return result;');
-        fw.writeLine(level, '}');
-        fw.writeLine(level, 'else {');
-        doIt(fw, level+1, {$class: `${CommonMarkModel.NAMESPACE}.Paragraph`, nodes: templateMarkNode.whenNone});
-        fw.writeLine(level, '(result as CiceroMark.IOptional).whenNone = $result.nodes[0];');
-        fw.writeLine(level, '(result as CiceroMark.IOptional).whenSome = $result.nodes[0];');  // HACK - model needs to be updated
-        fw.writeLine(level, 'return result;');
-        fw.writeLine(level, '}');
-        writeCloseGenerateScope(fw, level);
-        delete templateMarkNode.nodes;
-        delete (templateMarkNode as any).whenSome; // already handled
-        delete (templateMarkNode as any).whenNone;
-    }
-
-    exit(fw:FileWriter, level:number) {
-        writeCloseDataScope(fw,level);
-        writeCloseNodeScope(fw,level);
-    }
-}

package/src/compilers/Variable.ts

@@ -1,40 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { FileWriter } from '@accordproject/concerto-util';
-import { TemplateMarkModel } from '@accordproject/markdown-common';
-import { IVariable } from '../model-gen/org.accordproject.ciceromark@0.6.0';
-import { IVariableDefinition } from '../model-gen/org.accordproject.templatemark@0.4.0';
-import { AbstractComplexCompiler, getTypeScriptType, makeCiceroMark, writeCloseDataScope, writeCloseGenerateScope, writeOpenDataScope, writeOpenGenerateScope } from './Common';
-
-export class Variable extends AbstractComplexCompiler {
-    static TYPE = `${TemplateMarkModel.NAMESPACE}.VariableDefinition`;
-    constructor() {
-        super(true);
-    }
-    generate(fw:FileWriter, level:number, templateMarkNode:IVariableDefinition) {
-        const clone = makeCiceroMark(templateMarkNode) as IVariable;
-        writeOpenGenerateScope(fw,level);
-        if(templateMarkNode.name !== 'this') {
-            writeOpenDataScope(fw,level,templateMarkNode.name);
-        }
-        fw.writeLine(level, 'const text = JSON.stringify(Runtime.peek($data)) as string;');
-        if(templateMarkNode.name !== 'this') {
-            writeCloseDataScope(fw,level);
-        }
-        fw.writeLine(level, `const variable:any = ${JSON.stringify(clone)};`);
-        fw.writeLine(level, 'variable.value = text;');
-        fw.writeLine(level, `return variable as ${getTypeScriptType(clone.$class)};`);
-        writeCloseGenerateScope(fw,level);
-    }
-}