@hyperfixi/core 3.1.1 → 3.2.0

package/dist/ast-utils/index.mjs

@@ -2252,6 +2252,14 @@ function convertNode(node, infer) {
                 ...pos(node),
             };
         case 'identifier':
+            if (node.scope === 'element' || node.scope === 'local' || node.scope === 'global') {
+                return {
+                    type: 'variable',
+                    name: (node.name ?? ''),
+                    scope: node.scope,
+                    ...pos(node),
+                };
+            }
             return {
                 type: 'identifier',
                 value: (node.name ?? node.value ?? ''),
@@ -2274,6 +2282,15 @@ function convertNode(node, infer) {
                 operand: convertNode(node.argument ?? node.operand, infer),
                 ...pos(node),
             };
+        case 'typeCheckExpression':
+            return {
+                type: 'typeCheck',
+                value: convertNode(node.value, infer),
+                typeName: String(node.typeName),
+                nullOk: node.nullOk !== false,
+                negated: node.negated === true,
+                ...pos(node),
+            };
         case 'timeExpression':
             return { type: 'literal', value: node.value, ...pos(node) };
         case 'templateLiteral':
@@ -2285,6 +2302,28 @@ function convertNode(node, infer) {
                 scope: (node.scope ?? 'local'),
                 ...pos(node),
             };
+        case 'arrayLiteral':
+            return {
+                type: 'array',
+                elements: (node.elements ?? []).map(element => convertNode(element, infer)),
+                ...pos(node),
+            };
+        case 'attributeAccess':
+            return {
+                type: 'possessive',
+                object: { type: 'identifier', value: 'me' },
+                property: `@${node.attributeName}`,
+                ...pos(node),
+            };
+        case 'propertyOfExpression': {
+            const property = node.property;
+            return {
+                type: 'possessive',
+                object: convertNode(node.target, infer),
+                property: (property?.name ?? property?.value ?? ''),
+                ...pos(node),
+            };
+        }
         case 'htmlSelector':
             return {
                 type: 'selector',
@@ -2336,6 +2375,21 @@ function convertCommand$1(node, infer) {
     if (name === 'repeat') {
         return convertRepeatCommand(node, infer);
     }
+    const original = node.originalCommand;
+    const sum = node.modifiers?.to;
+    const counted = node.args?.[0];
+    if (name === 'set' &&
+        (original === 'increment' || original === 'decrement') &&
+        sum?.type === 'binaryExpression' &&
+        counted) {
+        return convertCommand$1({
+            ...node,
+            name: original,
+            args: [counted],
+            modifiers: { by: sum.right },
+            originalCommand: undefined,
+        }, infer);
+    }
     const args = (node.args ?? []).map(arg => convertNode(arg, infer));
     const target = node.target ? convertNode(node.target, infer) : undefined;
     const modifiers = node.modifiers
@@ -2384,6 +2438,64 @@ function convertIfCommand(node, infer) {
     };
 }
 function convertRepeatCommand(node, infer) {
+    const slots = (node.modifiers ?? {});
+    const form = slotText(slots.loopType);
+    if (form === undefined)
+        return convertPositionalRepeat(node, infer);
+    const [bodyBlock, elseBlock] = (node.args ?? []);
+    const body = extractBlockCommands(bodyBlock, infer);
+    const indexName = slotText(slots.index);
+    const shared = {
+        ...(indexName ? { indexName } : {}),
+        ...(elseBlock ? { elseBody: extractBlockCommands(elseBlock, infer) } : {}),
+        ...pos(node),
+    };
+    const operand = (slot) => (slot ? convertNode(slot, infer) : undefined);
+    switch (form) {
+        case 'for':
+            return {
+                type: 'foreach',
+                itemName: slotText(slots.for) ?? 'it',
+                collection: operand(slots.in) ?? { type: 'literal', value: null },
+                body,
+                ...shared,
+            };
+        case 'times':
+            return { type: 'repeat', count: operand(slots.times), body, ...shared };
+        case 'while':
+        case 'until': {
+            const test = operand(slots[form]) ?? { type: 'literal', value: form === 'until' };
+            return {
+                type: 'while',
+                condition: form === 'until' ? { type: 'unary', operator: 'not', operand: test } : test,
+                ...(slots.bottomTested?.value === true ? { bottomTested: true } : {}),
+                body,
+                ...shared,
+            };
+        }
+        case 'until-event': {
+            const event = slotText(slots.event);
+            if (!event) {
+                return { type: 'error', message: "'repeat until event' has no event name", ...pos(node) };
+            }
+            const target = operand(slots.from);
+            return {
+                type: 'repeat',
+                untilEvent: event,
+                ...(target ? { untilEventTarget: target } : {}),
+                body,
+                ...shared,
+            };
+        }
+        default:
+            return { type: 'repeat', body, ...shared };
+    }
+}
+function slotText(slot) {
+    const text = slot?.value ?? slot?.name;
+    return typeof text === 'string' ? text : undefined;
+}
+function convertPositionalRepeat(node, infer) {
     const args = (node.args ?? []);
     if (args.length === 0) {
         return { type: 'repeat', body: [], ...pos(node) };
@@ -2700,6 +2812,15 @@ function toCoreAST(node) {
                 prefix: true,
                 ...nodePos(node),
             };
+        case 'typeCheck':
+            return {
+                type: 'typeCheckExpression',
+                value: toCoreAST(node.value),
+                typeName: node.typeName,
+                nullOk: node.nullOk,
+                negated: node.negated,
+                ...nodePos(node),
+            };
         case 'member':
             return {
                 type: 'memberExpression',
@@ -2710,6 +2831,12 @@ function toCoreAST(node) {
                 computed: node.computed ?? false,
                 ...nodePos(node),
             };
+        case 'array':
+            return {
+                type: 'arrayLiteral',
+                elements: node.elements.map(element => toCoreAST(element)),
+                ...nodePos(node),
+            };
         case 'possessive':
             return {
                 type: 'possessiveExpression',
@@ -2772,72 +2899,85 @@ function convertCommand(node) {
     }
     return result;
 }
+function block(nodes) {
+    return { type: 'block', commands: nodes.map(n => toCoreAST(n)), ...POS };
+}
 function convertIf(node) {
-    const result = {
+    const [elseIf, ...laterElseIfs] = node.elseIfBranches ?? [];
+    const elseBranch = elseIf
+        ? [
+            {
+                type: 'if',
+                condition: elseIf.condition,
+                thenBranch: elseIf.body,
+                elseIfBranches: laterElseIfs,
+                ...(node.elseBranch ? { elseBranch: node.elseBranch } : {}),
+            },
+        ]
+        : node.elseBranch;
+    return {
         type: 'command',
         name: 'if',
         isBlocking: true,
-        condition: toCoreAST(node.condition),
-        thenBranch: node.thenBranch.map(n => toCoreAST(n)),
-        args: [],
+        args: [
+            toCoreAST(node.condition),
+            block(node.thenBranch),
+            ...(elseBranch ? [block(elseBranch)] : []),
+        ],
         ...nodePos(node),
     };
-    if (node.elseBranch) {
-        result.elseBranch = node.elseBranch.map(n => toCoreAST(n));
-    }
-    return result;
 }
-function convertRepeat(node) {
-    const result = {
+function loopCommand(node, form, operands) {
+    const modifiers = { loopType: slotString(form) };
+    for (const [slot, value] of Object.entries(operands)) {
+        if (value)
+            modifiers[slot] = value;
+    }
+    if (node.indexName)
+        modifiers.index = slotString(node.indexName);
+    return {
         type: 'command',
         name: 'repeat',
         isBlocking: true,
-        body: node.body.map(n => toCoreAST(n)),
-        args: [],
+        args: [block(node.body), ...(node.elseBody ? [block(node.elseBody)] : [])],
+        modifiers,
         ...nodePos(node),
     };
+}
+function slotString(value) {
+    return { type: 'string', value, ...POS };
+}
+function convertRepeat(node) {
     if (node.count !== undefined) {
-        result.count =
-            typeof node.count === 'number'
-                ? { type: 'literal', value: node.count, raw: String(node.count), ...POS }
-                : toCoreAST(node.count);
-        result.loopVariant = 'times';
-    }
-    else if (node.whileCondition !== undefined) {
-        result.condition = toCoreAST(node.whileCondition);
-        result.loopVariant = 'while';
-    }
-    else if (node.untilEvent !== undefined) {
-        result.untilEvent = node.untilEvent;
-        result.loopVariant = 'until';
+        const times = typeof node.count === 'number'
+            ? { type: 'literal', value: node.count, raw: String(node.count), ...POS }
+            : toCoreAST(node.count);
+        return loopCommand(node, 'times', { times });
+    }
+    if (node.whileCondition !== undefined) {
+        return loopCommand(node, 'while', { while: toCoreAST(node.whileCondition) });
+    }
+    if (node.untilEvent !== undefined) {
+        return loopCommand(node, 'until-event', {
+            event: slotString(node.untilEvent),
+            from: node.untilEventTarget ? toCoreAST(node.untilEventTarget) : undefined,
+        });
     }
-    return result;
+    return loopCommand(node, 'forever', {});
 }
 function convertForEach(node) {
-    return {
-        type: 'command',
-        name: 'repeat',
-        isBlocking: true,
-        loopVariant: 'for',
-        itemName: node.itemName,
-        ...(node.indexName ? { indexName: node.indexName } : {}),
-        collection: toCoreAST(node.collection),
-        body: node.body.map(n => toCoreAST(n)),
-        args: [],
-        ...nodePos(node),
-    };
+    return loopCommand(node, 'for', {
+        for: slotString(node.itemName),
+        in: toCoreAST(node.collection),
+    });
 }
 function convertWhile(node) {
-    return {
-        type: 'command',
-        name: 'repeat',
-        isBlocking: true,
-        loopVariant: 'while',
-        condition: toCoreAST(node.condition),
-        body: node.body.map(n => toCoreAST(n)),
-        args: [],
-        ...nodePos(node),
-    };
+    return loopCommand(node, 'while', {
+        while: toCoreAST(node.condition),
+        bottomTested: node.bottomTested
+            ? { type: 'literal', value: true, raw: 'true', ...POS }
+            : undefined,
+    });
 }
 function flattenEventModifiers(modifiers) {
     if (!modifiers)
@@ -3241,6 +3381,9 @@ function getChildren(node) {
         case 'unary':
             children.push(node.operand);
             break;
+        case 'typeCheck':
+            children.push(node.value);
+            break;
         case 'member': {
             const m = node;
             children.push(m.object);
@@ -3378,6 +3521,8 @@ function friendlyTypeName(node) {
             return `Binary Expression (${node.operator})`;
         case 'unary':
             return `Unary Expression (${node.operator})`;
+        case 'typeCheck':
+            return `Type Check (${node.typeName})`;
         case 'literal':
             return 'Literal';
         case 'identifier':

package/dist/ast-utils/interchange/types.d.ts

@@ -1,4 +1,4 @@
-export type InterchangeNode = EventNode | CommandNode | LiteralNode | IdentifierNode | SelectorNode | VariableNode | BinaryNode | UnaryNode | MemberNode | PossessiveNode | CallNode | IfNode | RepeatNode | ForEachNode | WhileNode | PositionalNode | ErrorNode;
+export type InterchangeNode = EventNode | CommandNode | LiteralNode | IdentifierNode | SelectorNode | VariableNode | BinaryNode | UnaryNode | TypeCheckNode | MemberNode | PossessiveNode | ArrayNode | CallNode | IfNode | RepeatNode | ForEachNode | WhileNode | PositionalNode | ErrorNode;
 export interface BaseNode {
     readonly type: string;
     readonly start?: number;
@@ -35,6 +35,13 @@ export interface UnaryNode extends BaseNode {
     readonly operator: string;
     readonly operand: InterchangeNode;
 }
+export interface TypeCheckNode extends BaseNode {
+    readonly type: 'typeCheck';
+    readonly value: InterchangeNode;
+    readonly typeName: string;
+    readonly nullOk: boolean;
+    readonly negated: boolean;
+}
 export interface MemberNode extends BaseNode {
     readonly type: 'member';
     readonly object: InterchangeNode;
@@ -46,6 +53,10 @@ export interface PossessiveNode extends BaseNode {
     readonly object: InterchangeNode;
     readonly property: string;
 }
+export interface ArrayNode extends BaseNode {
+    readonly type: 'array';
+    readonly elements: readonly InterchangeNode[];
+}
 export interface CallNode extends BaseNode {
     readonly type: 'call';
     readonly callee: InterchangeNode;
@@ -92,7 +103,10 @@ export interface RepeatNode extends BaseNode {
     readonly count?: number | InterchangeNode;
     readonly whileCondition?: InterchangeNode;
     readonly untilEvent?: string;
+    readonly untilEventTarget?: InterchangeNode;
+    readonly indexName?: string;
     readonly body: InterchangeNode[];
+    readonly elseBody?: InterchangeNode[];
 }
 export interface ForEachNode extends BaseNode {
     readonly type: 'foreach';
@@ -100,11 +114,15 @@ export interface ForEachNode extends BaseNode {
     readonly indexName?: string;
     readonly collection: InterchangeNode;
     readonly body: InterchangeNode[];
+    readonly elseBody?: InterchangeNode[];
 }
 export interface WhileNode extends BaseNode {
     readonly type: 'while';
     readonly condition: InterchangeNode;
+    readonly bottomTested?: boolean;
+    readonly indexName?: string;
     readonly body: InterchangeNode[];
+    readonly elseBody?: InterchangeNode[];
 }
 export interface EventModifiers {
     readonly prevent?: boolean;

package/dist/behaviors/index.cjs

@@ -655,10 +655,29 @@ function isHTMLElement(value) {
         'classList' in value);
 }
 
+function loneRootWithTag(content, tagName) {
+    let root;
+    if (typeof content === 'string') {
+        const template = document.createElement('template');
+        template.innerHTML = content;
+        root = template.content.firstElementChild;
+        if (!root || root.nextElementSibling)
+            return null;
+    }
+    else {
+        root = content.cloneNode(true);
+    }
+    return root.tagName === tagName && isHTMLElement(root) ? root : null;
+}
 function executeSwap(target, content, strategy, morphOptions) {
     const contentStr = content !== null && !isHTMLElement(content) ? content : '';
     const contentEl = isHTMLElement(content) ? content : null;
     switch (strategy) {
+        case 'morphMerge': {
+            const root = content !== null ? loneRootWithTag(content, target.tagName) : null;
+            executeSwap(target, root ?? content, root ? 'morphOuter' : 'morph', morphOptions);
+            break;
+        }
         case 'morph':
             if (content !== null) {
                 try {

package/dist/behaviors/index.mjs

@@ -653,10 +653,29 @@ function isHTMLElement(value) {
         'classList' in value);
 }
 
+function loneRootWithTag(content, tagName) {
+    let root;
+    if (typeof content === 'string') {
+        const template = document.createElement('template');
+        template.innerHTML = content;
+        root = template.content.firstElementChild;
+        if (!root || root.nextElementSibling)
+            return null;
+    }
+    else {
+        root = content.cloneNode(true);
+    }
+    return root.tagName === tagName && isHTMLElement(root) ? root : null;
+}
 function executeSwap(target, content, strategy, morphOptions) {
     const contentStr = content !== null && !isHTMLElement(content) ? content : '';
     const contentEl = isHTMLElement(content) ? content : null;
     switch (strategy) {
+        case 'morphMerge': {
+            const root = content !== null ? loneRootWithTag(content, target.tagName) : null;
+            executeSwap(target, root ?? content, root ? 'morphOuter' : 'morph', morphOptions);
+            break;
+        }
         case 'morph':
             if (content !== null) {
                 try {

package/dist/bundle-generator/index.cjs

@@ -262,13 +262,23 @@ const COMMAND_IMPLEMENTATIONS_TS = {
           if (isOuter) {
             morphlexMorph(target, contentStr);
           } else {
-            // morphlex's morphInner takes an ELEMENT, not a string \u2014 the same
-            // wrapping src/lib/morph-adapter.ts does. Passing the string threw
-            // straight into the fallback below, so inner morph never actually
-            // morphed (it silently degraded to innerHTML on every call).
-            const wrapper = document.createElement(target.tagName);
-            wrapper.innerHTML = contentStr;
-            morphlexMorphInner(target, wrapper);
+            // Upstream's morph MERGES a lone root element that has the
+            // target's tag (attributes and children); anything else morphs the
+            // children \u2014 the full runtime's 'morphMerge' (lib/swap-executor.ts).
+            const template = document.createElement('template');
+            template.innerHTML = contentStr;
+            const root = template.content.firstElementChild;
+            if (root && !root.nextElementSibling && root.tagName === target.tagName) {
+              morphlexMorph(target, root);
+            } else {
+              // morphlex's morphInner takes an ELEMENT, not a string \u2014 the same
+              // wrapping src/lib/morph-adapter.ts does. Passing the string threw
+              // straight into the fallback below, so inner morph never actually
+              // morphed (it silently degraded to innerHTML on every call).
+              const wrapper = document.createElement(target.tagName);
+              wrapper.innerHTML = contentStr;
+              morphlexMorphInner(target, wrapper);
+            }
           }
         } catch (error) {
           // Fallback to innerHTML/outerHTML if morph fails
@@ -592,7 +602,9 @@ const BLOCK_IMPLEMENTATIONS_TS = {
     repeat: `
     case 'repeat': {
       const count = await evaluate(block.condition!, ctx);
-      const n = typeof count === 'number' ? count : parseInt(String(count));
+      // A count reads as upstream's \`index < times\` does, and core's loopCount:
+      // "6.5" loops 7 times, "6abc" none (parseInt read 6 for both), true once.
+      const n = Number(count) || 0;
       for (let i = 0; i < n && i < MAX_LOOP_ITERATIONS; i++) {
         ctx.locals.set('__loop_index__', i);
         ctx.locals.set('__loop_count__', i + 1);
@@ -2342,7 +2354,7 @@ class HybridParser {
     }
     return { type: "command", name, args: [url], modifiers };
   }
-  /** \`morph [over] <target> with|to|into <content>\` \u2014 all four connectives the full parser takes. */
+  /** \`morph [over] <target> to|with|into <content>\` \u2014 upstream spells it \`to\`; the full parser also takes \`with\`; \`into\` is this parser's own. */
   parseMorph() {
     this.expect("morph");
     let modifier;
@@ -2540,6 +2552,9 @@ class HybridParser {
     return left;
   }
   parseUnary() {
+    if (this.match("beep") && this.peek(1).value === "!") {
+      throw new Error(\`'beep!' needs the full parser (use hyperfixi.js)\`);
+    }
     if (this.match("not", "!")) {
       this.advance();
       return { type: "unary", operator: "not", operand: this.parseUnary() };

package/dist/bundle-generator/index.mjs

@@ -260,13 +260,23 @@ const COMMAND_IMPLEMENTATIONS_TS = {
           if (isOuter) {
             morphlexMorph(target, contentStr);
           } else {
-            // morphlex's morphInner takes an ELEMENT, not a string \u2014 the same
-            // wrapping src/lib/morph-adapter.ts does. Passing the string threw
-            // straight into the fallback below, so inner morph never actually
-            // morphed (it silently degraded to innerHTML on every call).
-            const wrapper = document.createElement(target.tagName);
-            wrapper.innerHTML = contentStr;
-            morphlexMorphInner(target, wrapper);
+            // Upstream's morph MERGES a lone root element that has the
+            // target's tag (attributes and children); anything else morphs the
+            // children \u2014 the full runtime's 'morphMerge' (lib/swap-executor.ts).
+            const template = document.createElement('template');
+            template.innerHTML = contentStr;
+            const root = template.content.firstElementChild;
+            if (root && !root.nextElementSibling && root.tagName === target.tagName) {
+              morphlexMorph(target, root);
+            } else {
+              // morphlex's morphInner takes an ELEMENT, not a string \u2014 the same
+              // wrapping src/lib/morph-adapter.ts does. Passing the string threw
+              // straight into the fallback below, so inner morph never actually
+              // morphed (it silently degraded to innerHTML on every call).
+              const wrapper = document.createElement(target.tagName);
+              wrapper.innerHTML = contentStr;
+              morphlexMorphInner(target, wrapper);
+            }
           }
         } catch (error) {
           // Fallback to innerHTML/outerHTML if morph fails
@@ -590,7 +600,9 @@ const BLOCK_IMPLEMENTATIONS_TS = {
     repeat: `
     case 'repeat': {
       const count = await evaluate(block.condition!, ctx);
-      const n = typeof count === 'number' ? count : parseInt(String(count));
+      // A count reads as upstream's \`index < times\` does, and core's loopCount:
+      // "6.5" loops 7 times, "6abc" none (parseInt read 6 for both), true once.
+      const n = Number(count) || 0;
       for (let i = 0; i < n && i < MAX_LOOP_ITERATIONS; i++) {
         ctx.locals.set('__loop_index__', i);
         ctx.locals.set('__loop_count__', i + 1);
@@ -2340,7 +2352,7 @@ class HybridParser {
     }
     return { type: "command", name, args: [url], modifiers };
   }
-  /** \`morph [over] <target> with|to|into <content>\` \u2014 all four connectives the full parser takes. */
+  /** \`morph [over] <target> to|with|into <content>\` \u2014 upstream spells it \`to\`; the full parser also takes \`with\`; \`into\` is this parser's own. */
   parseMorph() {
     this.expect("morph");
     let modifier;
@@ -2538,6 +2550,9 @@ class HybridParser {
     return left;
   }
   parseUnary() {
+    if (this.match("beep") && this.peek(1).value === "!") {
+      throw new Error(\`'beep!' needs the full parser (use hyperfixi.js)\`);
+    }
     if (this.match("not", "!")) {
       this.advance();
       return { type: "unary", operator: "not", operand: this.parseUnary() };