edgexpress 3.0.1 → 3.0.2

package/src/edge/stacks.js

@@ -0,0 +1,98 @@
+"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 });
+const node_os_1 = require("node:os");
+class Stacks {
+    #contentSources = new Map();
+    /**
+     * Pre-seeded content before the placeholder has been
+     * defined.
+     */
+    #seededPlaceholders = new Map();
+    /**
+     * Placeholders to be flushed
+     */
+    #placeholders = new Map();
+    /**
+     * Returns the placeholder name for a given stack
+     */
+    #createPlaceholder(name) {
+        return `<!-- @edge.stacks.${name} -->`;
+    }
+    /**
+     * Create a new stack placeholder. Multiple calls to this method
+     * with the same name results in an exception.
+     */
+    create(name) {
+        if (this.#placeholders.has(name)) {
+            throw new Error(`Cannot declare stack "${name}" for multiple times`);
+        }
+        /**
+         * Copy content from the seeded placeholders and delete it
+         */
+        const seededPlaceholder = this.#seededPlaceholders.get(name) || [];
+        this.#seededPlaceholders.delete(name);
+        this.#placeholders.set(name, [...seededPlaceholder]);
+        return this.#createPlaceholder(name);
+    }
+    /**
+     * Push content inside a given stack. Content can be pre-seeded
+     * without creating a stack
+     */
+    pushTo(name, contents) {
+        let placeholder = this.#placeholders.get(name);
+        if (!placeholder) {
+            if (!this.#seededPlaceholders.has(name)) {
+                this.#seededPlaceholders.set(name, []);
+            }
+            const seededPlaceholder = this.#seededPlaceholders.get(name);
+            seededPlaceholder.push(contents);
+            return this;
+        }
+        /**
+         * Defined content for the unique key inside a given
+         * stack
+         */
+        placeholder.push(contents);
+        return this;
+    }
+    /**
+     * Push contents to a stack with a unique source id. A
+     * source can only push once to a given stack.
+     */
+    pushOnceTo(name, sourceId, contents) {
+        const contentSources = this.#contentSources.get(name);
+        if (contentSources && contentSources.has(sourceId)) {
+            return;
+        }
+        this.pushTo(name, contents);
+        /**
+         * Track source
+         */
+        if (contentSources) {
+            contentSources.add(sourceId);
+        }
+        else {
+            this.#contentSources.set(name, new Set([sourceId]));
+        }
+    }
+    /**
+     * Fill placeholders with their actual content
+     */
+    fillPlaceholders(contents) {
+        for (let [name, sources] of this.#placeholders) {
+            contents = contents.replace(this.#createPlaceholder(name), sources.join(node_os_1.EOL));
+        }
+        this.#placeholders.clear();
+        this.#seededPlaceholders.clear();
+        return contents;
+    }
+}
+exports.default = Stacks;

package/src/loader.d.ts

@@ -0,0 +1,138 @@
+/**
+ * edge
+ *
+ * (c) EdgeJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import type { ComponentsTree, LoaderContract, LoaderTemplate } from './types.js'
+/**
+ * The job of a loader is to load the template from a given path.
+ * The base loader (shipped with edge) looks for files on the
+ * file-system and reads them synchronously.
+ *
+ * You are free to define your own loaders that implements the [[LoaderContract]] interface.
+ */
+export declare class Loader implements LoaderContract {
+  #private
+  /**
+   * Returns an object of mounted directories with their public
+   * names.
+   *
+   * ```js
+   * loader.mounted
+   * // output
+   *
+   * {
+   *   default: '/users/virk/code/app/views',
+   *   foo: '/users/virk/code/app/foo',
+   * }
+   * ```
+   */
+  get mounted(): {
+    [key: string]: string
+  }
+  /**
+   * Returns an object of templates registered as a raw string
+   *
+   * ```js
+   * loader.templates
+   * // output
+   *
+   * {
+   *   'form.label': { template: 'Template contents' }
+   * }
+   * ```
+   */
+  get templates(): {
+    [templatePath: string]: LoaderTemplate
+  }
+  /**
+   * Mount a directory with a name for resolving views. If name is set
+   * to `default`, then you can resolve views without prefixing the
+   * disk name.
+   *
+   * ```js
+   * loader.mount('default', join(__dirname, 'views'))
+   *
+   * // mount a named disk
+   * loader.mount('admin', join(__dirname, 'admin/views'))
+   * ```
+   */
+  mount(diskName: string, dirPath: string | URL): void
+  /**
+   * Remove the previously mounted dir.
+   *
+   * ```js
+   * loader.unmount('default')
+   * ```
+   */
+  unmount(diskName: string): void
+  /**
+   * Make path to a given template. The paths are resolved from the root
+   * of the mounted directory.
+   *
+   * ```js
+   * loader.makePath('welcome') // returns {diskRootPath}/welcome.edge
+   * loader.makePath('admin::welcome') // returns {adminRootPath}/welcome.edge
+   * loader.makePath('users.list') // returns {diskRootPath}/users/list.edge
+   * ```
+   *
+   * @throws Error if disk is not mounted and attempting to make path for it.
+   */
+  makePath(templatePath: string): string
+  /**
+   * Resolves the template by reading its contents from the disk
+   *
+   * ```js
+   * loader.resolve('welcome', true)
+   *
+   * // output
+   * {
+   *   template: `<h1> Template content </h1>`,
+   * }
+   * ```
+   */
+  resolve(templatePath: string): LoaderTemplate
+  /**
+   * Register in memory template for a given path. This is super helpful
+   * when distributing components.
+   *
+   * ```js
+   * loader.register('welcome', {
+   *   template: '<h1> Template content </h1>',
+   *   Presenter: class Presenter {
+   *     constructor (state) {
+   *       this.state = state
+   *     }
+   *   }
+   * })
+   * ```
+   *
+   * @throws Error if template content is empty.
+   */
+  register(templatePath: string, contents: LoaderTemplate): void
+  /**
+   * Remove registered template
+   */
+  remove(templatePath: string): void
+  /**
+   * Returns a list of components from all the disks. We assume
+   * the components are stored within the components directory.
+   *
+   * Also, we treat all in-memory templates as components.
+   *
+   * The return path is same the path you will pass to the `@component`
+   * tag.
+   */
+  listComponents(): ComponentsTree
+  /**
+   * Returns a list of templates from all the disks and in-memory
+   * templates as well
+   */
+  listTemplates(): {
+    diskName: string
+    templates: string[]
+  }[]
+}

package/src/loader.js

@@ -0,0 +1,347 @@
+"use strict";
+/**
+ * edge
+ *
+ * (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.Loader = void 0;
+const node_url_1 = require("node:url");
+const string_1 = __importDefault(require("@poppinss/utils/string"));
+const node_path_1 = require("node:path");
+const node_fs_1 = require("node:fs");
+/**
+ * The job of a loader is to load the template from a given path.
+ * The base loader (shipped with edge) looks for files on the
+ * file-system and reads them synchronously.
+ *
+ * You are free to define your own loaders that implements the [[LoaderContract]] interface.
+ */
+class Loader {
+    /**
+     * List of mounted directories
+     */
+    #mountedDirs = new Map();
+    /**
+     * List of pre-registered (in-memory) templates
+     */
+    #preRegistered = new Map();
+    /**
+     * Reads the content of a template from the disk. An exception is raised
+     * when file is missing or if `readFileSync` returns an error.
+     */
+    #readTemplateContents(absPath) {
+        try {
+            return (0, node_fs_1.readFileSync)(absPath, 'utf-8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                throw new Error(`Cannot resolve "${absPath}". Make sure the file exists`);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    /**
+     * Returns a list of components for a given disk
+     */
+    #getDiskComponents(diskName) {
+        const componentsDirName = 'components';
+        const diskBasePath = this.#mountedDirs.get(diskName);
+        let files = diskName === 'default'
+            ? Array.from(this.#preRegistered.keys()).map((template) => {
+                return {
+                    fileName: template,
+                    componentPath: template,
+                };
+            })
+            : [];
+        /**
+         * Read disk files
+         */
+        const componentsPath = (0, node_path_1.join)(diskBasePath, componentsDirName);
+        if ((0, node_fs_1.existsSync)(componentsPath)) {
+            files = files.concat((0, node_fs_1.readdirSync)((0, node_path_1.join)(componentsPath), {
+                recursive: true,
+                withFileTypes: true,
+            })
+                .filter((file) => {
+                return file.isFile() && file.name.endsWith('.edge');
+            })
+                .map((file) => {
+                const fileName = string_1.default
+                    .toUnixSlash((0, node_path_1.relative)(componentsPath, (0, node_path_1.join)(file.parentPath, file.name)))
+                    .replace(/\.edge$/, '');
+                return {
+                    fileName,
+                    componentPath: `${componentsDirName}/${fileName}`,
+                };
+            }));
+        }
+        return files.map(({ fileName, componentPath }) => {
+            const tagName = fileName
+                .split('/')
+                .filter((segment, index) => {
+                return index === 0 || segment !== 'index';
+            })
+                .map((segment) => string_1.default.camelCase(segment))
+                .join('.');
+            return {
+                componentName: diskName !== 'default' ? `${diskName}::${componentPath}` : componentPath,
+                tagName: diskName !== 'default' ? `${diskName}.${tagName}` : tagName,
+            };
+        });
+    }
+    /**
+     * Returns a list of templates for a given disk
+     */
+    #getDiskTemplates(diskName) {
+        const diskBasePath = this.#mountedDirs.get(diskName);
+        let files = diskName === 'default' ? Array.from(this.#preRegistered.keys()) : [];
+        if ((0, node_fs_1.existsSync)(diskBasePath)) {
+            files = files.concat((0, node_fs_1.readdirSync)(diskBasePath, {
+                recursive: true,
+                withFileTypes: true,
+            })
+                .filter((file) => {
+                return file.isFile() && file.name.endsWith('.edge');
+            })
+                .map((file) => {
+                return (0, node_path_1.relative)(diskBasePath, (0, node_path_1.join)(file.parentPath, file.name)).replace(/\.edge$/, '');
+            }));
+        }
+        return files.map((file) => {
+            const fileName = string_1.default.toUnixSlash(file).replace(/\.edge$/, '');
+            return diskName !== 'default' ? `${diskName}::${fileName}` : fileName;
+        });
+    }
+    /**
+     * Extracts the disk name and the template name from the template
+     * path expression.
+     *
+     * If `diskName` is missing, it will be set to `default`.
+     *
+     * ```
+     * extractDiskAndTemplateName('users::list')
+     * // returns ['users', 'list.edge']
+     *
+     * extractDiskAndTemplateName('list')
+     * // returns ['default', 'list.edge']
+     * ```
+     */
+    #extractDiskAndTemplateName(templatePath) {
+        let [disk, ...rest] = templatePath.split('::');
+        if (!rest.length) {
+            rest = [disk];
+            disk = 'default';
+        }
+        let [template, ext] = rest.join('::').split('.edge');
+        return [disk, `${template}.${ext || 'edge'}`];
+    }
+    /**
+     * Returns an object of mounted directories with their public
+     * names.
+     *
+     * ```js
+     * loader.mounted
+     * // output
+     *
+     * {
+     *   default: '/users/virk/code/app/views',
+     *   foo: '/users/virk/code/app/foo',
+     * }
+     * ```
+     */
+    get mounted() {
+        return Array.from(this.#mountedDirs).reduce((obj, [key, value]) => {
+            obj[key] = value;
+            return obj;
+        }, {});
+    }
+    /**
+     * Returns an object of templates registered as a raw string
+     *
+     * ```js
+     * loader.templates
+     * // output
+     *
+     * {
+     *   'form.label': { template: 'Template contents' }
+     * }
+     * ```
+     */
+    get templates() {
+        return Array.from(this.#preRegistered).reduce((obj, [key, value]) => {
+            obj[key] = value;
+            return obj;
+        }, {});
+    }
+    /**
+     * Mount a directory with a name for resolving views. If name is set
+     * to `default`, then you can resolve views without prefixing the
+     * disk name.
+     *
+     * ```js
+     * loader.mount('default', join(__dirname, 'views'))
+     *
+     * // mount a named disk
+     * loader.mount('admin', join(__dirname, 'admin/views'))
+     * ```
+     */
+    mount(diskName, dirPath) {
+        this.#mountedDirs.set(diskName, typeof dirPath === 'string' ? dirPath : (0, node_url_1.fileURLToPath)(dirPath));
+    }
+    /**
+     * Remove the previously mounted dir.
+     *
+     * ```js
+     * loader.unmount('default')
+     * ```
+     */
+    unmount(diskName) {
+        this.#mountedDirs.delete(diskName);
+    }
+    /**
+     * Make path to a given template. The paths are resolved from the root
+     * of the mounted directory.
+     *
+     * ```js
+     * loader.makePath('welcome') // returns {diskRootPath}/welcome.edge
+     * loader.makePath('admin::welcome') // returns {adminRootPath}/welcome.edge
+     * loader.makePath('users.list') // returns {diskRootPath}/users/list.edge
+     * ```
+     *
+     * @throws Error if disk is not mounted and attempting to make path for it.
+     */
+    makePath(templatePath) {
+        /**
+         * Return the template path as it is, when it is registered
+         * dynamically
+         */
+        if (this.#preRegistered.has(templatePath)) {
+            return templatePath;
+        }
+        /**
+         * Return absolute path as it is
+         */
+        if ((0, node_path_1.isAbsolute)(templatePath)) {
+            return templatePath;
+        }
+        /**
+         * Extract disk name and template path from the expression
+         */
+        const [diskName, template] = this.#extractDiskAndTemplateName(templatePath);
+        /**
+         * Raise exception when disk name is not registered
+         */
+        const mountedDir = this.#mountedDirs.get(diskName);
+        if (!mountedDir) {
+            throw new Error(`"${diskName}" namespace is not mounted`);
+        }
+        return (0, node_path_1.join)(mountedDir, template);
+    }
+    /**
+     * Resolves the template by reading its contents from the disk
+     *
+     * ```js
+     * loader.resolve('welcome', true)
+     *
+     * // output
+     * {
+     *   template: `<h1> Template content </h1>`,
+     * }
+     * ```
+     */
+    resolve(templatePath) {
+        /**
+         * Return from pre-registered one's if exists
+         */
+        if (this.#preRegistered.has(templatePath)) {
+            return this.#preRegistered.get(templatePath);
+        }
+        /**
+         * Make absolute to the file on the disk
+         */
+        templatePath = (0, node_path_1.isAbsolute)(templatePath) ? templatePath : this.makePath(templatePath);
+        return {
+            template: this.#readTemplateContents(templatePath),
+        };
+    }
+    /**
+     * Register in memory template for a given path. This is super helpful
+     * when distributing components.
+     *
+     * ```js
+     * loader.register('welcome', {
+     *   template: '<h1> Template content </h1>',
+     *   Presenter: class Presenter {
+     *     constructor (state) {
+     *       this.state = state
+     *     }
+     *   }
+     * })
+     * ```
+     *
+     * @throws Error if template content is empty.
+     */
+    register(templatePath, contents) {
+        /**
+         * Ensure template content is defined as a string
+         */
+        if (typeof contents.template !== 'string') {
+            throw new Error('Make sure to define the template content as a string');
+        }
+        /**
+         * Do not overwrite existing template with same template path
+         */
+        if (this.#preRegistered.has(templatePath)) {
+            throw new Error(`Cannot override previously registered "${templatePath}" template`);
+        }
+        this.#preRegistered.set(templatePath, contents);
+    }
+    /**
+     * Remove registered template
+     */
+    remove(templatePath) {
+        this.#preRegistered.delete(templatePath);
+    }
+    /**
+     * Returns a list of components from all the disks. We assume
+     * the components are stored within the components directory.
+     *
+     * Also, we treat all in-memory templates as components.
+     *
+     * The return path is same the path you will pass to the `@component`
+     * tag.
+     */
+    listComponents() {
+        const diskNames = [...this.#mountedDirs.keys()];
+        return diskNames.map((diskName) => {
+            return {
+                diskName,
+                components: this.#getDiskComponents(diskName),
+            };
+        });
+    }
+    /**
+     * Returns a list of templates from all the disks and in-memory
+     * templates as well
+     */
+    listTemplates() {
+        const diskNames = [...this.#mountedDirs.keys()];
+        return diskNames.map((diskName) => {
+            return {
+                diskName,
+                templates: this.#getDiskTemplates(diskName),
+            };
+        });
+    }
+}
+exports.Loader = Loader;

package/src/migrate/globals.d.ts

@@ -0,0 +1 @@
+export declare const GLOBALS: Record<string, Function>

package/src/migrate/globals.js

@@ -0,0 +1,100 @@
+"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.GLOBALS = void 0;
+const edge_error_1 = require("edge-error");
+// @ts-ignore untyped module
+const js_stringify_1 = __importDefault(require("js-stringify"));
+// @ts-ignore untyped module
+const inspect_1 = __importDefault(require("@poppinss/inspect"));
+const { string: prettyPrintHtml } = inspect_1.default;
+const string_1 = __importDefault(require("@poppinss/utils/string"));
+const template_js_1 = require("../template.js");
+exports.GLOBALS = {
+    /**
+     * 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)(prettyPrintHtml.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,
+        });
+    },
+    /**
+     * Raise an exception
+     */
+    raise: (message, options) => {
+        if (!options) {
+            throw new Error(message);
+        }
+        else {
+            throw new edge_error_1.EdgeError(message, 'E_RUNTIME_EXCEPTION', options);
+        }
+    },
+    /**
+     * 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,
+        });
+    },
+    /**
+     * Using `"e"` because, `escape` is a global function in the
+     * Node.js global namespace and edge parser gives priority
+     * to it
+     */
+    e: template_js_1.escape,
+    /**
+     * Convert javascript data structures to a string. The method is a little
+     * better over JSON.stringify in handling certain data structures. For
+     * example: In JSON.stringify, the date is converted to an ISO string
+     * whereas this method converts it to an actual instance of date
+     */
+    stringify: js_stringify_1.default,
+    safe: template_js_1.htmlSafe,
+    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,
+};

package/src/migrate/plugin.d.ts

@@ -0,0 +1,2 @@
+import type { PluginFn } from '../types.js'
+export declare const migrate: PluginFn<undefined>