@kosatyi/ejs 0.0.113 → 0.0.115

package/dist/cjs/browser.js

@@ -876,7 +876,8 @@ function _outputContent(name, data) {
 _defineProperty(EjsInstance, "exports", ['configure', 'create', 'createContext', 'render', 'require', 'preload', 'compile', 'helpers']);
 
 const resolver = async (path, template, error) => {
-  return fetch(joinPath(path, template)).then(response => {
+  const url = new URL(joinPath(path, template), location.origin);
+  return fetch(url).then(response => {
     if (response.ok) return response.text();
     return error(1, "template ".concat(template, " not found"));
   }, reason => error(0, reason));

package/dist/esm/browser.js

@@ -958,7 +958,8 @@ class EjsInstance {
 }
 
 const resolver = async (path, template, error) => {
-    return fetch(joinPath(path, template)).then(
+    const url = new URL(joinPath(path, template), location.origin);
+    return fetch(url).then(
         (response) => {
             if (response.ok) return response.text()
             return error(1, `template ${template} not found`)

package/dist/types/browser.d.ts

@@ -0,0 +1,27 @@
+import { E as EjsInstance } from './index-BiIhwNBq.js';
+import { j as joinPath } from './element-CEdJaM42.js';
+export { e as element, a as escapeValue } from './element-CEdJaM42.js';
+
+const resolver = async (path, template, error) => {
+    return fetch(joinPath(path, template)).then(
+        (response) => {
+            if (response.ok) return response.text()
+            return error(1, `template ${template} not found`)
+        },
+        (reason) => error(0, reason),
+    )
+};
+
+const {
+    render,
+    configure,
+    create,
+    helpers,
+    createContext,
+    compile,
+    preload,
+} = new EjsInstance({
+    resolver,
+});
+
+export { compile, configure, create, createContext, helpers, preload, render };

package/dist/types/bundler.d.ts

@@ -0,0 +1,155 @@
+import fs from 'node:fs/promises';
+import globWatch from 'glob-watcher';
+import { join, dirname } from 'node:path';
+import { glob } from 'glob';
+import { b as bindContext } from './element-CEdJaM42.js';
+import { create } from './index.js';
+import './index-BiIhwNBq.js';
+
+class EjsBundler {
+    #templates = {}
+    #bundlerOptions = {
+        target: [],
+        umd: true,
+        minify: true,
+    }
+    #compile
+    #ejsOptions
+    #buildInProgress
+    static exports = ['build', 'watch', 'concat', 'output']
+
+    constructor(bundlerOptions = {}, ejsOptions = {}) {
+        bindContext(this, this.constructor.exports);
+        const { compile, configure } = create(ejsOptions);
+        Object.assign(this.#bundlerOptions, bundlerOptions);
+        this.#compile = compile;
+        this.#ejsOptions = configure({});
+        this.#buildInProgress = false;
+        this.#templates = {};
+    }
+
+    async #stageRead(path) {
+        return fs
+            .readFile(join(this.#ejsOptions.path, path))
+            .then((response) => response.toString())
+    }
+
+    #stageCompile(content, name) {
+        return this.#compile(content, name).source
+    }
+
+    #getBundle() {
+        const umd = this.#bundlerOptions.umd;
+        const strict = this.#ejsOptions.strict;
+        const module = this.#ejsOptions.precompiled;
+        const out = [];
+        if (umd) {
+            out.push('(function(global,factory){');
+            out.push(
+                'typeof exports === "object" && typeof module !== "undefined" ?',
+            );
+            out.push('module.exports = factory():');
+            out.push(
+                'typeof define === "function" && define.amd ? define(factory):',
+            );
+            out.push(
+                '(global = typeof globalThis !== "undefined" ? globalThis:',
+            );
+            out.push(`global || self,global["${module}"] = factory())`);
+            out.push('})(this,(function(){');
+        }
+        if (strict) out.push(`'use strict'`);
+        out.push('const templates = {}');
+        Object.entries(this.#templates).forEach(([name, content]) => {
+            name = JSON.stringify(name);
+            content = String(content);
+            out.push(`templates[${name}] = ${content}`);
+        });
+        if (umd) {
+            out.push('return templates}))');
+        } else {
+            out.push('export default templates');
+        }
+        return out.join('\n')
+    }
+
+    async build() {
+        if (this.#buildInProgress === true) return false
+        this.#buildInProgress = true;
+        await this.concat().catch(console.error);
+        await this.output().catch(console.error);
+        console.log('✅', 'bundle complete:', this.#bundlerOptions.target);
+        this.#buildInProgress = false;
+    }
+
+    async watch() {
+        console.log('🔍', 'watch directory:', this.#ejsOptions.path);
+        const pattern = '**/*.'.concat(this.#ejsOptions.extension);
+        const watcher = globWatch(pattern, { cwd: this.#ejsOptions.path });
+        const state = { build: null };
+        watcher.on('change', (path) => {
+            if (state.build) return
+            console.log('⟳', 'file change:', path);
+            state.build = this.build().then(() => {
+                state.build = null;
+            });
+        });
+        watcher.on('add', (path) => {
+            if (state.build) return
+            console.log('+', 'file added:', path);
+            state.build = this.build().then(() => {
+                state.build = null;
+            });
+        });
+    }
+
+    async concat() {
+        const pattern = '**/*.'.concat(this.#ejsOptions.extension);
+        const list = await glob(
+            pattern,
+            { cwd: this.#ejsOptions.path },
+            () => {},
+        );
+        for (let template of list) {
+            let content = '';
+            content = await this.#stageRead(template);
+            content = await this.#stageCompile(content, template);
+            this.#templates[template] = content;
+        }
+    }
+
+    async output() {
+        const target = [].concat(this.#bundlerOptions.target);
+        const content = this.#getBundle();
+        for (const file of target) {
+            const folderPath = dirname(file);
+            const folderExists = await fs
+                .stat(folderPath)
+                .then(() => true)
+                .catch(() => false);
+            if (folderExists === false) {
+                await fs.mkdir(folderPath, { recursive: true });
+            }
+            await fs.writeFile(file, content);
+        }
+    }
+}
+
+const bundler = (bundlerOptions = {}, ejsOptions = {}) => {
+    return new EjsBundler(bundlerOptions, ejsOptions)
+};
+
+const ejsRollupBundler = (bundlerOptions, ejsOptions) => {
+    const bundle = bundler(bundlerOptions, ejsOptions);
+    return {
+        name: 'ejs-bundler',
+        async buildStart() {
+            await bundle.concat();
+        },
+        async buildEnd() {
+            await bundle.output();
+        },
+    }
+};
+
+export { EjsBundler, bundler, ejsRollupBundler };

package/dist/types/element-CEdJaM42.d.ts

@@ -0,0 +1,178 @@
+const jsVariableName = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
+
+const typeProp = function () {
+    const args = [].slice.call(arguments);
+    const callback = args.shift();
+    return args.filter(callback).pop()
+};
+const isArray = (value) => Array.isArray(value);
+const isFunction = (value) => typeof value === 'function';
+const isString = (value) => typeof value === 'string';
+const isBoolean = (value) => typeof value === 'boolean';
+const isArrayOfVariables = (value) => {
+    if (!isArray(value)) return false
+    return value.filter((name) => {
+        const valid = jsVariableName.test(name);
+        if (valid === false)
+            console.log(
+                `ejsConfig.globals: expected '${name}' to be valid variable name --> skipped`,
+            );
+        return valid
+    })
+};
+
+const symbolEntities = {
+    "'": "'",
+    '\\': '\\',
+    '\r': 'r',
+    '\n': 'n',
+    '\t': 't',
+    '\u2028': 'u2028',
+    '\u2029': 'u2029',
+};
+
+const htmlEntities = {
+    '&': '&',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#x27;',
+};
+
+const regexKeys = (obj) =>
+    new RegExp(['[', Object.keys(obj).join(''), ']'].join(''), 'g');
+
+const htmlEntitiesMatch = regexKeys(htmlEntities);
+
+const symbolEntitiesMatch = regexKeys(symbolEntities);
+
+const entities = (string = '') => {
+    return ('' + string).replace(
+        htmlEntitiesMatch,
+        (match) => htmlEntities[match],
+    )
+};
+
+const symbols = (string) => {
+    return ('' + string).replace(
+        symbolEntitiesMatch,
+        (match) => '\\' + symbolEntities[match],
+    )
+};
+
+const escapeValue = (value, escape) => {
+    const check = value;
+    return check == null
+        ? ''
+        : Boolean(escape) === true
+          ? entities(check)
+          : check
+};
+
+const getPath = (context, name, strict) => {
+    let data = context;
+    let chunks = String(name).split('.');
+    let prop = chunks.pop();
+    for (let i = 0; i < chunks.length; i++) {
+        const part = chunks[i];
+        if (isFunction(data['toJSON'])) {
+            data = data.toJSON();
+        }
+        if (strict && data.hasOwnProperty(part) === false) {
+            data = {};
+            break
+        }
+        data = data[part] = data[part] || {};
+    }
+    if (isFunction(data['toJSON'])) {
+        data = data.toJSON();
+    }
+    return [data, prop]
+};
+
+const each = (object, callback) => {
+    let prop;
+    for (prop in object) {
+        if (hasProp(object, prop)) {
+            callback(object[prop], prop, object);
+        }
+    }
+};
+
+const omit = (object, list) => {
+    const result = { ...object };
+    for (const key of list) {
+        delete result[key];
+    }
+    return result
+};
+
+const hasProp = (object, prop) => {
+    return object && Object.hasOwn(object, prop)
+};
+
+const joinPath = (path, template) => {
+    template = [path, template].join('/');
+    template = template.replace(/\/\//g, '/');
+    return template
+};
+
+const bindContext = (object, methods = []) => {
+    for (let i = 0, len = methods.length; i < len; i++) {
+        const name = methods[i];
+        if (name in object) {
+            object[name] = object[name].bind(object);
+        }
+    }
+};
+
+const selfClosed = [
+    'area',
+    'base',
+    'br',
+    'col',
+    'embed',
+    'hr',
+    'img',
+    'input',
+    'link',
+    'meta',
+    'param',
+    'source',
+    'track',
+    'wbr',
+];
+
+const space = ' ';
+const quote = '"';
+const equal = '=';
+const slash = '/';
+const lt = '<';
+const gt = '>';
+
+const eachAttribute = ([key, value]) => {
+    if (value !== null && value !== undefined) {
+        return [entities(key), [quote, entities(value), quote].join('')].join(
+            equal,
+        )
+    }
+};
+
+const element = (tag, attrs, content) => {
+    const result = [];
+    const hasClosedTag = selfClosed.indexOf(tag) === -1;
+    const attributes = Object.entries(attrs ?? {})
+        .map(eachAttribute)
+        .filter((e) => e)
+        .join(space);
+    result.push([lt, tag, space, attributes, gt].join(''));
+    if (content && hasClosedTag) {
+        result.push(Array.isArray(content) ? content.join('') : content);
+    }
+    if (hasClosedTag) {
+        result.push([lt, slash, tag, gt].join(''));
+    }
+    return result.join('')
+};
+
+export { escapeValue as a, bindContext as b, isString as c, isBoolean as d, element as e, isArrayOfVariables as f, isArray as g, each as h, isFunction as i, joinPath as j, getPath as k, hasProp as l, omit as o, symbols as s, typeProp as t };

package/dist/types/element.d.ts

@@ -0,0 +1 @@
+export { e as element, a as escapeValue } from './element-CEdJaM42.js';