@teleporthq/teleport-uidl-resolver 0.43.23 → 0.43.34

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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,6CAAgC;AAChC,+DAAuD;AAQvD,mDAAwD;AACxD,2EAA8E;AAC9E,mEAAsE;AACtE,qDAAwD;AACxD,uEAA2E;AAE3E;;;GAGG;AACH;IASE,kBAAY,OAA6B;QAAzC,iBAMC;QAdO,YAAO,GAAY;YACzB,QAAQ,EAAE,EAAE;YACZ,MAAM,EAAE,EAAE;YACV,UAAU,EAAE,EAAE;YACd,iBAAiB,EAAE,EAAE;YACrB,gBAAgB,EAAE,EAAE;SACrB,CAAA;QAGC,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;YAC1B,OAAO,CAAC,OAAO,CAAC,UAAC,EAAE,IAAK,OAAA,KAAI,CAAC,UAAU,CAAC,EAAE,CAAC,EAAnB,CAAmB,CAAC,CAAA;SAC7C;aAAM,IAAI,OAAO,EAAE;YAClB,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAA;SACzB;IACH,CAAC;IAEM,6BAAU,GAAjB,UAAkB,OAAgB;QAChC,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;IAC3D,CAAC;IAEM,8BAAW,GAAlB,UAAmB,KAAoB,EAAE,OAAsD;QAAtD,wBAAA,EAAA,YAA8B,kBAAkB,EAAE,EAAE,EAAE;QAC7F,IAAM,OAAO,GAAG,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;QAClE,IAAM,UAAU,yBACX,OAAO,KACV,OAAO,SAAA,GACR,CAAA;QACD,IAAM,MAAM,GAAmB,EAAE,CAAA;QAEjC,IAAM,IAAI,GAAG,2BAAS,CAAC,WAAW,CAAC,KAAK,CAAC,CAAA;QACzC,IAAI,CAAC,mBAAmB,GAAG,IAAA,kDAA0B,EAAC,KAAK,CAAC,mBAAmB,EAAE,UAAU,CAAC,CAAA;QAE5F,2BAAS,CAAC,wBAAwB,CAAC,IAAI,CAAC,CAAA;QAExC,KAAK,CAAC,oBAAoB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAA;QAEzC,KAAK,CAAC,oCAAoC,CAAC,IAAI,EAAE,UAAU,CAAC,CAAA;QAC5D,KAAK,CAAC,yCAAyC,CAAC,IAAI,EAAE,UAAU,CAAC,CAAA;QAEjE,IAAA,4BAAgB,EAAC,IAAI,EAAE,UAAU,CAAC,CAAA;QAElC,IAAA,0CAAsB,EAAC,IAAI,EAAE,UAAU,CAAC,CAAA;QACxC,IAAA,4BAAe,EAAC,IAAI,EAAE,UAAU,CAAC,CAAA;QAEjC,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,CAAA;QACxC,KAAK,CAAC,4BAA4B,CAAC,IAAI,EAAE,UAAU,CAAC,CAAA;QAEpD,uEAAuE;QACvE,yEAAyE;QACzE,0EAA0E;QAC1E,yCAAyC;QACzC,IAAA,+CAAyB,EAAC,IAAI,CAAC,CAAA;QAE/B,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;QACrC,KAAK,CAAC,kBAAkB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;QAEtC,KAAK,CAAC,0BAA0B,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QAC3C,KAAK,CAAC,eAAe,CAAC,IAAI,EAAE,UAAU,CAAC,CAAA;QAEvC,OAAO,IAAI,CAAA;IACb,CAAC;IAEM,iCAAc,GAArB,UACE,OAAoB,EACpB,OAAsD;QAAtD,wBAAA,EAAA,YAA8B,kBAAkB,EAAE,EAAE,EAAE;QAEtD,IAAM,OAAO,GAAG,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;QAElE,IAAM,UAAU,yBACX,OAAO,KACV,OAAO,SAAA,GACR,CAAA;QACD,IAAM,aAAa,GAAG,2BAAS,CAAC,WAAW,CAAC,OAAO,CAAC,CAAA;QACpD,KAAK,CAAC,cAAc,CAAC,aAAa,EAAE,UAAU,CAAC,CAAA;QAC/C,OAAO,aAAa,CAAA;IACtB,CAAC;IACH,eAAC;AAAD,CAAC,AA5ED,IA4EC"}

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"}

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

@@ -0,0 +1,205 @@
+"use strict";
+/**
+ * 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" }])`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractRootIdentifiers = void 0;
+var IDENTIFIER_START = /[A-Za-z_$]/;
+var IDENTIFIER_PART = /[A-Za-z0-9_$]/;
+/**
+ * Words that are valid identifiers to the lexer but are language keywords or
+ * literals, never a variable reference we could neutralise.
+ */
+var RESERVED_WORDS = new Set([
+    'true',
+    'false',
+    'null',
+    'undefined',
+    'this',
+    'super',
+    'new',
+    'delete',
+    'void',
+    'typeof',
+    'instanceof',
+    'in',
+    'of',
+    'do',
+    'if',
+    'else',
+    'for',
+    'while',
+    'switch',
+    'case',
+    'default',
+    'break',
+    'continue',
+    'return',
+    'function',
+    'var',
+    'let',
+    'const',
+    'class',
+    'extends',
+    'yield',
+    'await',
+    'async',
+    'throw',
+    'try',
+    'catch',
+    'finally',
+    'import',
+    'export',
+    'from',
+    'as',
+    'with',
+    'debugger',
+]);
+var isWhitespace = function (char) {
+    return char === ' ' || char === '\t' || char === '\n' || char === '\r' || char === '\f' || char === '\v';
+};
+/**
+ * True when the next non-whitespace character starting at `from` is a single
+ * `:` (an object-literal key separator, not the `::` of a type/label). Used to
+ * tell `{ active: item.x }` (key) apart from `cond ? item : other` (reference).
+ */
+var nextNonWhitespaceIsColon = function (code, from) {
+    var index = from;
+    while (index < code.length && isWhitespace(code[index])) {
+        index += 1;
+    }
+    return code[index] === ':' && code[index + 1] !== ':';
+};
+var skipStringLiteral = function (code, start) {
+    var quote = code[start];
+    var index = start + 1;
+    while (index < code.length) {
+        var char = code[index];
+        if (char === '\\') {
+            index += 2;
+            continue;
+        }
+        if (char === quote) {
+            return index + 1;
+        }
+        index += 1;
+    }
+    return index;
+};
+/**
+ * Reads a template literal starting at the backtick under `start`. Static text
+ * is ignored; every `${ ... }` interpolation is recursively scanned for roots.
+ * Returns the index just past the closing backtick.
+ */
+var scanTemplateLiteral = function (code, start, roots) {
+    var index = start + 1;
+    while (index < code.length) {
+        var char = code[index];
+        if (char === '\\') {
+            index += 2;
+            continue;
+        }
+        if (char === '`') {
+            return index + 1;
+        }
+        if (char === '$' && code[index + 1] === '{') {
+            var interpolationStart = index + 2;
+            var depth = 1;
+            var cursor = interpolationStart;
+            while (cursor < code.length && depth > 0) {
+                var inner = code[cursor];
+                if (inner === '{') {
+                    depth += 1;
+                }
+                else if (inner === '}') {
+                    depth -= 1;
+                    if (depth === 0) {
+                        break;
+                    }
+                }
+                else if (inner === '`') {
+                    cursor = scanTemplateLiteral(code, cursor, roots) - 1;
+                }
+                else if (inner === "'" || inner === '"') {
+                    cursor = skipStringLiteral(code, cursor) - 1;
+                }
+                cursor += 1;
+            }
+            collectRootIdentifiers(code.slice(interpolationStart, cursor), roots);
+            index = cursor + 1;
+            continue;
+        }
+        index += 1;
+    }
+    return index;
+};
+var collectRootIdentifiers = function (code, roots) {
+    var index = 0;
+    // Last non-whitespace character seen — used to tell a member access
+    // (`.name`, `?.name`) apart from a root reference.
+    var previousSignificant = '';
+    while (index < code.length) {
+        var char = code[index];
+        if (isWhitespace(char)) {
+            index += 1;
+            continue;
+        }
+        if (char === "'" || char === '"') {
+            index = skipStringLiteral(code, index);
+            previousSignificant = '"';
+            continue;
+        }
+        if (char === '`') {
+            index = scanTemplateLiteral(code, index, roots);
+            previousSignificant = '`';
+            continue;
+        }
+        if (IDENTIFIER_START.test(char)) {
+            var end = index + 1;
+            while (end < code.length && IDENTIFIER_PART.test(code[end])) {
+                end += 1;
+            }
+            var identifier = code.slice(index, end);
+            var isMemberAccess = previousSignificant === '.';
+            // An unquoted object-literal key (`{ key: ... }` / `, key: ...`) is a
+            // property name, not a variable read.
+            var isObjectKey = (previousSignificant === '{' || previousSignificant === ',') &&
+                nextNonWhitespaceIsColon(code, end);
+            if (!isMemberAccess && !isObjectKey && !RESERVED_WORDS.has(identifier)) {
+                roots.add(identifier);
+            }
+            index = end;
+            previousSignificant = 'a';
+            continue;
+        }
+        previousSignificant = char;
+        index += 1;
+    }
+};
+/**
+ * Returns the set of root reference identifiers read by an expression string.
+ */
+var extractRootIdentifiers = function (expression) {
+    var roots = new Set();
+    if (typeof expression === 'string' && expression.length > 0) {
+        collectRootIdentifiers(expression, roots);
+    }
+    return roots;
+};
+exports.extractRootIdentifiers = extractRootIdentifiers;
+//# sourceMappingURL=expression-identifiers.js.map

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

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

package/dist/cjs/resolvers/unbound-expressions/index.d.ts

@@ -0,0 +1,3 @@
+import { ComponentUIDL } from '@teleporthq/teleport-types';
+export declare const resolveUnboundExpressions: (uidl: ComponentUIDL) => void;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/resolvers/unbound-expressions/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAA0C,MAAM,4BAA4B,CAAA;AA0MlG,eAAO,MAAM,yBAAyB,SAAU,aAAa,KAAG,IAM/D,CAAA"}