edgexpress 3.0.0 → 3.0.2

package/src/compiler.js

@@ -0,0 +1,319 @@
+"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 __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.Compiler = void 0;
+const edge_error_1 = require("edge-error");
+const lexerUtils = __importStar(require("edge-lexer/utils"));
+const edge_parser_1 = require("edge-parser");
+const cache_manager_js_1 = require("./cache_manager.js");
+const AsyncFunction = Object.getPrototypeOf(async function () { }).constructor;
+/**
+ * Compiler is to used to compile templates using the `edge-parser`. Along with that
+ * it natively merges the contents of a layout with a parent template.
+ */
+class Compiler {
+    /**
+     * The variables someone can access inside templates. All other
+     * variables will get prefixed with `state` property name
+     */
+    #inlineVariables = ['$filename', 'state', '$context'];
+    /**
+     * A fixed set of params to pass to the template every time.
+     */
+    #templateParams = ['template', 'state', '$context'];
+    #claimTagFn;
+    #loader;
+    #tags;
+    #processor;
+    /**
+     * Caches compiled templates
+     */
+    cacheManager;
+    /**
+     * A boolean to know if compat mode is enabled
+     */
+    compat;
+    /**
+     * Know if compiler is compiling in the async mode or not
+     */
+    async;
+    constructor(loader, tags, processor, options = {
+        cache: true,
+        async: false,
+        compat: false,
+    }) {
+        this.#processor = processor;
+        this.#loader = loader;
+        this.#tags = tags;
+        this.async = !!options.async;
+        this.compat = options.compat === true;
+        this.cacheManager = new cache_manager_js_1.CacheManager(!!options.cache);
+    }
+    /**
+     * Merges sections of base template and parent template tokens
+     */
+    #mergeSections(base, extended) {
+        /**
+         * Collection of all sections from the extended tokens
+         */
+        const extendedSections = {};
+        /**
+         * Collection of extended set calls as top level nodes. The set
+         * calls are hoisted just like `var` statements in Javascript.
+         */
+        const extendedSetCalls = [];
+        extended.forEach((node) => {
+            /**
+             * Ignore new lines, comments, layout tag and empty raw nodes inside the parent
+             * template
+             */
+            if (lexerUtils.isTag(node, 'layout') ||
+                node.type === 'newline' ||
+                (node.type === 'raw' && !node.value.trim()) ||
+                node.type === 'comment') {
+                return;
+            }
+            /**
+             * Collect parent template sections
+             */
+            if (lexerUtils.isTag(node, 'section')) {
+                extendedSections[node.properties.jsArg.trim()] = node;
+                return;
+            }
+            /**
+             * Collect set calls inside parent templates
+             */
+            if (lexerUtils.isTag(node, 'set')) {
+                extendedSetCalls.push(node);
+                return;
+            }
+            /**
+             * Everything else is not allowed as top level nodes
+             */
+            const [line, col] = lexerUtils.getLineAndColumn(node);
+            throw new edge_error_1.EdgeError('Template extending a layout can only use "@section" or "@set" tags as top level nodes', 'E_UNALLOWED_EXPRESSION', { line, col, filename: node.filename });
+        });
+        /**
+         * Replace/extend sections inside base tokens list
+         */
+        const finalNodes = base.map((node) => {
+            if (!lexerUtils.isTag(node, 'section')) {
+                return node;
+            }
+            const sectionName = node.properties.jsArg.trim();
+            const extendedNode = extendedSections[sectionName];
+            if (!extendedNode) {
+                return node;
+            }
+            /**
+             * Concat children when super was called
+             */
+            if (extendedNode.children.length) {
+                if (lexerUtils.isTag(extendedNode.children[0], 'super')) {
+                    extendedNode.children.shift();
+                    extendedNode.children = node.children.concat(extendedNode.children);
+                }
+                else if (lexerUtils.isTag(extendedNode.children[1], 'super')) {
+                    extendedNode.children.shift();
+                    extendedNode.children.shift();
+                    extendedNode.children = node.children.concat(extendedNode.children);
+                }
+            }
+            return extendedNode;
+        });
+        /**
+         * Set calls are hoisted to the top
+         */
+        return [].concat(extendedSetCalls).concat(finalNodes);
+    }
+    /**
+     * Generates an array of lexer tokens from the template string. Further tokens
+     * are checked for layouts and if layouts are used, their sections will be
+     * merged together.
+     */
+    #templateContentToTokens(content, parser, absPath) {
+        let templateTokens = parser.tokenize(content, { filename: absPath });
+        /**
+         * Parse layout and section in compat mode only
+         */
+        if (this.compat) {
+            const firstToken = templateTokens[0];
+            /**
+             * The `layout` is inbuilt feature from core, where we merge the layout
+             * and parent template sections together
+             */
+            if (lexerUtils.isTag(firstToken, 'layout')) {
+                const layoutName = firstToken.properties.jsArg.replace(/'|"/g, '');
+                templateTokens = this.#mergeSections(this.tokenize(layoutName, parser), templateTokens);
+            }
+        }
+        return templateTokens;
+    }
+    /**
+     * Returns the parser instance for a given template
+     */
+    #getParserFor(templatePath, localVariables) {
+        const parser = new edge_parser_1.Parser(this.#tags, new edge_parser_1.Stack(), {
+            claimTag: this.#claimTagFn,
+            async: this.async,
+            statePropertyName: 'state',
+            escapeCallPath: ['template', 'escape'],
+            localVariables: this.#inlineVariables,
+            onTag: (tag) => this.#processor.executeTag({ tag, path: templatePath }),
+        });
+        /**
+         * Define local variables on the parser. This is helpful when trying to compile
+         * a partail and we want to share the local state of the parent template
+         * with it
+         */
+        if (localVariables) {
+            localVariables.forEach((localVariable) => parser.stack.defineVariable(localVariable));
+        }
+        return parser;
+    }
+    /**
+     * Returns the parser instance for a given template
+     */
+    #getBufferFor(templatePath) {
+        return new edge_parser_1.EdgeBuffer(templatePath, {
+            outputVar: 'out',
+            rethrowCallPath: ['template', 'reThrow'],
+        });
+    }
+    /**
+     * Wraps template output to a function along with local variables
+     */
+    #wrapToFunction(template, localVariables) {
+        const args = localVariables ? this.#templateParams.concat(localVariables) : this.#templateParams;
+        if (this.async) {
+            return new AsyncFunction(...args, template);
+        }
+        return new Function(...args, template);
+    }
+    /**
+     * Define a function to claim tags
+     */
+    claimTag(fn) {
+        this.#claimTagFn = fn;
+        return this;
+    }
+    /**
+     * Converts the template content to an array of lexer tokens. The method is
+     * same as the `parser.tokenize`, but it also handles layouts natively.
+     *
+     * ```
+     * compiler.tokenize('<template-path>')
+     * ```
+     */
+    tokenize(templatePath, parser) {
+        const absPath = this.#loader.makePath(templatePath);
+        let { template } = this.#loader.resolve(absPath);
+        return this.tokenizeRaw(template, absPath, parser);
+    }
+    /**
+     * Tokenize a raw template
+     */
+    tokenizeRaw(contents, templatePath = 'eval.edge', parser) {
+        contents = this.#processor.executeRaw({ path: templatePath, raw: contents });
+        return this.#templateContentToTokens(contents, parser || this.#getParserFor(templatePath), templatePath);
+    }
+    /**
+     * Compiles the template contents to string. The output is same as the `edge-parser`,
+     * it's just that the compiler uses the loader to load the templates and also
+     * handles layouts.
+     *
+     * ```js
+     * compiler.compile('welcome')
+     * ```
+     */
+    compile(templatePath, localVariables) {
+        const absPath = this.#loader.makePath(templatePath);
+        let cachedResponse = localVariables ? null : this.cacheManager.get(absPath);
+        /**
+         * Process the template and cache it
+         */
+        if (!cachedResponse) {
+            const parser = this.#getParserFor(absPath, localVariables);
+            const buffer = this.#getBufferFor(absPath);
+            /**
+             * Generate tokens and process them
+             */
+            const templateTokens = this.tokenize(absPath, parser);
+            templateTokens.forEach((token) => parser.processToken(token, buffer));
+            /**
+             * Processing template via hook
+             */
+            const template = this.#processor.executeCompiled({
+                path: absPath,
+                compiled: buffer.flush(),
+            });
+            const compiledTemplate = this.#wrapToFunction(template, localVariables);
+            if (!localVariables) {
+                this.cacheManager.set(absPath, compiledTemplate);
+            }
+            cachedResponse = compiledTemplate;
+        }
+        return cachedResponse;
+    }
+    /**
+     * Compiles the template contents to string. The output is same as the `edge-parser`,
+     * it's just that the compiler uses the loader to load the templates and also
+     * handles layouts.
+     *
+     * ```js
+     * compiler.compileRaw('welcome')
+     * ```
+     */
+    compileRaw(contents, templatePath = 'eval.edge') {
+        const parser = this.#getParserFor(templatePath);
+        const buffer = this.#getBufferFor(templatePath);
+        const templateTokens = this.tokenizeRaw(contents, templatePath, parser);
+        templateTokens.forEach((token) => parser.processToken(token, buffer));
+        const template = this.#processor.executeCompiled({
+            path: templatePath,
+            compiled: buffer.flush(),
+        });
+        return this.#wrapToFunction(template);
+    }
+}
+exports.Compiler = Compiler;

package/src/component/props.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Representation of component props with ability to serialize
+ * them into HTML attributes
+ */
+export declare class ComponentProps {
+  #private
+  constructor(values: Record<string, any>)
+  /**
+   * Create a typed instance of Component props with properties
+   */
+  static create<T extends Record<string, any>>(values: T): ComponentProps & T
+  /**
+   * Reference to props raw values
+   */
+  all(): Record<string, any>
+  /**
+   * Check if a key exists
+   */
+  has(key: string): any
+  /**
+   * Get key value
+   */
+  get(key: string, defaultValue?: any): any
+  /**
+   * Returns a new props bag with only the mentioned keys
+   */
+  only(keys: string[]): ComponentProps
+  /**
+   * Returns a new props bag with except the mentioned keys
+   */
+  except(keys: string[]): ComponentProps
+  /**
+   * Merge defaults with the props
+   *
+   * - All other attributes will be overwritten when defined in props
+   * - Classes will be merged together.
+   */
+  merge(values: Record<string, any>): ComponentProps
+  /**
+   * Merge defaults with the props, if the given condition is truthy
+   */
+  mergeIf(conditional: any, values: Record<string, any>): ComponentProps
+  /**
+   * Merge defaults with the props, if the given condition is falsy
+   */
+  mergeUnless(conditional: any, values: Record<string, any>): ComponentProps
+  /**
+   * Converts props to HTML attributes
+   */
+  toAttrs(): {
+    value: any
+  }
+}

package/src/component/props.js

@@ -0,0 +1,110 @@
+"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.ComponentProps = void 0;
+const lodash_1 = __importDefault(require("@poppinss/utils/lodash"));
+const template_js_1 = require("../template.js");
+const utils_js_1 = require("../utils.js");
+/**
+ * Representation of component props with ability to serialize
+ * them into HTML attributes
+ */
+class ComponentProps {
+    #values;
+    constructor(values) {
+        this.#values = values;
+        Object.assign(this, values);
+    }
+    /**
+     * Create a typed instance of Component props with properties
+     */
+    static create(values) {
+        return new ComponentProps(values);
+    }
+    /**
+     * Reference to props raw values
+     */
+    all() {
+        return this.#values;
+    }
+    /**
+     * Check if a key exists
+     */
+    has(key) {
+        return lodash_1.default.has(this.#values, key);
+    }
+    /**
+     * Get key value
+     */
+    get(key, defaultValue) {
+        return lodash_1.default.get(this.#values, key, defaultValue);
+    }
+    /**
+     * Returns a new props bag with only the mentioned keys
+     */
+    only(keys) {
+        return new ComponentProps(lodash_1.default.pick(this.#values, keys));
+    }
+    /**
+     * Returns a new props bag with except the mentioned keys
+     */
+    except(keys) {
+        return new ComponentProps(lodash_1.default.omit(this.#values, keys));
+    }
+    /**
+     * Merge defaults with the props
+     *
+     * - All other attributes will be overwritten when defined in props
+     * - Classes will be merged together.
+     */
+    merge(values) {
+        if (values.class && this.#values['class']) {
+            const classesSet = new Set();
+            (Array.isArray(values.class) ? values.class : [values]).forEach((item) => {
+                classesSet.add(item);
+            });
+            (Array.isArray(this.#values['class'])
+                ? this.#values['class']
+                : [this.#values['class']]).forEach((item) => {
+                classesSet.add(item);
+            });
+            return new ComponentProps({ ...values, ...this.#values, class: Array.from(classesSet) });
+        }
+        return new ComponentProps({ ...values, ...this.#values });
+    }
+    /**
+     * Merge defaults with the props, if the given condition is truthy
+     */
+    mergeIf(conditional, values) {
+        if (conditional) {
+            return this.merge(values);
+        }
+        return this;
+    }
+    /**
+     * Merge defaults with the props, if the given condition is falsy
+     */
+    mergeUnless(conditional, values) {
+        if (!conditional) {
+            return this.merge(values);
+        }
+        return this;
+    }
+    /**
+     * Converts props to HTML attributes
+     */
+    toAttrs() {
+        return (0, template_js_1.htmlSafe)((0, utils_js_1.stringifyAttributes)(this.#values));
+    }
+}
+exports.ComponentProps = ComponentProps;

package/src/edge/globals.d.ts

@@ -0,0 +1,5 @@
+import type { EdgeGlobals } from '../types.js'
+/**
+ * Inbuilt globals
+ */
+export declare const edgeGlobals: EdgeGlobals

package/src/edge/globals.js

@@ -0,0 +1,95 @@
+"use strict";
+/*
+ * edge.js.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.edgeGlobals = void 0;
+// @ts-expect-error untyped module
+const js_stringify_1 = __importDefault(require("js-stringify"));
+const classnames_1 = __importDefault(require("classnames"));
+// @ts-expect-error untyped module
+const inspect_1 = __importDefault(require("@poppinss/inspect"));
+const string_1 = __importDefault(require("@poppinss/utils/string"));
+const template_js_1 = require("../template.js");
+const utils_js_1 = require("../utils.js");
+/**
+ * Inbuilt globals
+ */
+exports.edgeGlobals = {
+    /**
+     * Converts new lines to break
+     */
+    nl2br: (value) => {
+        if (!value) {
+            return;
+        }
+        return String(value).replace(/([^>\r\n]?)(\r\n|\n\r|\r|\n)/g, '$1<br>');
+    },
+    /**
+     * Inspect state
+     */
+    inspect: (value) => {
+        return (0, template_js_1.htmlSafe)(inspect_1.default.string.html(value));
+    },
+    /**
+     * Truncate a sentence
+     */
+    truncate: (value, length = 20, options) => {
+        options = options || {};
+        return string_1.default.truncate(value, length, {
+            completeWords: options.completeWords !== undefined ? options.completeWords : !options.strict,
+            suffix: options.suffix,
+        });
+    },
+    /**
+     * Generate an excerpt
+     */
+    excerpt: (value, length = 20, options) => {
+        options = options || {};
+        return string_1.default.excerpt(value, length, {
+            completeWords: options.completeWords !== undefined ? options.completeWords : !options.strict,
+            suffix: options.suffix,
+        });
+    },
+    /**
+     * Helpers related to HTML
+     */
+    html: {
+        escape: template_js_1.escape,
+        safe: template_js_1.htmlSafe,
+        classNames: classnames_1.default,
+        attrs: (values) => {
+            return (0, template_js_1.htmlSafe)((0, utils_js_1.stringifyAttributes)(values));
+        },
+    },
+    /**
+     * Helpers related to JavaScript
+     */
+    js: {
+        stringify: js_stringify_1.default,
+    },
+    camelCase: string_1.default.camelCase,
+    snakeCase: string_1.default.snakeCase,
+    dashCase: string_1.default.dashCase,
+    pascalCase: string_1.default.pascalCase,
+    capitalCase: string_1.default.capitalCase,
+    sentenceCase: string_1.default.sentenceCase,
+    dotCase: string_1.default.dotCase,
+    noCase: string_1.default.noCase,
+    titleCase: string_1.default.titleCase,
+    pluralize: string_1.default.pluralize,
+    sentence: string_1.default.sentence,
+    prettyMs: string_1.default.milliseconds.format,
+    toMs: string_1.default.milliseconds.parse,
+    prettyBytes: string_1.default.bytes.format,
+    toBytes: string_1.default.bytes.parse,
+    ordinal: string_1.default.ordinal,
+};