edgexpress 3.0.1 → 3.0.2

package/src/tags/else.js

@@ -0,0 +1,22 @@
+"use strict";
+/*
+ * edge.js
+ *
+ * (c) EdgeJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.elseTag = void 0;
+exports.elseTag = {
+    block: false,
+    seekable: false,
+    tagName: 'else',
+    /**
+     * Compiles else block node to Javascript else statement
+     */
+    compile(_, buffer, token) {
+        buffer.writeStatement('} else {', token.filename, -1);
+    },
+};

package/src/tags/else_if.d.ts

@@ -0,0 +1,7 @@
+import { type TagContract } from '../types.js'
+/**
+ * Else if tag is used to define conditional blocks. We keep `@elseif` tag
+ * is a inline tag, so that everything between the `if` and the `elseif`
+ * comes `if` children.
+ */
+export declare const elseIfTag: TagContract

package/src/tags/else_if.js

@@ -0,0 +1,39 @@
+"use strict";
+/*
+ * edge.js
+ *
+ * (c) EdgeJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.elseIfTag = void 0;
+const edge_parser_1 = require("edge-parser");
+const utils_js_1 = require("../utils.js");
+/**
+ * Else if tag is used to define conditional blocks. We keep `@elseif` tag
+ * is a inline tag, so that everything between the `if` and the `elseif`
+ * comes `if` children.
+ */
+exports.elseIfTag = {
+    block: false,
+    seekable: true,
+    tagName: 'elseif',
+    /**
+     * Compiles the else if block node to a Javascript if statement
+     */
+    compile(parser, buffer, token) {
+        const parsed = (0, utils_js_1.parseJsArg)(parser, token);
+        /**
+         * Disallow sequence expressions
+         */
+        (0, utils_js_1.isNotSubsetOf)(parsed, [edge_parser_1.expressions.SequenceExpression], () => {
+            (0, utils_js_1.unallowedExpression)(`{${token.properties.jsArg}} is not a valid argument type for the @elseif tag`, token.filename, parser.utils.getExpressionLoc(parsed));
+        });
+        /**
+         * Start else if block
+         */
+        buffer.writeStatement(`} else if (${parser.utils.stringify(parsed)}) {`, token.filename, token.loc.start.line);
+    },
+};

package/src/tags/eval.d.ts

@@ -0,0 +1,7 @@
+import type { TagContract } from '../types.js'
+/**
+ * The eval tag accepts expressions similar to double curly
+ * braces. However, it does not write anything to the
+ * output.
+ */
+export declare const evalTag: TagContract

package/src/tags/eval.js

@@ -0,0 +1,30 @@
+"use strict";
+/*
+ * edge.js
+ *
+ * (c) EdgeJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evalTag = void 0;
+const utils_js_1 = require("../utils.js");
+/**
+ * The eval tag accepts expressions similar to double curly
+ * braces. However, it does not write anything to the
+ * output.
+ */
+exports.evalTag = {
+    block: false,
+    seekable: true,
+    tagName: 'eval',
+    noNewLine: true,
+    /**
+     * Compiles the tag AST
+     */
+    compile(parser, buffer, token) {
+        const parsed = (0, utils_js_1.parseJsArg)(parser, token);
+        buffer.writeExpression(parser.utils.stringify(parsed), token.filename, token.loc.start.line);
+    },
+};

package/src/tags/if.d.ts

@@ -0,0 +1,5 @@
+import { type TagContract } from '../types.js'
+/**
+ * If tag is used to define conditional blocks.
+ */
+export declare const ifTag: TagContract

package/src/tags/if.js

@@ -0,0 +1,45 @@
+"use strict";
+/*
+ * edge.js
+ *
+ * (c) EdgeJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ifTag = void 0;
+const edge_parser_1 = require("edge-parser");
+const utils_js_1 = require("../utils.js");
+/**
+ * If tag is used to define conditional blocks.
+ */
+exports.ifTag = {
+    block: true,
+    seekable: true,
+    tagName: 'if',
+    /**
+     * Compiles the if block node to a Javascript if statement
+     */
+    compile(parser, buffer, token) {
+        const parsed = (0, utils_js_1.parseJsArg)(parser, token);
+        /**
+         * Disallow sequence expressions
+         */
+        (0, utils_js_1.isNotSubsetOf)(parsed, [edge_parser_1.expressions.SequenceExpression], () => {
+            (0, utils_js_1.unallowedExpression)(`"${token.properties.jsArg}" is not a valid argument type for the @if tag`, token.filename, parser.utils.getExpressionLoc(parsed));
+        });
+        /**
+         * Start if block
+         */
+        buffer.writeStatement(`if (${parser.utils.stringify(parsed)}) {`, token.filename, token.loc.start.line);
+        /**
+         * Process of all children recursively
+         */
+        token.children.forEach((child) => parser.processToken(child, buffer));
+        /**
+         * Close if block
+         */
+        buffer.writeStatement('}', token.filename, -1);
+    },
+};

package/src/tags/include.d.ts

@@ -0,0 +1,27 @@
+import { type Parser } from 'edge-parser'
+import type { TagContract } from '../types.js'
+/**
+ * List of expressions allowed for the include tag
+ */
+export declare const ALLOWED_EXPRESSION: (
+  | 'Identifier'
+  | 'MemberExpression'
+  | 'CallExpression'
+  | 'Literal'
+  | 'TemplateLiteral'
+  | 'ConditionalExpression'
+  | 'LogicalExpression'
+)[]
+/**
+ * Returns the expression for rendering the partial
+ */
+export declare function getRenderExpression(parser: Parser, parsedExpression: any): string
+/**
+ * Include tag is used to include partials in the same scope of the parent
+ * template.
+ *
+ * ```edge
+ * @include('partials.header')
+ * ```
+ */
+export declare const includeTag: TagContract

package/src/tags/include.js

@@ -0,0 +1,78 @@
+"use strict";
+/*
+ * edge.js
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.includeTag = exports.ALLOWED_EXPRESSION = void 0;
+exports.getRenderExpression = getRenderExpression;
+const edge_parser_1 = require("edge-parser");
+const utils_js_1 = require("../utils.js");
+/**
+ * List of expressions allowed for the include tag
+ */
+exports.ALLOWED_EXPRESSION = [
+    edge_parser_1.expressions.Literal,
+    edge_parser_1.expressions.Identifier,
+    edge_parser_1.expressions.CallExpression,
+    edge_parser_1.expressions.TemplateLiteral,
+    edge_parser_1.expressions.MemberExpression,
+    edge_parser_1.expressions.LogicalExpression,
+    edge_parser_1.expressions.ConditionalExpression,
+];
+/**
+ * Returns the expression for rendering the partial
+ */
+function getRenderExpression(parser, parsedExpression) {
+    /**
+     * We need to pass the local variables to the partial render function
+     */
+    const localVariables = parser.stack.list();
+    /**
+     * Arguments for the `renderInline` method
+     */
+    const renderArgs = localVariables.length
+        ? [
+            parser.utils.stringify(parsedExpression),
+            localVariables.map((localVar) => `"${localVar}"`).join(','),
+        ]
+        : [parser.utils.stringify(parsedExpression)];
+    /**
+     * Arguments for invoking the output function of `renderInline`
+     */
+    const callFnArgs = localVariables.length
+        ? ['template', 'state', '$context', localVariables.map((localVar) => localVar).join(',')]
+        : ['template', 'state', '$context'];
+    return `template.compilePartial(${renderArgs.join(',')})(${callFnArgs.join(',')})`;
+}
+/**
+ * Include tag is used to include partials in the same scope of the parent
+ * template.
+ *
+ * ```edge
+ * @include('partials.header')
+ * ```
+ */
+exports.includeTag = {
+    block: false,
+    seekable: true,
+    tagName: 'include',
+    /**
+     * Compiles else block node to Javascript else statement
+     */
+    compile(parser, buffer, token) {
+        const awaitKeyword = parser.asyncMode ? 'await ' : '';
+        const parsed = (0, utils_js_1.parseJsArg)(parser, token);
+        /**
+         * Only mentioned expressions are allowed inside `@include` tag
+         */
+        (0, utils_js_1.isSubsetOf)(parsed, exports.ALLOWED_EXPRESSION, () => {
+            (0, utils_js_1.unallowedExpression)(`"${token.properties.jsArg}" is not a valid argument type for the @include tag`, token.filename, parser.utils.getExpressionLoc(parsed));
+        });
+        buffer.outputExpression(`${awaitKeyword}${getRenderExpression(parser, parsed)}`, token.filename, token.loc.start.line, false);
+    },
+};

package/src/tags/include_if.d.ts

@@ -0,0 +1,10 @@
+import { type TagContract } from '../types.js'
+/**
+ * Include tag is used to include partials in the same scope of the parent
+ * template.
+ *
+ * ```edge
+ * @include('partials.header')
+ * ```
+ */
+export declare const includeIfTag: TagContract

package/src/tags/include_if.js

@@ -0,0 +1,61 @@
+"use strict";
+/*
+ * edge.js
+ *
+ * (c) EdgeJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.includeIfTag = void 0;
+const edge_error_1 = require("edge-error");
+const edge_parser_1 = require("edge-parser");
+const include_js_1 = require("./include.js");
+const utils_js_1 = require("../utils.js");
+/**
+ * Include tag is used to include partials in the same scope of the parent
+ * template.
+ *
+ * ```edge
+ * @include('partials.header')
+ * ```
+ */
+exports.includeIfTag = {
+    block: false,
+    seekable: true,
+    tagName: 'includeIf',
+    /**
+     * Compiles else block node to Javascript else statement
+     */
+    compile(parser, buffer, token) {
+        const awaitKeyword = parser.asyncMode ? 'await ' : '';
+        const parsed = (0, utils_js_1.parseJsArg)(parser, token);
+        /**
+         * The include if only accepts the sequence expression
+         */
+        (0, utils_js_1.isSubsetOf)(parsed, [edge_parser_1.expressions.SequenceExpression], () => {
+            (0, utils_js_1.unallowedExpression)(`"${token.properties.jsArg}" is not a valid argument type for the @includeIf tag`, token.filename, parser.utils.getExpressionLoc(parsed));
+        });
+        /**
+         * Disallow more than or less than 2 values for the sequence expression
+         */
+        if (parsed.expressions.length !== 2) {
+            throw new edge_error_1.EdgeError('@includeIf expects a total of 2 arguments', 'E_ARGUMENTS_MIS_MATCH', {
+                line: parsed.loc.start.line,
+                col: parsed.loc.start.column,
+                filename: token.filename,
+            });
+        }
+        const [conditional, include] = parsed.expressions;
+        (0, utils_js_1.isNotSubsetOf)(conditional, [edge_parser_1.expressions.SequenceExpression], () => {
+            (0, utils_js_1.unallowedExpression)(`"${conditional.type}" is not a valid 1st argument type for the @includeIf tag`, token.filename, parser.utils.getExpressionLoc(conditional));
+        });
+        (0, utils_js_1.isSubsetOf)(include, include_js_1.ALLOWED_EXPRESSION, () => {
+            (0, utils_js_1.unallowedExpression)(`"${include.type}" is not a valid 2nd argument type for the @includeIf tag`, token.filename, parser.utils.getExpressionLoc(include));
+        });
+        buffer.writeStatement(`if (${parser.utils.stringify(conditional)}) {`, token.filename, token.loc.start.line);
+        buffer.outputExpression(`${awaitKeyword}${(0, include_js_1.getRenderExpression)(parser, include)}`, token.filename, token.loc.start.line, false);
+        buffer.writeStatement('}', token.filename, -1);
+    },
+};

package/src/tags/inject.d.ts

@@ -0,0 +1,6 @@
+import type { TagContract } from '../types.js'
+/**
+ * The inject tag is used within the components to share values with the
+ * component caller.
+ */
+export declare const injectTag: TagContract

package/src/tags/inject.js

@@ -0,0 +1,40 @@
+"use strict";
+/*
+ * edge.js
+ *
+ * (c) EdgeJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectTag = void 0;
+const edge_parser_1 = require("edge-parser");
+const utils_js_1 = require("../utils.js");
+/**
+ * The inject tag is used within the components to share values with the
+ * component caller.
+ */
+exports.injectTag = {
+    block: false,
+    seekable: true,
+    tagName: 'inject',
+    noNewLine: true,
+    compile(parser, buffer, token) {
+        token.properties.jsArg = `(${token.properties.jsArg})`;
+        const parsed = (0, utils_js_1.parseJsArg)(parser, token);
+        /**
+         * The inject tag only accepts an object expression.
+         */
+        (0, utils_js_1.isSubsetOf)(parsed, [edge_parser_1.expressions.ObjectExpression, edge_parser_1.expressions.Identifier, edge_parser_1.expressions.CallExpression], () => {
+            throw (0, utils_js_1.unallowedExpression)(`"${token.properties.jsArg}" is not a valid key-value pair for the @inject tag`, token.filename, parser.utils.getExpressionLoc(parsed));
+        });
+        /**
+         * Ensure $slots are defined before merging shared state
+         */
+        buffer.writeStatement('if (!state.$slots || !state.$slots.$context) {', token.filename, token.loc.start.line);
+        buffer.writeExpression(`throw new Error('Cannot use "@inject" outside of a component scope')`, token.filename, token.loc.start.line);
+        buffer.writeStatement('}', token.filename, token.loc.start.line);
+        buffer.writeExpression(`Object.assign(state.$slots.$context, ${parser.utils.stringify(parsed)})`, token.filename, token.loc.start.line);
+    },
+};

package/src/tags/let.d.ts

@@ -0,0 +1,6 @@
+import { type TagContract } from '../types.js'
+/**
+ * The let tag is used to set runtime values within the template. The value
+ * is set inside the current scope of the template.
+ */
+export declare const letTag: TagContract

package/src/tags/let.js

@@ -0,0 +1,69 @@
+"use strict";
+/*
+ * edge.js
+ *
+ * (c) EdgeJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.letTag = void 0;
+const edge_parser_1 = require("edge-parser");
+const lodash_1 = __importDefault(require("@poppinss/utils/lodash"));
+const utils_js_1 = require("../utils.js");
+/**
+ * The let tag is used to set runtime values within the template. The value
+ * is set inside the current scope of the template.
+ */
+exports.letTag = {
+    block: false,
+    seekable: true,
+    tagName: 'let',
+    noNewLine: true,
+    /**
+     * Compiles else block node to Javascript else statement
+     */
+    compile(parser, buffer, token) {
+        const parsed = parser.utils.generateAST(`let ${token.properties.jsArg}`, token.loc, token.filename).declarations[0];
+        const key = parsed.id;
+        const value = parsed.init;
+        /**
+         * The variable name has to be an identifier or the destructuring
+         * operator.
+         */
+        (0, utils_js_1.isSubsetOf)(key, ['ObjectPattern', edge_parser_1.expressions.Identifier, 'ArrayPattern'], () => {
+            throw (0, utils_js_1.unallowedExpression)(`Invalid variable name for the @let tag`, token.filename, parser.utils.getExpressionLoc(key));
+        });
+        /**
+         * Define local variables based upon the expression
+         */
+        if (key.type === 'Identifier') {
+            parser.stack.defineVariable(key.name);
+        }
+        else if (key.type === 'ObjectPattern') {
+            key.properties.forEach((property) => {
+                parser.stack.defineVariable(property.argument ? property.argument.name : property.value.name);
+            });
+        }
+        else if (key.type === 'ArrayPattern') {
+            key.elements.forEach((element) => {
+                parser.stack.defineVariable(element.argument ? element.argument.name : element.name);
+            });
+        }
+        /**
+         * Declare let variable
+         */
+        const expression = `let ${parser.utils.stringify(key)} = ${parser.utils.stringify(parser.utils.transformAst(value, token.filename, parser))}`;
+        buffer.writeExpression(expression, token.filename, token.loc.start.line);
+    },
+    /**
+     * Add methods to the template for running the loop
+     */
+    boot(template) {
+        template.macro('setValue', lodash_1.default.set);
+    },
+};

package/src/tags/main.d.ts

@@ -0,0 +1,18 @@
+export { ifTag as if } from './if.js'
+export { letTag as let } from './let.js'
+export { eachTag as each } from './each.js'
+export { slotTag as slot } from './slot.js'
+export { elseTag as else } from './else.js'
+export { evalTag as eval } from './eval.js'
+export { stackTag as stack } from './stack.js'
+export { assignTag as assign } from './assign.js'
+export { injectTag as inject } from './inject.js'
+export { unlessTag as unless } from './unless.js'
+export { elseIfTag as elseif } from './else_if.js'
+export { pushToTag as pushTo } from './push_to.js'
+export { includeTag as include } from './include.js'
+export { debuggerTag as debugger } from './debugger.js'
+export { newErrorTag as newError } from './new_error.js'
+export { componentTag as component } from './component.js'
+export { includeIfTag as includeIf } from './include_if.js'
+export { pushOnceToTag as pushOnceTo } from './push_once_to.js'

package/src/tags/main.js

@@ -0,0 +1,47 @@
+"use strict";
+/*
+ * edge.js
+ *
+ * (c) EdgeJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pushOnceTo = exports.includeIf = exports.component = exports.newError = exports.debugger = exports.include = exports.pushTo = exports.elseif = exports.unless = exports.inject = exports.assign = exports.stack = exports.eval = exports.else = exports.slot = exports.each = exports.let = exports.if = void 0;
+var if_js_1 = require("./if.js");
+Object.defineProperty(exports, "if", { enumerable: true, get: function () { return if_js_1.ifTag; } });
+var let_js_1 = require("./let.js");
+Object.defineProperty(exports, "let", { enumerable: true, get: function () { return let_js_1.letTag; } });
+var each_js_1 = require("./each.js");
+Object.defineProperty(exports, "each", { enumerable: true, get: function () { return each_js_1.eachTag; } });
+var slot_js_1 = require("./slot.js");
+Object.defineProperty(exports, "slot", { enumerable: true, get: function () { return slot_js_1.slotTag; } });
+var else_js_1 = require("./else.js");
+Object.defineProperty(exports, "else", { enumerable: true, get: function () { return else_js_1.elseTag; } });
+var eval_js_1 = require("./eval.js");
+Object.defineProperty(exports, "eval", { enumerable: true, get: function () { return eval_js_1.evalTag; } });
+var stack_js_1 = require("./stack.js");
+Object.defineProperty(exports, "stack", { enumerable: true, get: function () { return stack_js_1.stackTag; } });
+var assign_js_1 = require("./assign.js");
+Object.defineProperty(exports, "assign", { enumerable: true, get: function () { return assign_js_1.assignTag; } });
+var inject_js_1 = require("./inject.js");
+Object.defineProperty(exports, "inject", { enumerable: true, get: function () { return inject_js_1.injectTag; } });
+var unless_js_1 = require("./unless.js");
+Object.defineProperty(exports, "unless", { enumerable: true, get: function () { return unless_js_1.unlessTag; } });
+var else_if_js_1 = require("./else_if.js");
+Object.defineProperty(exports, "elseif", { enumerable: true, get: function () { return else_if_js_1.elseIfTag; } });
+var push_to_js_1 = require("./push_to.js");
+Object.defineProperty(exports, "pushTo", { enumerable: true, get: function () { return push_to_js_1.pushToTag; } });
+var include_js_1 = require("./include.js");
+Object.defineProperty(exports, "include", { enumerable: true, get: function () { return include_js_1.includeTag; } });
+var debugger_js_1 = require("./debugger.js");
+Object.defineProperty(exports, "debugger", { enumerable: true, get: function () { return debugger_js_1.debuggerTag; } });
+var new_error_js_1 = require("./new_error.js");
+Object.defineProperty(exports, "newError", { enumerable: true, get: function () { return new_error_js_1.newErrorTag; } });
+var component_js_1 = require("./component.js");
+Object.defineProperty(exports, "component", { enumerable: true, get: function () { return component_js_1.componentTag; } });
+var include_if_js_1 = require("./include_if.js");
+Object.defineProperty(exports, "includeIf", { enumerable: true, get: function () { return include_if_js_1.includeIfTag; } });
+var push_once_to_js_1 = require("./push_once_to.js");
+Object.defineProperty(exports, "pushOnceTo", { enumerable: true, get: function () { return push_once_to_js_1.pushOnceToTag; } });

package/src/tags/new_error.d.ts

@@ -0,0 +1,6 @@
+import { type TagContract } from '../types.js'
+/**
+ * newError tag to raise exceptions inside your templates. They will point
+ * back to the exact line:col in the template
+ */
+export declare const newErrorTag: TagContract

package/src/tags/new_error.js

@@ -0,0 +1,47 @@
+"use strict";
+/*
+ * edge.js
+ *
+ * (c) EdgeJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newErrorTag = void 0;
+const edge_parser_1 = require("edge-parser");
+const utils_js_1 = require("../utils.js");
+/**
+ * newError tag to raise exceptions inside your templates. They will point
+ * back to the exact line:col in the template
+ */
+exports.newErrorTag = {
+    block: false,
+    seekable: true,
+    tagName: 'newError',
+    noNewLine: true,
+    compile(parser, buffer, token) {
+        const parsed = (0, utils_js_1.parseJsArg)(parser, token);
+        let message = '';
+        let line = token.loc.start.line;
+        let col = token.loc.start.col;
+        let filename = '$filename';
+        if (parsed.type === edge_parser_1.expressions.SequenceExpression) {
+            message = parser.utils.stringify(parsed.expressions[0]);
+            filename = parsed.expressions[1] ? parser.utils.stringify(parsed.expressions[1]) : '$filename';
+            line = parsed.expressions[2]
+                ? parser.utils.stringify(parsed.expressions[2])
+                : token.loc.start.line;
+            col = parsed.expressions[3]
+                ? parser.utils.stringify(parsed.expressions[3])
+                : token.loc.start.col;
+        }
+        else {
+            message = parser.utils.stringify(parsed);
+        }
+        /**
+         * Raise the exception with the correct filename and the line number
+         */
+        buffer.writeStatement(`template.newError(${message}, ${filename}, ${line}, ${col})`, token.filename, token.loc.start.line);
+    },
+};

package/src/tags/push_once_to.d.ts

@@ -0,0 +1,13 @@
+import { type TagContract } from '../types.js'
+declare module '../template.js' {
+  interface Template {
+    stackSources: Record<string, boolean>
+    trackStackSource(stack: string, filename: string, line: string, col: string): boolean
+  }
+}
+/**
+ * Stack tag to define stack placeholders
+ */
+export declare const pushOnceToTag: TagContract & {
+  generateId(): string
+}