edgexpress 3.0.1 → 3.0.2

package/src/migrate/plugin.js

@@ -0,0 +1,58 @@
+"use strict";
+/*
+ * edge.js
+ *
+ * (c) Edge
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrate = void 0;
+const Tags = __importStar(require("./tags/main.js"));
+const globals_js_1 = require("./globals.js");
+const migrate = (edge) => {
+    edge.compat = true;
+    edge.compiler.compat = true;
+    edge.asyncCompiler.compat = true;
+    Object.keys(globals_js_1.GLOBALS).forEach((name) => {
+        edge.global(name, globals_js_1.GLOBALS[name]);
+    });
+    Object.keys(Tags).forEach((name) => {
+        edge.registerTag(Tags[name]);
+    });
+};
+exports.migrate = migrate;

package/src/migrate/props.d.ts

@@ -0,0 +1,66 @@
+import { type ComponentProps } from '../component/props.js'
+/**
+ * Class to ease interactions with component props
+ */
+export declare class Props {
+  #private
+  /**
+   * Use ".next" property to migrate to newer
+   * api
+   */
+  next: ComponentProps
+  constructor(props: any)
+  /**
+   * Find if a key exists inside the props
+   */
+  has(key: string): boolean
+  /**
+   * Get value for a given key
+   */
+  get(key: string, defaultValue?: any): any
+  /**
+   * Returns all the props
+   */
+  all(): any
+  /**
+   * Validate prop value
+   */
+  validate(key: string, validateFn: (key: string, value?: any) => any): void
+  /**
+   * Return values for only the given keys
+   */
+  only(keys: string[]): any
+  /**
+   * Return values except the given keys
+   */
+  except(keys: string[]): any
+  /**
+   * Serialize all props to a string of HTML attributes
+   */
+  serialize(
+    mergeProps?: any,
+    prioritizeInline?: boolean
+  ): {
+    value: any
+  }
+  /**
+   * Serialize only the given keys to a string of HTML attributes
+   */
+  serializeOnly(
+    keys: string[],
+    mergeProps?: any,
+    prioritizeInline?: boolean
+  ): {
+    value: any
+  }
+  /**
+   * Serialize except the given keys to a string of HTML attributes
+   */
+  serializeExcept(
+    keys: string[],
+    mergeProps?: any,
+    prioritizeInline?: boolean
+  ): {
+    value: any
+  }
+}

package/src/migrate/props.js

@@ -0,0 +1,129 @@
+"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.Props = void 0;
+const lodash_1 = __importDefault(require("@poppinss/utils/lodash"));
+const stringify_attributes_1 = __importDefault(require("stringify-attributes"));
+const template_js_1 = require("../template.js");
+const props_js_1 = require("../component/props.js");
+/**
+ * Class to ease interactions with component props
+ */
+class Props {
+    /**
+     * Use ".next" property to migrate to newer
+     * api
+     */
+    next;
+    constructor(props) {
+        // @ts-ignore
+        this[Symbol.for('options')] = { props };
+        Object.assign(this, props);
+        this.next = new props_js_1.ComponentProps(props);
+    }
+    /**
+     * Merges the className attribute with the class attribute
+     */
+    #mergeClassAttributes(props) {
+        if (props.className) {
+            if (!props.class) {
+                props.class = [];
+            }
+            /**
+             * Normalize class attribute to be an array
+             */
+            if (!Array.isArray(props.class)) {
+                props.class = [props.class];
+            }
+            props.class = props.class.concat(props.className);
+            props.className = false;
+        }
+        return props;
+    }
+    /**
+     * Find if a key exists inside the props
+     */
+    has(key) {
+        const value = this.get(key);
+        return value !== undefined && value !== null;
+    }
+    /**
+     * Get value for a given key
+     */
+    get(key, defaultValue) {
+        return lodash_1.default.get(this.all(), key, defaultValue);
+    }
+    /**
+     * Returns all the props
+     */
+    all() {
+        // @ts-ignore
+        return this[Symbol.for('options')].props;
+    }
+    /**
+     * Validate prop value
+     */
+    validate(key, validateFn) {
+        const value = this.get(key);
+        validateFn(key, value);
+    }
+    /**
+     * Return values for only the given keys
+     */
+    only(keys) {
+        return lodash_1.default.pick(this.all(), keys);
+    }
+    /**
+     * Return values except the given keys
+     */
+    except(keys) {
+        return lodash_1.default.omit(this.all(), keys);
+    }
+    /**
+     * Serialize all props to a string of HTML attributes
+     */
+    serialize(mergeProps, prioritizeInline = true) {
+        /**
+         * Prioritize user attributes when prioritizeInline=false
+         */
+        const attributes = prioritizeInline
+            ? lodash_1.default.merge({}, this.all(), mergeProps)
+            : lodash_1.default.merge({}, mergeProps, this.all());
+        return (0, template_js_1.htmlSafe)((0, stringify_attributes_1.default)(this.#mergeClassAttributes(attributes)));
+    }
+    /**
+     * Serialize only the given keys to a string of HTML attributes
+     */
+    serializeOnly(keys, mergeProps, prioritizeInline = true) {
+        /**
+         * Prioritize user attributes when prioritizeInline=false
+         */
+        const attributes = prioritizeInline
+            ? lodash_1.default.merge({}, this.only(keys), mergeProps)
+            : lodash_1.default.merge({}, mergeProps, this.only(keys));
+        return (0, template_js_1.htmlSafe)((0, stringify_attributes_1.default)(this.#mergeClassAttributes(attributes)));
+    }
+    /**
+     * Serialize except the given keys to a string of HTML attributes
+     */
+    serializeExcept(keys, mergeProps, prioritizeInline = true) {
+        /**
+         * Prioritize user attributes when prioritizeInline=false
+         */
+        const attributes = prioritizeInline
+            ? lodash_1.default.merge({}, this.except(keys), mergeProps)
+            : lodash_1.default.merge({}, mergeProps, this.except(keys));
+        return (0, template_js_1.htmlSafe)((0, stringify_attributes_1.default)(this.#mergeClassAttributes(attributes)));
+    }
+}
+exports.Props = Props;

package/src/migrate/tags/layout.d.ts

@@ -0,0 +1,6 @@
+import { type TagContract } from '../../types.js'
+/**
+ * Layout tag is used to define parent layout for a given template. The layout
+ * must appear in the first line of the template itself.
+ */
+export declare const layoutTag: TagContract

package/src/migrate/tags/layout.js

@@ -0,0 +1,25 @@
+"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.layoutTag = void 0;
+/**
+ * Layout tag is used to define parent layout for a given template. The layout
+ * must appear in the first line of the template itself.
+ */
+exports.layoutTag = {
+    block: false,
+    seekable: true,
+    tagName: 'layout',
+    noNewLine: true,
+    compile() {
+        // The layouts are handled by the template itself. I am just a way to
+        // tell lexer to parse me as a block node
+    },
+};

package/src/migrate/tags/main.d.ts

@@ -0,0 +1,4 @@
+export { setTag as set } from './set.js'
+export { superTag as super } from './super.js'
+export { layoutTag as layout } from './layout.js'
+export { sectionTag as section } from './section.js'

package/src/migrate/tags/main.js

@@ -0,0 +1,19 @@
+"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.section = exports.layout = exports.super = exports.set = void 0;
+var set_js_1 = require("./set.js");
+Object.defineProperty(exports, "set", { enumerable: true, get: function () { return set_js_1.setTag; } });
+var super_js_1 = require("./super.js");
+Object.defineProperty(exports, "super", { enumerable: true, get: function () { return super_js_1.superTag; } });
+var layout_js_1 = require("./layout.js");
+Object.defineProperty(exports, "layout", { enumerable: true, get: function () { return layout_js_1.layoutTag; } });
+var section_js_1 = require("./section.js");
+Object.defineProperty(exports, "section", { enumerable: true, get: function () { return section_js_1.sectionTag; } });

package/src/migrate/tags/section.d.ts

@@ -0,0 +1,6 @@
+import { type TagContract } from '../../types.js'
+/**
+ * Section tag is used to define the sections on a given template. Sections cannot be
+ * nested and must appear as top level children inside a component.
+ */
+export declare const sectionTag: TagContract

package/src/migrate/tags/section.js

@@ -0,0 +1,23 @@
+"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.sectionTag = void 0;
+/**
+ * Section tag is used to define the sections on a given template. Sections cannot be
+ * nested and must appear as top level children inside a component.
+ */
+exports.sectionTag = {
+    block: true,
+    seekable: true,
+    tagName: 'section',
+    compile(parser, buffer, token) {
+        token.children.forEach((child) => parser.processToken(child, buffer));
+    },
+};

package/src/migrate/tags/set.d.ts

@@ -0,0 +1,26 @@
+import type lodash from '@poppinss/utils/lodash'
+import { type TagContract } from '../../types.js'
+declare module '../../template.js' {
+  interface Template {
+    setValue: (typeof lodash)['set']
+  }
+}
+/**
+ * The set tag is used to set runtime values within the template. The value
+ * is set inside the current scope of the template.
+ *
+ * ```edge
+ * @set('user.username', 'virk')
+ * <p> {{ user.username }} </p>
+ * ```
+ *
+ * Set it inside the each loop.
+ *
+ * ```edge
+ * @each(user in users)
+ *   @set('age', user.age + 1)
+ *   {{ age }}
+ * @endeach
+ * ```
+ */
+export declare const setTag: TagContract

package/src/migrate/tags/set.js

@@ -0,0 +1,104 @@
+"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.setTag = void 0;
+const edge_error_1 = require("edge-error");
+const edge_parser_1 = require("edge-parser");
+const lodash_1 = __importDefault(require("@poppinss/utils/lodash"));
+const utils_js_1 = require("../../utils.js");
+/**
+ * The set tag is used to set runtime values within the template. The value
+ * is set inside the current scope of the template.
+ *
+ * ```edge
+ * @set('user.username', 'virk')
+ * <p> {{ user.username }} </p>
+ * ```
+ *
+ * Set it inside the each loop.
+ *
+ * ```edge
+ * @each(user in users)
+ *   @set('age', user.age + 1)
+ *   {{ age }}
+ * @endeach
+ * ```
+ */
+exports.setTag = {
+    block: false,
+    seekable: true,
+    tagName: 'set',
+    noNewLine: true,
+    /**
+     * Compiles else block node to Javascript else statement
+     */
+    compile(parser, buffer, token) {
+        const parsed = (0, utils_js_1.parseJsArg)(parser, token);
+        /**
+         * The set tag only accepts a sequence expression.
+         */
+        (0, utils_js_1.isSubsetOf)(parsed, [edge_parser_1.expressions.SequenceExpression], () => {
+            throw (0, utils_js_1.unallowedExpression)(`"${token.properties.jsArg}" is not a valid key-value pair for the @slot tag`, token.filename, parser.utils.getExpressionLoc(parsed));
+        });
+        /**
+         * Disallow less than 2 and more than 3 values for the sequence
+         * expression
+         */
+        if (parsed.expressions.length < 2 || parsed.expressions.length > 3) {
+            throw new edge_error_1.EdgeError('@set tag accepts a minimum of 2 or maximum or 3 arguments', 'E_INVALID_ARGUMENTS_COUNT', {
+                line: parsed.loc.start.line,
+                col: parsed.loc.start.column,
+                filename: token.filename,
+            });
+        }
+        /**
+         * Extract key-value and the collection (if any)
+         */
+        let collection;
+        let key;
+        let value;
+        if (parsed.expressions.length === 3) {
+            collection = parsed.expressions[0];
+            key = parsed.expressions[1];
+            value = parsed.expressions[2];
+        }
+        else {
+            key = parsed.expressions[0];
+            value = parsed.expressions[1];
+        }
+        /**
+         * Mutate the collection when defined
+         */
+        if (collection) {
+            buffer.writeExpression(`template.setValue(${parser.utils.stringify(collection)}, '${key.value}', ${parser.utils.stringify(value)})`, token.filename, token.loc.start.line);
+            return;
+        }
+        /**
+         * Write statement to mutate the key. If the variable has already been
+         * defined, then just update it's value.
+         *
+         * We do not allow re-declaring a variable as of now
+         */
+        const expression = parser.stack.has(key.value)
+            ? `${key.value} = ${parser.utils.stringify(value)}`
+            : `let ${key.value} = ${parser.utils.stringify(value)}`;
+        buffer.writeExpression(expression, token.filename, token.loc.start.line);
+        parser.stack.defineVariable(key.value);
+    },
+    /**
+     * Add methods to the template for running the loop
+     */
+    boot(template) {
+        template.macro('setValue', lodash_1.default.set);
+    },
+};

package/src/migrate/tags/super.d.ts

@@ -0,0 +1,9 @@
+import { type TagContract } from '../../types.js'
+/**
+ * Super tag is used inside sections to inherit the parent section
+ * content.
+ *
+ * The implementation of super tag is handled by the compiler itself, but we need
+ * the tag to exists, so that the lexer can parse it as a tag.
+ */
+export declare const superTag: TagContract

package/src/migrate/tags/super.js

@@ -0,0 +1,31 @@
+"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.superTag = void 0;
+const edge_error_1 = require("edge-error");
+/**
+ * Super tag is used inside sections to inherit the parent section
+ * content.
+ *
+ * The implementation of super tag is handled by the compiler itself, but we need
+ * the tag to exists, so that the lexer can parse it as a tag.
+ */
+exports.superTag = {
+    block: false,
+    seekable: false,
+    tagName: 'super',
+    compile(_, __, token) {
+        throw new edge_error_1.EdgeError('@super tag must appear as top level tag inside the @section tag', 'E_ORPHAN_SUPER_TAG', {
+            line: token.loc.start.line,
+            col: token.loc.start.col,
+            filename: token.filename,
+        });
+    },
+};

package/src/plugins/supercharged.d.ts

@@ -0,0 +1,4 @@
+import { type PluginFn } from '../types.js'
+export declare const pluginSuperCharged: PluginFn<{
+  recurring: boolean
+}>

package/src/plugins/supercharged.js

@@ -0,0 +1,88 @@
+"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.pluginSuperCharged = void 0;
+/**
+ * Hooks into the compiler phase of Edge and converts
+ * tags to components.
+ *
+ * The components are discovered from the components directory
+ * inside every registered disk.
+ */
+class SuperChargedComponents {
+    #edge;
+    #components = {};
+    constructor(edge) {
+        this.#edge = edge;
+        this.#claimTags();
+        this.#transformTags();
+    }
+    /**
+     * Refreshes the list of components
+     */
+    refreshComponents() {
+        this.#components = this.#edge.loader
+            .listComponents()
+            .reduce((result, { components }) => {
+            components.forEach((component) => {
+                result[component.tagName] = component.componentName;
+            });
+            return result;
+        }, {});
+    }
+    /**
+     * Registers hook to claim self processing of tags that
+     * are references to components
+     */
+    #claimTags() {
+        this.#edge.compiler.claimTag((name) => {
+            if (this.#components[name]) {
+                return { seekable: true, block: true };
+            }
+            return null;
+        });
+        this.#edge.asyncCompiler.claimTag((name) => {
+            if (this.#components[name]) {
+                return { seekable: true, block: true };
+            }
+            return null;
+        });
+    }
+    /**
+     * Transforms tags to component calls
+     */
+    #transformTags() {
+        this.#edge.processor.process('tag', ({ tag }) => {
+            const component = this.#components[tag.properties.name];
+            if (!component) {
+                return;
+            }
+            tag.properties.name = 'component';
+            if (tag.properties.jsArg.trim() === '') {
+                tag.properties.jsArg = `'${component}'`;
+            }
+            else {
+                tag.properties.jsArg = `'${component}',${tag.properties.jsArg}`;
+            }
+        });
+    }
+}
+/**
+ * The superCharged plugin converts components stored within the
+ * components directory of all the disk to Edge tags.
+ */
+let superCharged;
+const pluginSuperCharged = (edge, firstRun) => {
+    if (firstRun) {
+        superCharged = new SuperChargedComponents(edge);
+    }
+    superCharged.refreshComponents();
+};
+exports.pluginSuperCharged = pluginSuperCharged;

package/src/processor.d.ts

@@ -0,0 +1,42 @@
+import type { Template } from './template.js'
+import type { TagToken } from 'edge-lexer/types'
+/**
+ * Exposes the API to register a set of handlers to process the
+ * templates output at different stages
+ */
+export declare class Processor {
+  #private
+  /**
+   * Execute tag handler
+   */
+  executeTag(data: { tag: TagToken; path: string }): void
+  /**
+   * Execute raw handlers
+   */
+  executeRaw(data: { raw: string; path: string }): string
+  /**
+   * Execute compiled handlers
+   */
+  executeCompiled(data: { compiled: string; path: string }): string
+  /**
+   * Execute output handlers
+   */
+  executeOutput(data: { output: string; template: Template; state: Record<string, any> }): string
+  /**
+   * Define a processor function
+   */
+  process(event: 'raw', handler: (data: { raw: string; path: string }) => string | void): this
+  process(event: 'tag', handler: (data: { tag: TagToken; path: string }) => void): this
+  process(
+    event: 'compiled',
+    handler: (data: { compiled: string; path: string }) => string | void
+  ): this
+  process(
+    event: 'output',
+    handler: (data: {
+      output: string
+      template: Template
+      state: Record<string, any>
+    }) => string | void
+  ): this
+}