@pacem/pacem-core 1.0.6-ricci → 2.0.0-abel

package/dist/browser/pacem-core.js

@@ -1,5 +1,5 @@
 /*!
- * @pacem/pacem-core v1.0.6-ricci (https://js.pacem.it)
+ * @pacem/pacem-core v2.0.0-abel (https://js.pacem.it)
  * Pacem (https://pacem.it)
  * Licensed under Apache-2.0
  */
@@ -1463,45 +1463,264 @@
     const PCSS = root?.Configuration?.css ?? P;
     //}
 
+    //namespace Pacem {
+    /** Name of the argument object binding expressions are compiled against (see {@link Expression}). */
+    const BINDING_CONTEXT_PREFIX = '__context_pacem';
+    const HOST_REFERENCE = '__host_pacem';
+    /** The foundation vocabulary binding expressions are tokenized with. */
+    const BINDING_SYNTAX = 'pacem-binding';
+    /** Tokenizations are cached by expression text, up to this many entries. */
+    const MAX_CACHED_ANALYSES = 4096;
+    const INSIGNIFICANT = new Set(['space', 'newline', 'comment', 'doc-comment']);
+    const MEMBER_ACCESS = new Set(['.', '?.']);
+    /** Globals whose members are off limits. */
+    const UNSAFE_OWNERS = new Set(['window', 'document']);
+    function isReference(token) {
+        return token.type.startsWith('binding-');
+    }
+    function isMemberName(token) {
+        return token?.type === 'identifier' || token?.type === 'keyword';
+    }
+    /** Whether `raw` (and the significant token after it) call what precedes them: `(` or `?.(`. */
+    function isInvocation(raw, next) {
+        if (raw === '(') {
+            return true;
+        }
+        return raw === '?.' && next === '(';
+    }
+    /**
+     * Pure parser of Pacem binding expressions (the content of `{{ … }}` attributes and `on-*` handlers), built on the
+     * `pacem-binding` vocabulary of foundation's language-agnostic `Compile.Scanner`: Pacem references (`:host.`, `::name`,
+     * `^item`, `^index`, `#id`, `$this`) are recognized wherever the JavaScript grammar allows an expression, and never
+     * inside strings or template literal text.
+     */
+    class BindingParser {
+        static { this._scanner = new pacemFoundation.Compile.Scanner(); }
+        static { this._cache = new Map(); }
+        /** Tokenizes `expression` (cached) and detects its references and unsafe constructs. */
+        static analyze(expression) {
+            const text = expression ?? '';
+            const cache = BindingParser._cache;
+            const cached = cache.get(text);
+            if (cached != null) {
+                return cached;
+            }
+            if (cache.size >= MAX_CACHED_ANALYSES) {
+                cache.clear();
+            }
+            const tokens = BindingParser._scanner.tokenize(text, BINDING_SYNTAX);
+            const significant = [];
+            tokens.forEach((t, i) => {
+                if (!INSIGNIFICANT.has(t.type)) {
+                    significant.push(i);
+                }
+            });
+            const hasReferences = tokens.some(isReference);
+            const unsafe = BindingParser._findUnsafe(tokens, significant);
+            const analysis = { tokens, significant, hasReferences, unsafe };
+            cache.set(text, analysis);
+            return analysis;
+        }
+        /**
+         * Finds the first unsafe construct: `new`, members of `window`/`document`, `eval(…)`. Member names (`x.window`),
+         * object keys (`{ new: 1 }`) and string contents never count.
+         */
+        static _findUnsafe(tokens, significant) {
+            for (let k = 0; k < significant.length; k++) {
+                const token = tokens[significant[k]];
+                const previous = tokens[significant[k - 1]];
+                const next = tokens[significant[k + 1]];
+                if (MEMBER_ACCESS.has(previous?.raw)) {
+                    continue;
+                }
+                // (`{ new: … }` is an object key, not an instantiation)
+                const instantiation = token.type === 'keyword' && token.raw === 'new' && next?.raw !== ':';
+                if (instantiation) {
+                    return 'new';
+                }
+                if (token.type !== 'identifier') {
+                    continue;
+                }
+                const accessed = next?.raw === '[' || MEMBER_ACCESS.has(next?.raw);
+                if (UNSAFE_OWNERS.has(token.raw) && accessed) {
+                    return token.raw + next.raw;
+                }
+                if (token.raw === 'eval' && next?.raw === '(') {
+                    return 'eval(';
+                }
+            }
+            return null;
+        }
+        /**
+         * Parses a binding expression against a scope.
+         * @param expression The bare expression text (no `{{ }}` delimiters, no `, twoway`/`, once` modifier).
+         * @param scope What the references resolve to.
+         * @throws When the expression is unsafe (see {@link analyze}).
+         */
+        static parse(expression, scope) {
+            const analysis = BindingParser.analyze(expression);
+            if (analysis.unsafe != null) {
+                throw `Unsafe expression detected: "${analysis.unsafe}" in "${expression}".`;
+            }
+            if (!analysis.hasReferences) {
+                return { kind: 'constant', functionBody: `return ${expression};`, voidBody: expression, dependencies: [] };
+            }
+            if (!scope.ready) {
+                return { kind: 'pending', dependencies: [] };
+            }
+            const rewriter = new BindingRewriter(analysis, scope);
+            return rewriter.run();
+        }
+    }
+    /** One rewrite pass: replaces the Pacem references with `__context_pacem` lookups, collecting args and dependencies. */
+    class BindingRewriter {
+        constructor(_analysis, _scope) {
+            this._analysis = _analysis;
+            this._scope = _scope;
+            this._dependencies = [];
+            this._args = { '$this': _scope.self };
+        }
+        run() {
+            const tokens = this._analysis.tokens;
+            let expression = '';
+            for (let i = 0; i < tokens.length; i++) {
+                const token = tokens[i];
+                expression += isReference(token) ? this._rewrite(token, i) : token.raw;
+            }
+            // some referenced element/item/host isn't available (yet)
+            for (let key in this._args) {
+                if (this._args[key] == null) {
+                    return { kind: 'pending', dependencies: [] };
+                }
+            }
+            const dependencies = this._dependencies;
+            // a single dependency on a plain property path can be bound two-way
+            const trimmed = expression.trim();
+            if (dependencies.length === 1 && !/[^\w\.\$]+/.test(trimmed)) {
+                dependencies[0].twowayAllowed = true;
+            }
+            return {
+                kind: 'resolved',
+                functionBody: `try{ var ___$$$r = ${expression}; return ___$$$r; }catch(e){  }`,
+                voidBody: `try{ ${expression} }catch(e){  }`,
+                dependencies,
+                args: this._args
+            };
+        }
+        /**
+         * The member values read directly after the token at `index` (`.a.b`, `?.a`), e.g. `['a', 'b']`.
+         * As in javascript, `?.` is a member access like `.`; a member that gets invoked (`.map(`, `?.map(`, `.fn?.(`)
+         * is a method, not a value, so the chain stops before it. Spaces and comments in between are skipped, as in javascript.
+         */
+        _memberChain(index) {
+            const tokens = this._analysis.tokens;
+            const names = [];
+            let k = this._significantAfter(index);
+            while (MEMBER_ACCESS.has(this._significantRaw(k)) && isMemberName(tokens[this._significant(k + 1)])) {
+                const following = this._significantRaw(k + 2);
+                const afterFollowing = this._significantRaw(k + 3);
+                if (isInvocation(following, afterFollowing)) {
+                    return names;
+                }
+                const name = tokens[this._significant(k + 1)].raw;
+                names.push(name);
+                k += 2;
+            }
+            return names;
+        }
+        /** The position, in the significant tokens, of the first one after the token at `index`. */
+        _significantAfter(index) {
+            const significant = this._analysis.significant;
+            let k = 0;
+            while (k < significant.length && significant[k] <= index) {
+                k++;
+            }
+            return k;
+        }
+        /** The token index of the `k`-th significant token, if any. */
+        _significant(k) {
+            return this._analysis.significant[k] ?? -1;
+        }
+        _significantRaw(k) {
+            const index = this._significant(k);
+            return this._analysis.tokens[index]?.raw;
+        }
+        _ensureArg(key, factory) {
+            const args = this._args;
+            if (args[key] == null) {
+                args[key] = factory();
+            }
+            return args[key];
+        }
+        _host() {
+            return this._ensureArg(HOST_REFERENCE, () => this._scope.host());
+        }
+        _rewrite(token, index) {
+            const chain = this._memberChain(index);
+            switch (token.type) {
+                case 'binding-host': {
+                    const host = this._host();
+                    this._addDependency(host, chain);
+                    return `${BINDING_CONTEXT_PREFIX}.${HOST_REFERENCE}`;
+                }
+                case 'binding-host-property': {
+                    const name = token.raw.slice(2);
+                    const host = this._host();
+                    const element = host == null ? null : host[name];
+                    this._addDependency(element, chain);
+                    return `${BINDING_CONTEXT_PREFIX}.${HOST_REFERENCE}.${name}`;
+                }
+                case 'binding-item':
+                case 'binding-index': {
+                    // `^item` is 0 levels up, `^^item` 1, …
+                    const upLevels = token.raw.lastIndexOf('^');
+                    const member = token.type === 'binding-item' ? 'item' : 'index';
+                    const reference = `__item_${upLevels}_up_pacem`;
+                    const placeholder = this._ensureArg(reference, () => this._scope.item(upLevels));
+                    // the dependency is the `item`/`index` property itself, the path goes on with the item members
+                    const memberChain = member === 'item' ? [member].concat(chain) : [member];
+                    this._addDependency(placeholder, memberChain);
+                    return `${BINDING_CONTEXT_PREFIX}.${reference}.${member}`;
+                }
+                case 'binding-element': {
+                    const id = token.raw.slice(1);
+                    const element = this._ensureArg(id, () => this._scope.element(id));
+                    this._addDependency(element, chain);
+                    return `${BINDING_CONTEXT_PREFIX}.${id}`;
+                }
+                default: {
+                    // `$this`/`this`
+                    this._addDependency(this._scope.self, chain);
+                    return `${BINDING_CONTEXT_PREFIX}.$this`;
+                }
+            }
+        }
+        /**
+         * Registers a dependency on the first member of `chain` of `element`, unless it's a method, it doesn't exist,
+         * or it's already registered.
+         */
+        _addDependency(element, chain) {
+            const property = chain[0];
+            if (property == null || element == null || typeof element !== 'object' && typeof element !== 'function') {
+                return;
+            }
+            if (!(property in element) || typeof element[property] === 'function') {
+                return;
+            }
+            const dependencies = this._dependencies;
+            const duplicate = dependencies.some(d => d.element === element && d.property === property);
+            if (duplicate) {
+                return;
+            }
+            const path = chain.join('.');
+            dependencies.push({ element, property, path, twowayAllowed: false });
+        }
+    }
+
     /// <reference path="types.ts" />
     /// <reference path="utils.ts" />
     /// <reference path="utils-customelement.ts" />
-    const CONTEXT_PREFIX = '__context_pacem';
-    /** the following pattern matches:
-     * -------------------------------
-     * ciao "a tutti \"quanti\" voi"                                    -> "a tutti \"quanti\" voi"
-     * ciao 'a tutti "quanti" voi'+ mysel.value + 'e a nessun\' altra'  -> 'a tutti "quanti" voi'
-     *                                                                     'e a nessun\' altra'
-     */
-    const stringPattern = /'(\\'|[^'])*[^\\]?'|"(\\"|[^"])*[^\\]?"/g;
-    /** the following pattern matches:
-     * -------------------------------
-     * var l = new Date();  ->  new
-     * window.eval(         -> window.
-     * eval(                -> eval(
-     * eval  (              -> eval  (
-     */
-    const safetyPattern = /[^\w]new\s|[^\w]window\s*[\.\[]|[^\w]document\s*\.|[^\w]eval\s*\(/;
-    /** the following pattern matches:
-     * -------------------------------
-     * ^^^item.ciao           -> ^^^item
-     * !ciao.value            -> !ciao.
-     * :host.value            -> :host.
-     * ::child.prop           -> ::child.
-     * _connectTo(me.value)   -> (me.
-     * 009.ciao               ->
-     * this[that.value]       -> [that.
-     */
-    const variablePattern = /(^|[\s\(\[\+\-\*\/!])(:host\.|\^+item[\s\.,;\)\]]|\^+item$|\^+index[^\w\.]|\^+index$|\$?this[\.\s$]?|#[a-zA-Z_][\w]*|::[a-zA-Z_][\w]*)/g;
-    ///** the following pattern tests:
-    // * -------------------------------
-    // * __context.$this.myself.value -> true
-    // * !__context.myelem.value      -> false
-    // * fn(myelem.value)             -> false
-    // * $this == that                -> false
-    // * ...
-    // */
-    //const purePropertyPathPattern = /^[\w\.\$]+/; 
+    const CONTEXT_PREFIX = BINDING_CONTEXT_PREFIX;
     /**
      * A parsed, compiled binding expression (the content of a `{{ ... }}` attribute value). Parsing
      * (see {@link parse}) rewrites special tokens found in the source text - `:host.`, `^item`/`^^item`/...,
@@ -1591,136 +1810,45 @@
          * Parses a binding expression's source text (the bare content of a `{{ ... }}` attribute, without the
          * delimiters - see {@link CustomElementUtils.extractBindingAttributeExpression}) into an {@link Expression},
          * resolving its special tokens against `element`'s scope (see {@link CustomElementUtils.findScopeContext}).
-         * Throws if the expression matches the unsafe-code guard (`new`, `window.`, `document.`, `eval(`).
+         * Tokenization and rewriting are delegated to {@link BindingParser} (cached per expression text).
+         * Throws if the expression uses an unsafe construct (`new`, members of `window`/`document`, `eval(`).
          * @param expression Bare expression source text.
          * @param element Element the expression is bound to; provides the scope special tokens (`:host.`, `#id`, `^item`, ...) resolve against.
-         * @returns A constant expression if it has no dependencies; a shared pending placeholder if `element` isn't attached to a scope yet; otherwise a fully resolved expression.
+         * @returns A constant expression if it has no special tokens; a shared pending placeholder if `element` isn't attached to a scope yet; otherwise a fully resolved expression.
          */
         static parse(expression, element) {
-            var context = CustomElementUtils.findScopeContext(element);
-            var args = { '$this': element };
-            var dependencies = [];
-            var expr = '';
-            var independent = true;
-            //1. remove strings
-            var strings = [], stringMatches, index = 0, trunks = [];
-            while ((stringMatches = stringPattern.exec(expression)) != null) {
-                trunks.push(expression.substr(index, stringMatches.index - index));
-                let length = stringMatches[0].length;
-                strings.push({ start: stringMatches.index, length: length });
-                index = stringMatches.index + length;
-            }
-            if (index < expression.length)
-                trunks.push(expression.substr(index, expression.length - index));
-            //2. loop non string trunks
-            // trunks.length >= strings.length (more precisely, the following statemente is always `true`:
-            // trunks.length === strings.length || trunks.length === strings.length+1;
-            for (var j = 0; j < trunks.length; j++) {
-                let trunk = trunks[j];
-                if (safetyPattern.test(trunk))
-                    throw `Unsafe expression detected: "${trunk}".`;
-                if (context == null) {
-                    // context is null, means viewActivated event still to be fired.
-                    // check whether this is a constant expression (then no need to instantiate actual binding listeners)
-                    // or not.
-                    if (new RegExp(variablePattern).test(trunk) === true) {
-                        independent = false;
-                        break;
-                    }
-                }
-                else {
-                    let processedTrunk = trunk.replace(variablePattern, (mwhole, mstart, melem, index, input) => {
-                        independent = false;
-                        const cmpRef = `__host_pacem`;
-                        // default initialization := assumes `this`
-                        let retval = CONTEXT_PREFIX + '.$this' + (melem.endsWith('.') ? '.' : ''), el = element, dotIndex = input.indexOf('.', index), furtherParts = dotIndex > index ? input.substr(dotIndex + 1).trim() : '', pathRegexArray = /^[\w\.\$]+/.exec(furtherParts), path = pathRegexArray && pathRegexArray.length > 0 && pathRegexArray[0], propArray, prop = path && (propArray = path.split('.')).length > 0 && propArray[0];
-                        if (melem === ':host.') {
-                            el = args[cmpRef] = args[cmpRef] || CustomElementUtils.findHostContext(element);
-                            retval = `${CONTEXT_PREFIX}.${cmpRef}.`;
-                        }
-                        else if (melem.endsWith('^item') || melem.substr(0, melem.length - 1).endsWith('^item')) {
-                            let lastChar = melem.endsWith('^item') ? '' : melem.substr(melem.length - 1, 1);
-                            let upLevels = melem.length - (lastChar.length > 0 ? 6 : 5); // 5 = 'item'.length + 1 (zero-based)
-                            let itemRef = `__item_${upLevels}_up_pacem`;
-                            let item = Repeater.findItemContext(element, upLevels);
-                            el = args[itemRef] = args[itemRef] || (item && item.placeholder);
-                            path = 'item' + (path ? ('.' + path) : '');
-                            prop = 'item';
-                            retval = `${CONTEXT_PREFIX}.${itemRef}.item${lastChar}`;
-                        }
-                        else if (melem.endsWith('^index') || melem.substr(0, melem.length - 1).endsWith('^index')) {
-                            let lastChar = melem.endsWith('^index') ? '' : melem.substr(melem.length - 1, 1);
-                            let upLevels = melem.length - (lastChar.length > 0 ? 7 : 6); // 6 = 'index'.length + 1 (zero-based)
-                            let itemRef = `__item_${upLevels}_up_pacem`;
-                            let item = Repeater.findItemContext(element, upLevels);
-                            el = args[itemRef] = args[itemRef] || (item && item.placeholder);
-                            path = 'index';
-                            prop = 'index';
-                            retval = `${CONTEXT_PREFIX}.${itemRef}.index${lastChar}`;
-                        }
-                        else if (melem.startsWith('::')) {
-                            let melem0 = melem.substr(2, melem.length - 2);
-                            let host = args[cmpRef] = args[cmpRef] || CustomElementUtils.findHostContext(element);
-                            if (!Utils.isNull(host)) {
-                                el = host[melem0];
-                            }
-                            else {
-                                el = null;
-                            }
-                            retval = `${CONTEXT_PREFIX}.${cmpRef}.${melem0}`;
-                        }
-                        else if (melem.startsWith('#')) {
-                            let melem0 = melem.substr(1, melem.length - 1);
-                            el = args[melem0] = args[melem0] || context.querySelector('#' + melem0);
-                            retval = `${CONTEXT_PREFIX}.${melem0}`;
-                        }
-                        // merge dependencies
-                        if (prop && el && prop in el
-                            // && it is not a direct method call (which means that the 'prop' isn't in fact a 'func')
-                            && typeof el[prop] !== 'function' //!isMethodCall 
-                            // && does not already exist as a dependency
-                            && dependencies.find(d => d.element === el && d.property == prop) == null) {
-                            dependencies.push({ element: el, property: prop, path: path, twowayAllowed: false });
-                        }
-                        // return value
-                        return mstart + retval;
-                    });
-                    expr += processedTrunk;
-                    if (j < strings.length) {
-                        const s = strings[j];
-                        expr += expression.substr(s.start, s.length);
-                    }
-                }
-            }
-            if (independent) {
-                // constant expression
-                var constexpr = new Expression();
-                constexpr._independent = true;
-                constexpr._fnBody = `return ${expression};`;
-                constexpr._voidBody = expression;
-                constexpr._dependencies = [];
-                return constexpr;
-            }
-            if (context == null) {
-                return this._getPendingExpressionSingleton();
-            }
-            // if some dependency elements aren't available yet, then postpone...
-            for (var elem in args) {
-                if (args[elem] == null)
-                    return Expression._getPendingExpressionSingleton();
+            const scope = Expression._scopeOf(element);
+            const parsed = BindingParser.parse(expression, scope);
+            return Expression._fromParsed(parsed);
+        }
+        /** The DOM surroundings of `element` the special tokens resolve against (lazily, except for the scope context). */
+        static _scopeOf(element) {
+            const context = CustomElementUtils.findScopeContext(element);
+            return {
+                ready: context != null,
+                self: element,
+                host: () => CustomElementUtils.findHostContext(element),
+                item: (upLevels) => {
+                    const item = Repeater.findItemContext(element, upLevels);
+                    return item?.placeholder;
+                },
+                element: (id) => context.querySelector('#' + id)
+            };
+        }
+        static _fromParsed(parsed) {
+            if (parsed.kind === 'pending') {
+                return Expression._getPendingExpressionSingleton();
             }
-            if (dependencies.length == 1
-                // := && trimmed expression contains only letters, figures, underscores, dots, and '$'...
-                && /[^\w\.\$]+/.test(expr.trim()) !== true) {
-                // ...then 'twoway' binding might be applied/accepted
-                dependencies[0].twowayAllowed = true;
+            const retval = new Expression();
+            retval._fnBody = parsed.functionBody;
+            retval._voidBody = parsed.voidBody;
+            retval._dependencies = parsed.dependencies;
+            if (parsed.kind === 'constant') {
+                retval._independent = true;
+                return retval;
             }
-            var retexpr = new Expression();
-            retexpr._args = args;
-            retexpr._fnBody = `try{ var ___$$$r = ${expr}; return ___$$$r; }catch(e){  }`;
-            retexpr._voidBody = `try{ ${expr} }catch(e){  }`;
-            retexpr._dependencies = dependencies;
-            return retexpr;
+            retval._args = parsed.args;
+            return retval;
         }
     }
     // }