@teleporthq/teleport-uidl-resolver 0.43.22 → 0.43.29

package/__tests__/style-set-definitions/index.ts

@@ -75,6 +75,87 @@ describe('Resolves style-sheet', () => {
     )
   })
 
+  it('Keeps valid CSS selector keys (incl. attribute selectors) and drops JS-fragment keys', () => {
+    const styleSet: Record<string, UIDLStyleSetDefinition> = {
+      'input-group': {
+        type: 'reusable-project-style-map' as const,
+        content: { display: staticNode('block') },
+        className: 'input-group',
+      },
+      'input-group label': {
+        type: 'reusable-project-style-map' as const,
+        content: { display: staticNode('block') },
+        className: 'input-group',
+        subselectors: ' label',
+      },
+      'input-group input[type="number"]': {
+        type: 'reusable-project-style-map' as const,
+        content: { width: staticNode('100%') },
+        className: 'input-group',
+        subselectors: ' input[type="number"]',
+      },
+      'input-group input[type="range"]': {
+        type: 'reusable-project-style-map' as const,
+        content: { width: staticNode('100%') },
+        className: 'input-group',
+        subselectors: ' input[type="range"]',
+      },
+      // Combinators, pseudo-functions, universal and id selectors are valid CSS
+      'card > span': {
+        type: 'reusable-project-style-map' as const,
+        content: { display: staticNode('block') },
+        className: 'card',
+        subselectors: ' > span',
+      },
+      'card + .card': {
+        type: 'reusable-project-style-map' as const,
+        content: { display: staticNode('block') },
+        className: 'card',
+        subselectors: ' + .card',
+      },
+      'list li:nth-child(2n+1)': {
+        type: 'reusable-project-style-map' as const,
+        content: { display: staticNode('block') },
+        className: 'list',
+        subselectors: ' li:nth-child(2n+1)',
+      },
+      'card:not(.active)': {
+        type: 'reusable-project-style-map' as const,
+        content: { display: staticNode('block') },
+        className: 'card',
+        subselectors: ':not(.active)',
+      },
+      '#main .card': {
+        type: 'reusable-project-style-map' as const,
+        content: { display: staticNode('block') },
+        className: 'main',
+        subselectors: ' .card',
+      },
+      // JS-fragment / invalid keys that must be dropped
+      "'coin'": { type: 'reusable-project-style-map' as const, content: {} },
+      '{{': { type: 'reusable-project-style-map' as const, content: {} },
+      '||': { type: 'reusable-project-style-map' as const, content: {} },
+      "t('coin')": { type: 'reusable-project-style-map' as const, content: {} },
+      ['$' + '{expr}']: { type: 'reusable-project-style-map' as const, content: {} },
+      'a && b': { type: 'reusable-project-style-map' as const, content: {} },
+      '<div>': { type: 'reusable-project-style-map' as const, content: {} },
+    }
+
+    const result = resolveStyleSetDefinitions(styleSet, {})
+
+    expect(Object.keys(result)).toEqual([
+      'input-group',
+      'input-group label',
+      'input-group input[type="number"]',
+      'input-group input[type="range"]',
+      'card > span',
+      'card + .card',
+      'list li:nth-child(2n+1)',
+      'card:not(.active)',
+      '#main .card',
+    ])
+  })
+
   it(`Resolver doesn't throw any error even if conditions are not passed`, () => {
     const styleSet: Record<string, UIDLStyleSetDefinition> = {
       primaryButton: {

package/__tests__/unbound-expressions/expression-identifiers.ts

@@ -0,0 +1,61 @@
+import { extractRootIdentifiers } from '../../src/resolvers/unbound-expressions/expression-identifiers'
+
+const roots = (expression: string): string[] =>
+  Array.from(extractRootIdentifiers(expression)).sort()
+
+describe('extractRootIdentifiers', () => {
+  it('returns the leading identifier of a member expression', () => {
+    expect(roots('cat.name')).toEqual(['cat'])
+    expect(roots('loc.location_id')).toEqual(['loc'])
+  })
+
+  it('ignores property names accessed via dot and optional chaining', () => {
+    expect(roots('item?.id')).toEqual(['item'])
+    expect(roots('props.inventoryItem?.name')).toEqual(['props'])
+    expect(roots('event.target.value')).toEqual(['event'])
+  })
+
+  it('does not treat words inside string literals as identifiers', () => {
+    expect(roots('item?.name || "Item"')).toEqual(['item'])
+    expect(roots("tx?.transaction_type || 'Adjustment'")).toEqual(['tx'])
+  })
+
+  it('handles quoted JSON blobs without leaking string keys/values', () => {
+    const expression =
+      'JSON.stringify([{"type":"condition","source":"id","destination":params[\'id\'],"operand":"="}])'
+    expect(roots(expression)).toEqual(['JSON', 'params'])
+  })
+
+  it('extracts identifiers from template-literal interpolations only', () => {
+    // tslint:disable no-invalid-template-strings
+    expect(roots('`/edit-inventory-item/${item?.id}`')).toEqual(['item'])
+    expect(roots('`/edit-inventory-item/[id]`')).toEqual([])
+    expect(roots('`${cat.name} - ${loc.city}`').sort()).toEqual(['cat', 'loc'])
+    // tslint:enable no-invalid-template-strings
+  })
+
+  it('collects call-argument references but not property method names', () => {
+    expect(roots('Math.max(a, b)').sort()).toEqual(['Math', 'a', 'b'])
+  })
+
+  it('does not treat unquoted object-literal keys as references', () => {
+    expect(roots('{ active: item.active }')).toEqual(['item'])
+    expect(roots('{ a: cat.name, b: loc.id }').sort()).toEqual(['cat', 'loc'])
+  })
+
+  it('keeps ternary branches and object shorthand values as references', () => {
+    expect(roots('flag ? yes : no').sort()).toEqual(['flag', 'no', 'yes'])
+    expect(roots('{ item, index }').sort()).toEqual(['index', 'item'])
+  })
+
+  it('ignores keywords and literals', () => {
+    expect(roots('typeof cat === "object"')).toEqual(['cat'])
+    expect(roots('true')).toEqual([])
+    expect(roots('null')).toEqual([])
+  })
+
+  it('returns an empty set for empty or non-string input', () => {
+    expect(roots('')).toEqual([])
+    expect(Array.from(extractRootIdentifiers(undefined as unknown as string))).toEqual([])
+  })
+})

package/__tests__/unbound-expressions/index.ts

@@ -0,0 +1,149 @@
+import { ComponentUIDL, UIDLElementNode, UIDLNode } from '@teleporthq/teleport-types'
+import { resolveUnboundExpressions } from '../../src/resolvers/unbound-expressions'
+
+const expr = (content: string): UIDLNode => ({ type: 'expr', content } as UIDLNode)
+
+const optionWith = (child: UIDLNode): UIDLElementNode => ({
+  type: 'element',
+  content: {
+    elementType: 'option',
+    attrs: { value: { type: 'static', content: '' } },
+    children: [child],
+  },
+})
+
+const buildComponent = (node: UIDLElementNode): ComponentUIDL =>
+  ({
+    name: 'AddInventoryItem',
+    node,
+    propDefinitions: {
+      inventoryItem: { type: 'object', defaultValue: {} },
+    },
+    stateDefinitions: {
+      categoryOptions: { type: 'array', defaultValue: [] },
+    },
+  } as unknown as ComponentUIDL)
+
+describe('resolveUnboundExpressions', () => {
+  it('neutralises an orphaned option expression that references an unbound iterator', () => {
+    const option = optionWith(expr('cat.name'))
+    const uidl = buildComponent({
+      type: 'element',
+      content: { elementType: 'select', children: [option] },
+    })
+
+    resolveUnboundExpressions(uidl)
+
+    expect(option.content.children[0]).toEqual({ type: 'static', content: '' })
+  })
+
+  it('keeps expressions that reference an in-scope repeater iterator', () => {
+    const boundExpr = expr('item?.id')
+    const repeater: UIDLNode = {
+      type: 'cms-list-repeater',
+      content: {
+        elementType: 'fragment',
+        name: 'list',
+        key: 'list',
+        renderPropIdentifier: 'item',
+        nodes: {
+          list: {
+            type: 'element',
+            content: { elementType: 'div', children: [boundExpr] },
+          },
+        },
+      },
+    } as UIDLNode
+    const uidl = buildComponent({
+      type: 'element',
+      content: { elementType: 'container', children: [repeater] },
+    })
+
+    resolveUnboundExpressions(uidl)
+
+    expect(boundExpr).toEqual({ type: 'expr', content: 'item?.id' })
+  })
+
+  it('flags a repeater iterator referenced outside of its subtree', () => {
+    const escaped = optionWith(expr('item?.id'))
+    const repeater: UIDLNode = {
+      type: 'cms-list-repeater',
+      content: {
+        elementType: 'fragment',
+        name: 'list',
+        key: 'list',
+        renderPropIdentifier: 'item',
+        nodes: {
+          list: { type: 'element', content: { elementType: 'div', children: [] } },
+        },
+      },
+    } as UIDLNode
+    const uidl = buildComponent({
+      type: 'element',
+      content: { elementType: 'container', children: [repeater, escaped] },
+    })
+
+    resolveUnboundExpressions(uidl)
+
+    expect(escaped.content.children[0]).toEqual({ type: 'static', content: '' })
+  })
+
+  it('keeps expressions that reference props, state, globals and event', () => {
+    const propsExpr = expr('props.inventoryItem?.name')
+    const stateExpr = expr('categoryOptions')
+    const globalExpr = expr('JSON.stringify(params)')
+    const eventExpr = expr('event.target.value')
+    const uidl = buildComponent({
+      type: 'element',
+      content: {
+        elementType: 'container',
+        children: [propsExpr, stateExpr, globalExpr, eventExpr],
+      },
+    })
+
+    resolveUnboundExpressions(uidl)
+
+    expect(propsExpr).toEqual({ type: 'expr', content: 'props.inventoryItem?.name' })
+    expect(stateExpr).toEqual({ type: 'expr', content: 'categoryOptions' })
+    expect(globalExpr).toEqual({ type: 'expr', content: 'JSON.stringify(params)' })
+    expect(eventExpr).toEqual({ type: 'expr', content: 'event.target.value' })
+  })
+
+  it('neutralises an unbound expression used as an attribute value', () => {
+    const element: UIDLElementNode = {
+      type: 'element',
+      content: {
+        elementType: 'div',
+        attrs: {
+          'data-item-id': { type: 'expr', content: 'cat.id' },
+          title: { type: 'static', content: 'ok' },
+        },
+        children: [],
+      },
+    }
+    const uidl = buildComponent(element)
+
+    resolveUnboundExpressions(uidl)
+
+    expect(element.content.attrs!['data-item-id']).toEqual({ type: 'static', content: '' })
+    expect(element.content.attrs!.title).toEqual({ type: 'static', content: 'ok' })
+  })
+
+  it('preserves surrounding static text when neutralising mixed content', () => {
+    const span: UIDLElementNode = {
+      type: 'element',
+      content: {
+        elementType: 'span',
+        children: [{ type: 'static', content: 'Hello ' }, expr('cat.name')],
+      },
+    }
+    const uidl = buildComponent(span)
+
+    resolveUnboundExpressions(uidl)
+
+    expect(span.content.children).toEqual([
+      { type: 'static', content: 'Hello ' },
+      { type: 'static', content: '' },
+    ])
+  })
+})

package/dist/cjs/resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../src/resolver.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,aAAa,EACb,WAAW,EACX,OAAO,EACP,gBAAgB,EAEjB,MAAM,4BAA4B,CAAA;AAMnC;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,QAAQ;IAC3B,OAAO,CAAC,OAAO,CAMd;gBAEW,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,EAAE;IAQlC,UAAU,CAAC,OAAO,EAAE,OAAO;IAI3B,WAAW,CAAC,KAAK,EAAE,aAAa,EAAE,OAAO,GAAE,gBAA6C;IAmCxF,cAAc,CACnB,OAAO,EAAE,WAAW,EACpB,OAAO,GAAE,gBAA6C;CAYzD"}
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../src/resolver.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,aAAa,EACb,WAAW,EACX,OAAO,EACP,gBAAgB,EAEjB,MAAM,4BAA4B,CAAA;AAOnC;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,QAAQ;IAC3B,OAAO,CAAC,OAAO,CAMd;gBAEW,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,EAAE;IAQlC,UAAU,CAAC,OAAO,EAAE,OAAO;IAI3B,WAAW,CAAC,KAAK,EAAE,aAAa,EAAE,OAAO,GAAE,gBAA6C;IAyCxF,cAAc,CACnB,OAAO,EAAE,WAAW,EACpB,OAAO,GAAE,gBAA6C;CAYzD"}

package/dist/cjs/resolver.js

@@ -40,6 +40,7 @@ var abilities_1 = require("./resolvers/abilities");
 var style_set_definitions_1 = require("./resolvers/style-set-definitions");
 var referenced_styles_1 = require("./resolvers/referenced-styles");
 var embed_node_1 = require("./resolvers/embed-node");
+var unbound_expressions_1 = require("./resolvers/unbound-expressions");
 /**
  * The resolver takes the input UIDL and converts all the abstract node types into
  * concrete node types, based on the mappings you provide
@@ -80,6 +81,11 @@ var Resolver = /** @class */ (function () {
         (0, embed_node_1.resolveHtmlNode)(uidl, newOptions);
         utils.resolveNode(uidl.node, newOptions);
         utils.resolveNodeInPropDefinitions(uidl, newOptions);
+        // Guard against `expr` nodes that reference an out-of-scope identifier
+        // (e.g. an orphaned `<option>{{ cat.name }}</option>` whose repeater was
+        // never generated). Left untouched they compile to `ReferenceError`s that
+        // fail the static export / `next build`.
+        (0, unbound_expressions_1.resolveUnboundExpressions)(uidl);
         utils.createNodesLookup(uidl, lookup);
         utils.generateUniqueKeys(uidl, lookup);
         utils.ensureDataSourceUniqueness(uidl.node);

package/dist/cjs/resolver.js.map

@@ -1 +1 @@
-{"version":3,"file":"resolver.js","sourceRoot":"","sources":["../../src/resolver.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"resolver.js","sourceRoot":"","sources":["../../src/resolver.ts"],"names":[],"mappings":"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"}

package/dist/cjs/resolvers/style-set-definitions/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/resolvers/style-set-definitions/index.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EAGvB,MAAM,4BAA4B,CAAA;AAsBnC,eAAO,MAAM,0BAA0B,cAC1B,OAAO,MAAM,EAAE,sBAAsB,CAAC,WACxC,gBAAgB,KACxB,OAAO,MAAM,EAAE,sBAAsB,CA8CvC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/resolvers/style-set-definitions/index.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EAGvB,MAAM,4BAA4B,CAAA;AA+BnC,eAAO,MAAM,0BAA0B,cAC1B,OAAO,MAAM,EAAE,sBAAsB,CAAC,WACxC,gBAAgB,KACxB,OAAO,MAAM,EAAE,sBAAsB,CA8CvC,CAAA"}

package/dist/cjs/resolvers/style-set-definitions/index.js

@@ -32,11 +32,20 @@ var isValidStyleSetKey = function (key) {
     if (sanitized === null || sanitized.length === 0) {
         return false;
     }
-    // Allow compound CSS selectors like "base-class.modifier" or "base-class.modifier .child-class"
-    // These are valid CSS and used for state-dependent styling (e.g., dashboard-sidebar.collapsed)
-    // Also allow pseudo-selectors like "class:hover" and "class:focus-within"
-    // Reject characters that indicate JS expression fragments or are truly invalid
-    if (/['"{}|()!@#$%^&*+=<>?/\\]/.test(key)) {
+    // Allow real CSS selector syntax used in style-set keys:
+    //  - compound selectors: "base-class.modifier", "base-class.modifier .child-class"
+    //  - combinators: "card > span", "card + span", "card ~ span", "list *"
+    //  - pseudo-selectors / functions: "class:hover", "row:nth-child(2n+1)", "card:not(.active)"
+    //  - id selectors: "#main .card"
+    //  - attribute selectors: 'input-group input[type="number"]'
+    // Attribute-selector brackets can legitimately contain quotes and "=", so they are stripped
+    // before the JS-fragment check below. The remaining blacklist still rejects expression/template
+    // fragments such as "'coin'", "{{", "||", "${x}" or "a && b".
+    var keyWithoutAttributeSelectors = key.replace(/\[[^\]]*\]/g, '');
+    // Reject characters that indicate JS expression fragments or are truly invalid CSS selectors.
+    // Note: ( ) * + > # are intentionally NOT rejected so pseudo-functions, combinators, the
+    // universal selector and id selectors keep working.
+    if (/['"{}|!@$%^&=<?/\\]/.test(keyWithoutAttributeSelectors)) {
         return false;
     }
     // Reject keys that start with a digit

package/dist/cjs/resolvers/style-set-definitions/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/resolvers/style-set-definitions/index.ts"],"names":[],"mappings":";AAAA;;;EAGE;;;;;;;;;;;;;;;;;;;;;;;AAEF,+DAAyD;AAOzD,qCAA6C;AAE7C,IAAM,kBAAkB,GAAG,UAAC,GAAW;IACrC,IAAM,SAAS,GAAG,6BAAW,CAAC,uBAAuB,CAAC,GAAG,CAAC,CAAA;IAC1D,IAAI,SAAS,KAAK,IAAI,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE;QAChD,OAAO,KAAK,CAAA;KACb;IACD,gGAAgG;IAChG,+FAA+F;IAC/F,0EAA0E;IAC1E,+EAA+E;IAC/E,IAAI,2BAA2B,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;QACzC,OAAO,KAAK,CAAA;KACb;IACD,sCAAsC;IACtC,IAAI,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;QACnB,OAAO,KAAK,CAAA;KACb;IACD,OAAO,IAAI,CAAA;AACb,CAAC,CAAA;AAEM,IAAM,0BAA0B,GAAG,UACxC,SAAsD,EACtD,OAAyB;IADzB,0BAAA,EAAA,cAAsD;IAGtD,OAAO,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,UAAC,GAA2C,EAAE,OAAO;QACxF,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,EAAE;YAChC,OAAO,GAAG,CAAA;SACX;QACD,IAAM,QAAQ,GAAG,SAAS,CAAC,OAAO,CAAC,CAAA;QAC3B,IAAA,KAAkC,QAAQ,WAA3B,EAAf,UAAU,mBAAG,EAAE,KAAA,EAAE,KAAiB,QAAQ,QAAb,EAAZ,OAAO,mBAAG,EAAE,KAAA,CAAa;QAElD,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE;YAC3B,GAAG,CAAC,OAAO,CAAC,yBACP,QAAQ,KACX,OAAO,EAAE,IAAA,uBAAe,EAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,MAAM,CAAC,GAC5D,CAAA;YACD,OAAO,GAAG,CAAA;SACX;QAEK,IAAA,KAA+B,UAAU,CAAC,MAAM,CACpD,UAAC,EAA4E,EAAE,IAAI;gBAAjF,KAAK,QAAA,EAAE,KAAK,QAAA;YACZ,IAAI,IAAI,CAAC,IAAI,KAAK,aAAa,EAAE;gBAC/B,KAAK,CAAC,IAAI,uBACL,IAAI,KACP,OAAO,EAAE,IAAA,uBAAe,EAAC,IAAI,CAAC,OAAO,EAAE,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,MAAM,CAAC,IACvD,CAAA;aACH;YACD,IAAI,IAAI,CAAC,IAAI,KAAK,eAAe,EAAE;gBACjC,KAAK,CAAC,IAAI,uBACL,IAAI,KACP,OAAO,EAAE,IAAA,uBAAe,EAAC,IAAI,CAAC,OAAO,EAAE,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,MAAM,CAAC,IACvD,CAAA;aACH;YACD,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;QACvB,CAAC,EACD,CAAC,EAAE,EAAE,EAAE,CAAC,CACT,EAjBM,WAAW,QAAA,EAAE,aAAa,QAiBhC,CAAA;QAED,GAAG,CAAC,OAAO,CAAC,yBACP,QAAQ,KACX,OAAO,EAAE,IAAA,uBAAe,EAAC,OAAO,EAAE,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,MAAM,CAAC,EAClD,UAAU,kCACL,aAAa,SACb,WAAW,CAAC,IAAI,CAAC,UAAC,CAAC,EAAE,CAAC,IAAK,OAAA,CAAC,CAAC,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAjC,CAAiC,CAAC,UAEnE,CAAA;QAED,OAAO,GAAG,CAAA;IACZ,CAAC,EAAE,EAAE,CAAC,CAAA;AACR,CAAC,CAAA;AAjDY,QAAA,0BAA0B,8BAiDtC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/resolvers/style-set-definitions/index.ts"],"names":[],"mappings":"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"}

package/dist/cjs/resolvers/unbound-expressions/ambient-identifiers.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Root identifiers that are always in scope inside a generated component and
+ * therefore can never be an "unbound" reference:
+ *
+ *  - values the code generator injects into the render scope (`props`, `state`,
+ *    `event`, `params`, `context`, `metadata`, and common map callback vars),
+ *  - standard JavaScript globals / built-ins.
+ *
+ * Iterator variables introduced by repeaters (`item`, `kpi`, ...) are NOT
+ * listed here — they are tracked positionally as the walker descends into a
+ * repeater's subtree, so an iterator reference that escapes its repeater is
+ * still correctly flagged as unbound.
+ */
+export declare const AMBIENT_IDENTIFIERS: Set<string>;
+/**
+ * Identifiers emitted by the code generator itself (hoisted constants, internal
+ * helpers) are prefixed with `_` or `$`. Treat them as bound so we never touch
+ * generator-authored expressions.
+ */
+export declare const isGeneratorInternalIdentifier: (identifier: string) => boolean;
+//# sourceMappingURL=ambient-identifiers.d.ts.map

package/dist/cjs/resolvers/unbound-expressions/ambient-identifiers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ambient-identifiers.d.ts","sourceRoot":"","sources":["../../../../src/resolvers/unbound-expressions/ambient-identifiers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,mBAAmB,aAiE9B,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,eAAgB,MAAM,KAAG,OACT,CAAA"}

package/dist/cjs/resolvers/unbound-expressions/ambient-identifiers.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGeneratorInternalIdentifier = exports.AMBIENT_IDENTIFIERS = void 0;
+/**
+ * Root identifiers that are always in scope inside a generated component and
+ * therefore can never be an "unbound" reference:
+ *
+ *  - values the code generator injects into the render scope (`props`, `state`,
+ *    `event`, `params`, `context`, `metadata`, and common map callback vars),
+ *  - standard JavaScript globals / built-ins.
+ *
+ * Iterator variables introduced by repeaters (`item`, `kpi`, ...) are NOT
+ * listed here — they are tracked positionally as the walker descends into a
+ * repeater's subtree, so an iterator reference that escapes its repeater is
+ * still correctly flagged as unbound.
+ */
+exports.AMBIENT_IDENTIFIERS = new Set([
+    // Code-generator provided render-scope values
+    'props',
+    'state',
+    'context',
+    'ctx',
+    'metadata',
+    'record',
+    // Event handler / map callback parameters
+    'event',
+    'evt',
+    'e',
+    'params',
+    'index',
+    'idx',
+    'key',
+    'i',
+    // Browser globals
+    'window',
+    'document',
+    'navigator',
+    'location',
+    'history',
+    'screen',
+    'localStorage',
+    'sessionStorage',
+    'console',
+    'fetch',
+    'URL',
+    'URLSearchParams',
+    // Language built-ins
+    'globalThis',
+    'undefined',
+    'NaN',
+    'Infinity',
+    'JSON',
+    'Math',
+    'Object',
+    'Array',
+    'String',
+    'Number',
+    'Boolean',
+    'Date',
+    'RegExp',
+    'Map',
+    'Set',
+    'WeakMap',
+    'WeakSet',
+    'Promise',
+    'Symbol',
+    'BigInt',
+    'Error',
+    'TypeError',
+    'Function',
+    'Proxy',
+    'Reflect',
+    'Intl',
+    'parseInt',
+    'parseFloat',
+    'isNaN',
+    'isFinite',
+    'encodeURIComponent',
+    'decodeURIComponent',
+    'encodeURI',
+    'decodeURI',
+]);
+/**
+ * Identifiers emitted by the code generator itself (hoisted constants, internal
+ * helpers) are prefixed with `_` or `$`. Treat them as bound so we never touch
+ * generator-authored expressions.
+ */
+var isGeneratorInternalIdentifier = function (identifier) {
+    return identifier.startsWith('_') || identifier.startsWith('$');
+};
+exports.isGeneratorInternalIdentifier = isGeneratorInternalIdentifier;
+//# sourceMappingURL=ambient-identifiers.js.map

package/dist/cjs/resolvers/unbound-expressions/ambient-identifiers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ambient-identifiers.js","sourceRoot":"","sources":["../../../../src/resolvers/unbound-expressions/ambient-identifiers.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;GAYG;AACU,QAAA,mBAAmB,GAAG,IAAI,GAAG,CAAS;IACjD,8CAA8C;IAC9C,OAAO;IACP,OAAO;IACP,SAAS;IACT,KAAK;IACL,UAAU;IACV,QAAQ;IACR,0CAA0C;IAC1C,OAAO;IACP,KAAK;IACL,GAAG;IACH,QAAQ;IACR,OAAO;IACP,KAAK;IACL,KAAK;IACL,GAAG;IACH,kBAAkB;IAClB,QAAQ;IACR,UAAU;IACV,WAAW;IACX,UAAU;IACV,SAAS;IACT,QAAQ;IACR,cAAc;IACd,gBAAgB;IAChB,SAAS;IACT,OAAO;IACP,KAAK;IACL,iBAAiB;IACjB,qBAAqB;IACrB,YAAY;IACZ,WAAW;IACX,KAAK;IACL,UAAU;IACV,MAAM;IACN,MAAM;IACN,QAAQ;IACR,OAAO;IACP,QAAQ;IACR,QAAQ;IACR,SAAS;IACT,MAAM;IACN,QAAQ;IACR,KAAK;IACL,KAAK;IACL,SAAS;IACT,SAAS;IACT,SAAS;IACT,QAAQ;IACR,QAAQ;IACR,OAAO;IACP,WAAW;IACX,UAAU;IACV,OAAO;IACP,SAAS;IACT,MAAM;IACN,UAAU;IACV,YAAY;IACZ,OAAO;IACP,UAAU;IACV,oBAAoB;IACpB,oBAAoB;IACpB,WAAW;IACX,WAAW;CACZ,CAAC,CAAA;AAEF;;;;GAIG;AACI,IAAM,6BAA6B,GAAG,UAAC,UAAkB;IAC9D,OAAA,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC;AAAxD,CAAwD,CAAA;AAD7C,QAAA,6BAA6B,iCACgB"}

package/dist/cjs/resolvers/unbound-expressions/expression-identifiers.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Extracts the "root" reference identifiers used by a UIDL `expr` node so the
+ * resolver can tell whether an expression references a variable that is not in
+ * scope (and would therefore throw a `ReferenceError` at render time).
+ *
+ * A root reference is an identifier that is READ as a variable — e.g. `cat` in
+ * `cat.name`, `item` in `` `/edit/${item?.id}` ``, or `params` in
+ * `params['id']`. Property names (the `name` in `cat.name`), string-literal
+ * contents, and language keywords are NOT roots.
+ *
+ * The extractor is a small hand-written lexer rather than a full parser so the
+ * resolver package stays dependency-free. It only needs to be correct enough to
+ * find the leading identifier of every member/call/index expression while
+ * ignoring string and template-literal text — which is exactly what
+ * distinguishes a genuine unbound reference from an incidental word inside a
+ * quoted JSON blob such as
+ * `JSON.stringify([{ "type": "condition", "source": "id" }])`.
+ */
+/**
+ * Returns the set of root reference identifiers read by an expression string.
+ */
+export declare const extractRootIdentifiers: (expression: string) => Set<string>;
+//# sourceMappingURL=expression-identifiers.d.ts.map

package/dist/cjs/resolvers/unbound-expressions/expression-identifiers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression-identifiers.d.ts","sourceRoot":"","sources":["../../../../src/resolvers/unbound-expressions/expression-identifiers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAwLH;;GAEG;AACH,eAAO,MAAM,sBAAsB,eAAgB,MAAM,KAAG,IAAI,MAAM,CAMrE,CAAA"}