@teleporthq/teleport-uidl-resolver 0.43.44 → 0.43.46

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

@@ -0,0 +1,64 @@
+import { extractFallbackLiteral } from '../../src/resolvers/unbound-expressions/expression-fallback'
+
+describe('extractFallbackLiteral', () => {
+  it('returns the string literal an expression falls back to', () => {
+    expect(extractFallbackLiteral('company?.name || "N/A"')).toBe('N/A')
+    expect(extractFallbackLiteral("deal?.stage || 'Unassigned'")).toBe('Unassigned')
+    expect(extractFallbackLiteral('company?.logo ?? "https://cdn/placeholder.png"')).toBe(
+      'https://cdn/placeholder.png'
+    )
+  })
+
+  it('returns the last fallback of a chain', () => {
+    expect(extractFallbackLiteral('a || b || "last"')).toBe('last')
+    expect(extractFallbackLiteral('a ?? b ?? "last"')).toBe('last')
+  })
+
+  it('returns numeric fallbacks verbatim', () => {
+    expect(extractFallbackLiteral('parseFloat(item.price) || 0')).toBe('0')
+    expect(extractFallbackLiteral('item.ratio || 1.5')).toBe('1.5')
+    expect(extractFallbackLiteral('item.delta || -1')).toBe('-1')
+    expect(extractFallbackLiteral('item.delta || +1')).toBe('1')
+  })
+
+  it('accepts a template literal with no interpolation', () => {
+    expect(extractFallbackLiteral('item.label || `Untitled`')).toBe('Untitled')
+  })
+
+  it('rejects a template literal that still reads scope', () => {
+    // tslint:disable-next-line no-invalid-template-strings
+    expect(extractFallbackLiteral('item.label || `${item.id}`')).toBeNull()
+  })
+
+  it('ignores operators that live inside literals', () => {
+    expect(extractFallbackLiteral(`company?.size || "size || '-'"`)).toBe(`size || '-'`)
+    expect(extractFallbackLiteral(`"a || b"`)).toBeNull()
+  })
+
+  it('ignores operators nested inside parentheses, brackets or braces', () => {
+    expect(extractFallbackLiteral('fn(a || "inner")')).toBeNull()
+    expect(extractFallbackLiteral('map[a || "inner"]')).toBeNull()
+    expect(extractFallbackLiteral('{ key: a || "inner" }')).toBeNull()
+  })
+
+  it('rejects a fallback that is not a standalone literal', () => {
+    expect(extractFallbackLiteral('company?.name || buildName(company)')).toBeNull()
+    expect(extractFallbackLiteral(`company?.name || (a ? 'x' : 'y')`)).toBeNull()
+    expect(extractFallbackLiteral('company?.flag || true')).toBeNull()
+  })
+
+  it('does not confuse optional chaining or a ternary with a nullish fallback', () => {
+    expect(extractFallbackLiteral(`company?.name`)).toBeNull()
+    expect(extractFallbackLiteral(`company ? 'yes' : 'no'`)).toBeNull()
+  })
+
+  it('decodes escape sequences in the literal', () => {
+    expect(extractFallbackLiteral(`a || 'It\\'s here'`)).toBe("It's here")
+    expect(extractFallbackLiteral('a || "line\\nbreak"')).toBe('line\nbreak')
+  })
+
+  it('returns null for empty or non-string input', () => {
+    expect(extractFallbackLiteral('')).toBeNull()
+    expect(extractFallbackLiteral(undefined as unknown as string)).toBeNull()
+  })
+})

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

@@ -1,9 +1,11 @@
-import { extractRootIdentifiers } from '../../src/resolvers/unbound-expressions/expression-identifiers'
+import { analyzeExpressionScope } from '../../src/resolvers/unbound-expressions/expression-identifiers'
 
 const roots = (expression: string): string[] =>
-  Array.from(extractRootIdentifiers(expression)).sort()
+  Array.from(analyzeExpressionScope(expression).freeIdentifiers).sort()
 
-describe('extractRootIdentifiers', () => {
+const isResolvable = (expression: string): boolean => analyzeExpressionScope(expression).resolvable
+
+describe('analyzeExpressionScope', () => {
   it('returns the leading identifier of a member expression', () => {
     expect(roots('cat.name')).toEqual(['cat'])
     expect(roots('loc.location_id')).toEqual(['loc'])
@@ -56,6 +58,47 @@ describe('extractRootIdentifiers', () => {
 
   it('returns an empty set for empty or non-string input', () => {
     expect(roots('')).toEqual([])
-    expect(Array.from(extractRootIdentifiers(undefined as unknown as string))).toEqual([])
+    expect(
+      Array.from(analyzeExpressionScope(undefined as unknown as string).freeIdentifiers)
+    ).toEqual([])
+  })
+
+  it('subtracts identifiers bound by an arrow function parameter list', () => {
+    expect(roots('(event) => event.target.value')).toEqual([])
+    expect(roots('item => item.id')).toEqual([])
+    expect(roots('rows.map((row, i) => row.name + i)').sort()).toEqual(['rows'])
+    expect(roots('(a, b) => a + b + outer').sort()).toEqual(['outer'])
+  })
+
+  it('subtracts identifiers bound by a function expression', () => {
+    expect(roots('(function (a) { return a })')).toEqual([])
+    expect(roots('(function total(a) { return total(a) })')).toEqual([])
+    expect(roots('(function (a) { return a + outer })')).toEqual(['outer'])
+  })
+
+  it('keeps nested arrow scopes independent of the outer expression', () => {
+    // tslint:disable-next-line no-invalid-template-strings
+    expect(roots('groups.map((group) => group.items.map((entry) => entry.id))')).toEqual(['groups'])
+  })
+
+  it('still sees references that only appear outside a callback', () => {
+    expect(roots('outer.list.filter((x) => x.ok)').sort()).toEqual(['outer'])
+  })
+
+  it('reports block-scoped declarations as unresolvable rather than guessing', () => {
+    expect(isResolvable('(() => { const total = 1; return total })()')).toBe(false)
+    expect(isResolvable('(() => { let total = 1; return total })()')).toBe(false)
+    expect(isResolvable('(() => { var total = 1; return total })()')).toBe(false)
+    expect(isResolvable('props.value')).toBe(true)
+    expect(isResolvable('(event) => event.target.value')).toBe(true)
+  })
+
+  it('does not mistake a property named like a keyword for a declaration', () => {
+    expect(isResolvable('props.constant')).toBe(true)
+    expect(roots('props.constant')).toEqual(['props'])
+    // Reserved words are legal property names.
+    expect(isResolvable('props.const')).toBe(true)
+    expect(roots('props.const')).toEqual(['props'])
+    expect(roots('props.function + Math.max(a, b)').sort()).toEqual(['Math', 'a', 'b', 'props'])
   })
 })

package/__tests__/unbound-expressions/index.ts

@@ -24,6 +24,23 @@ const buildComponent = (node: UIDLElementNode): ComponentUIDL =>
     },
   } as unknown as ComponentUIDL)
 
+const containerWith = (children: UIDLNode[]): UIDLElementNode => ({
+  type: 'element',
+  content: { elementType: 'container', children },
+})
+
+// `console.warn` is the resolver's diagnostic channel; silence it so the suite
+// output stays readable while still exercising the code path.
+let warnSpy: jest.SpyInstance
+
+beforeEach(() => {
+  warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => undefined)
+})
+
+afterEach(() => {
+  warnSpy.mockRestore()
+})
+
 describe('resolveUnboundExpressions', () => {
   it('neutralises an orphaned option expression that references an unbound iterator', () => {
     const option = optionWith(expr('cat.name'))
@@ -54,16 +71,65 @@ describe('resolveUnboundExpressions', () => {
         },
       },
     } as UIDLNode
-    const uidl = buildComponent({
-      type: 'element',
-      content: { elementType: 'container', children: [repeater] },
-    })
+    const uidl = buildComponent(containerWith([repeater]))
 
     resolveUnboundExpressions(uidl)
 
     expect(boundExpr).toEqual({ type: 'expr', content: 'item?.id' })
   })
 
+  it('keeps the `index` a list repeater binds alongside its render prop', () => {
+    const indexExpr = expr('index + 1')
+    const repeater: UIDLNode = {
+      type: 'cms-list-repeater',
+      content: {
+        elementType: 'fragment',
+        name: 'list',
+        key: 'list',
+        renderPropIdentifier: 'item',
+        nodes: {
+          list: {
+            type: 'element',
+            content: { elementType: 'div', children: [indexExpr] },
+          },
+        },
+      },
+    } as UIDLNode
+    const uidl = buildComponent(containerWith([repeater]))
+
+    resolveUnboundExpressions(uidl)
+
+    expect(indexExpr).toEqual({ type: 'expr', content: 'index + 1' })
+  })
+
+  it('keeps `index` inside a repeat that opts into it and drops it otherwise', () => {
+    const indexed: UIDLElementNode = {
+      type: 'element',
+      content: { elementType: 'div', children: [expr('index')] },
+    }
+    const notIndexed: UIDLElementNode = {
+      type: 'element',
+      content: { elementType: 'div', children: [expr('index')] },
+    }
+    const repeatNode = (child: UIDLElementNode, useIndex: boolean): UIDLNode =>
+      ({
+        type: 'repeat',
+        content: {
+          node: child,
+          dataSource: { type: 'dynamic', content: { referenceType: 'prop', id: 'inventoryItem' } },
+          meta: { iteratorName: 'row', useIndex },
+        },
+      } as UIDLNode)
+    const uidl = buildComponent(
+      containerWith([repeatNode(indexed, true), repeatNode(notIndexed, false)])
+    )
+
+    resolveUnboundExpressions(uidl)
+
+    expect(indexed.content.children[0]).toEqual({ type: 'expr', content: 'index' })
+    expect(notIndexed.content.children[0]).toEqual({ type: 'static', content: '' })
+  })
+
   it('flags a repeater iterator referenced outside of its subtree', () => {
     const escaped = optionWith(expr('item?.id'))
     const repeater: UIDLNode = {
@@ -78,35 +144,49 @@ describe('resolveUnboundExpressions', () => {
         },
       },
     } as UIDLNode
-    const uidl = buildComponent({
-      type: 'element',
-      content: { elementType: 'container', children: [repeater, escaped] },
-    })
+    const uidl = buildComponent(containerWith([repeater, escaped]))
 
     resolveUnboundExpressions(uidl)
 
     expect(escaped.content.children[0]).toEqual({ type: 'static', content: '' })
   })
 
-  it('keeps expressions that reference props, state, globals and event', () => {
+  it('keeps expressions that reference props, state and globals', () => {
     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],
-      },
-    })
+    const globalExpr = expr('JSON.stringify(props.inventoryItem)')
+    const uidl = buildComponent(containerWith([propsExpr, stateExpr, globalExpr]))
 
     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' })
+    expect(globalExpr).toEqual({ type: 'expr', content: 'JSON.stringify(props.inventoryItem)' })
+  })
+
+  it('neutralises the renderer-only `state` object, which generated code never declares', () => {
+    // Regression: React state is destructured into bare variables, so a `state`
+    // reference that survived the editor export compiles to
+    // `ReferenceError: state is not defined` and fails `next build`.
+    const container = containerWith([expr('state'), expr('state.addressLine')])
+    const uidl = buildComponent(container)
+
+    resolveUnboundExpressions(uidl)
+
+    expect(container.content.children).toEqual([
+      { type: 'static', content: '' },
+      { type: 'static', content: '' },
+    ])
+  })
+
+  it('keeps a state named `state` when the component actually declares it', () => {
+    const container = containerWith([expr('state')])
+    const uidl = buildComponent(container)
+    uidl.stateDefinitions.state = { type: 'string', defaultValue: '' }
+
+    resolveUnboundExpressions(uidl)
+
+    expect(container.content.children).toEqual([{ type: 'expr', content: 'state' }])
   })
 
   it('neutralises an unbound expression used as an attribute value', () => {
@@ -147,6 +227,79 @@ describe('resolveUnboundExpressions', () => {
     ])
   })
 
+  it('keeps the literal fallback an unbound expression was authored with', () => {
+    const srcAttr: UIDLElementNode = {
+      type: 'element',
+      content: {
+        elementType: 'image',
+        attrs: { src: { type: 'expr', content: `company?.logo ?? 'https://cdn/placeholder.png'` } },
+        children: [],
+      },
+    }
+    const container = containerWith([expr(`company?.name || "N/A"`), srcAttr])
+    const uidl = buildComponent(container)
+
+    resolveUnboundExpressions(uidl)
+
+    expect(container.content.children[0]).toEqual({ type: 'static', content: 'N/A' })
+    expect(srcAttr.content.attrs!.src).toEqual({
+      type: 'static',
+      content: 'https://cdn/placeholder.png',
+    })
+  })
+
+  it('does not mistake a fallback-looking literal inside a string for a real fallback', () => {
+    const container = containerWith([expr(`company?.size || "size || '-'"`)])
+    const uidl = buildComponent(container)
+
+    resolveUnboundExpressions(uidl)
+
+    expect(container.content.children[0]).toEqual({ type: 'static', content: `size || '-'` })
+  })
+
+  it('blanks rather than guesses when the fallback is not a plain literal', () => {
+    const container = containerWith([expr('company?.name || buildName(company)')])
+    const uidl = buildComponent(container)
+
+    resolveUnboundExpressions(uidl)
+
+    expect(container.content.children[0]).toEqual({ type: 'static', content: '' })
+  })
+
+  it('keeps an inline callback whose parameter is declared by the expression itself', () => {
+    const callbackExpr = expr('(event) => event.target.value')
+    // tslint:disable-next-line no-invalid-template-strings
+    const arrowExpr = expr('props.inventoryItem.tags.map((tag, i) => `${i}:${tag}`).join()')
+    const container = containerWith([callbackExpr, arrowExpr])
+    const uidl = buildComponent(container)
+
+    resolveUnboundExpressions(uidl)
+
+    expect(container.content.children).toEqual([callbackExpr, arrowExpr])
+  })
+
+  it('leaves an expression alone when it declares bindings the analyser cannot resolve', () => {
+    const iife = expr('(() => { const total = 2; return total })()')
+    const container = containerWith([iife])
+    const uidl = buildComponent(container)
+
+    resolveUnboundExpressions(uidl)
+
+    expect(container.content.children).toEqual([iife])
+  })
+
+  it('does not treat quoted JSON payloads as references', () => {
+    const filterExpr = expr(
+      `JSON.stringify([{ "type": "condition", "source": "id", "operand": "=" }])`
+    )
+    const container = containerWith([filterExpr])
+    const uidl = buildComponent(container)
+
+    resolveUnboundExpressions(uidl)
+
+    expect(container.content.children).toEqual([filterExpr])
+  })
+
   it('keeps a navlink transitionTo that references a global-context identifier', () => {
     // Regression: the abilities resolver emits transitionTo exprs like
     // `/profile/${currentUser?.id}` for details navlinks bound to
@@ -163,10 +316,7 @@ describe('resolveUnboundExpressions', () => {
         children: [],
       },
     }
-    const uidl = buildComponent({
-      type: 'element',
-      content: { elementType: 'container', children: [link] },
-    })
+    const uidl = buildComponent(containerWith([link]))
 
     resolveUnboundExpressions(uidl)
 
@@ -176,4 +326,46 @@ describe('resolveUnboundExpressions', () => {
       content: '`/profile/${currentUser?.id}`',
     })
   })
+
+  it('neutralises an unbound reference inside a template literal', () => {
+    const link: UIDLElementNode = {
+      type: 'element',
+      content: {
+        elementType: 'navlink',
+        attrs: {
+          // tslint:disable-next-line no-invalid-template-strings
+          transitionTo: { type: 'expr', content: '`/deal-details/${deal?.id}`' },
+        },
+        children: [],
+      },
+    }
+    const uidl = buildComponent(containerWith([link]))
+
+    resolveUnboundExpressions(uidl)
+
+    expect(link.content.attrs.transitionTo).toEqual({ type: 'static', content: '' })
+  })
+
+  it('keeps the render prop a data-source node introduces for its children', () => {
+    const boundExpr = expr('dataSourceData?.title')
+    const dataSource: UIDLNode = {
+      type: 'data-source-item',
+      content: {
+        elementType: 'DataProvider',
+        renderPropIdentifier: 'dataSourceData',
+        resourceDefinition: {
+          type: 'external-data-source',
+          dataSourceId: 'ds-1',
+          tableName: 'items',
+          dataSourceType: 'postgresql',
+        },
+        children: [{ type: 'element', content: { elementType: 'div', children: [boundExpr] } }],
+      },
+    } as UIDLNode
+    const uidl = buildComponent(containerWith([dataSource]))
+
+    resolveUnboundExpressions(uidl)
+
+    expect(boundExpr).toEqual({ type: 'expr', content: 'dataSourceData?.title' })
+  })
 })

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

@@ -1,17 +1,39 @@
 /**
- * Root identifiers that are always in scope inside a generated component and
- * therefore can never be an "unbound" reference:
+ * Root identifiers that are always in scope where a UIDL `expr` node is
+ * rendered — i.e. in the component's RENDER BODY, which is the only place this
+ * resolver inspects (element children, element attributes and the link ability
+ * the abilities resolver has not yet folded into attributes).
  *
- *  - 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.
+ * Membership here is a promise that the code generator declares the name. It is
+ * therefore limited to:
  *
- * 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.
+ *  - `props`, the render function's own parameter,
+ *  - the global-context values the JSX emitter destructures from
+ *    `useGlobalContext()` whenever it sees them in an expression
+ *    (`GLOBAL_EXPRESSION_IDENTIFIERS` in teleport-plugin-common node-to-jsx),
+ *  - standard JavaScript / browser globals.
+ *
+ * Deliberately NOT here:
+ *
+ *  - `state` — React state is destructured into bare variables
+ *    (`dynamicReferencePrefixMap.state` is `''`), so there is no `state` object
+ *    at runtime and `state` / `state.x` in an expression is always a
+ *    `ReferenceError`. Individual state names come from `stateDefinitions`.
+ *  - `params`, `index` and render-prop names — these ARE bound, but only inside
+ *    the subtree of the node that introduces them (a repeater's `.map()`
+ *    callback, a CMS/data-source `renderSuccess` prop). The walker tracks them
+ *    positionally so a reference that escapes its owner is still caught.
+ *  - `event` / `evt` / `e` — bound only inside event handlers, which this
+ *    resolver does not visit. When one appears in a render-scope expression it
+ *    is either an inline callback parameter (the scope analyser sees the
+ *    binding) or genuinely undeclared.
+ *  - `context`, `ctx`, `metadata`, `record`, `idx`, `key`, `i` — no generator
+ *    ever declares these names in a render body.
+ *
+ * Reserved words and literals (`true`, `null`, `undefined`, …) are filtered out
+ * by the lexer itself and need no entry here.
  */
-export declare const AMBIENT_IDENTIFIERS: Set<string>;
+export declare const RENDER_SCOPE_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

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

@@ -1 +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,aA4E9B,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,eAAgB,MAAM,KAAG,OACT,CAAA"}
+{"version":3,"file":"ambient-identifiers.d.ts","sourceRoot":"","sources":["../../../../src/resolvers/unbound-expressions/ambient-identifiers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,eAAO,MAAM,wBAAwB,aA6DnC,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,eAAgB,MAAM,KAAG,OACT,CAAA"}

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

@@ -1,27 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isGeneratorInternalIdentifier = exports.AMBIENT_IDENTIFIERS = void 0;
+exports.isGeneratorInternalIdentifier = exports.RENDER_SCOPE_IDENTIFIERS = void 0;
 /**
- * Root identifiers that are always in scope inside a generated component and
- * therefore can never be an "unbound" reference:
+ * Root identifiers that are always in scope where a UIDL `expr` node is
+ * rendered — i.e. in the component's RENDER BODY, which is the only place this
+ * resolver inspects (element children, element attributes and the link ability
+ * the abilities resolver has not yet folded into attributes).
  *
- *  - 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.
+ * Membership here is a promise that the code generator declares the name. It is
+ * therefore limited to:
  *
- * 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.
+ *  - `props`, the render function's own parameter,
+ *  - the global-context values the JSX emitter destructures from
+ *    `useGlobalContext()` whenever it sees them in an expression
+ *    (`GLOBAL_EXPRESSION_IDENTIFIERS` in teleport-plugin-common node-to-jsx),
+ *  - standard JavaScript / browser globals.
+ *
+ * Deliberately NOT here:
+ *
+ *  - `state` — React state is destructured into bare variables
+ *    (`dynamicReferencePrefixMap.state` is `''`), so there is no `state` object
+ *    at runtime and `state` / `state.x` in an expression is always a
+ *    `ReferenceError`. Individual state names come from `stateDefinitions`.
+ *  - `params`, `index` and render-prop names — these ARE bound, but only inside
+ *    the subtree of the node that introduces them (a repeater's `.map()`
+ *    callback, a CMS/data-source `renderSuccess` prop). The walker tracks them
+ *    positionally so a reference that escapes its owner is still caught.
+ *  - `event` / `evt` / `e` — bound only inside event handlers, which this
+ *    resolver does not visit. When one appears in a render-scope expression it
+ *    is either an inline callback parameter (the scope analyser sees the
+ *    binding) or genuinely undeclared.
+ *  - `context`, `ctx`, `metadata`, `record`, `idx`, `key`, `i` — no generator
+ *    ever declares these names in a render body.
+ *
+ * Reserved words and literals (`true`, `null`, `undefined`, …) are filtered out
+ * by the lexer itself and need no entry here.
  */
-exports.AMBIENT_IDENTIFIERS = new Set([
-    // Code-generator provided render-scope values
+exports.RENDER_SCOPE_IDENTIFIERS = new Set([
+    // The render function's own parameter
     'props',
-    'state',
-    'context',
-    'ctx',
-    'metadata',
-    'record',
     // Global-context values: the JSX emitter scans expressions for these
     // (GLOBAL_EXPRESSION_IDENTIFIERS in teleport-plugin-common node-to-jsx) and
     // injects the matching `useGlobalContext()` destructuring, so they are
@@ -33,15 +50,6 @@ exports.AMBIENT_IDENTIFIERS = new Set([
     'cart',
     'locale',
     'locales',
-    // Event handler / map callback parameters
-    'event',
-    'evt',
-    'e',
-    'params',
-    'index',
-    'idx',
-    'key',
-    'i',
     // Browser globals
     'window',
     'document',
@@ -57,7 +65,6 @@ exports.AMBIENT_IDENTIFIERS = new Set([
     'URLSearchParams',
     // Language built-ins
     'globalThis',
-    'undefined',
     'NaN',
     'Infinity',
     'JSON',

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

@@ -1 +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,qEAAqE;IACrE,4EAA4E;IAC5E,uEAAuE;IACvE,2EAA2E;IAC3E,gEAAgE;IAChE,aAAa;IACb,gBAAgB;IAChB,WAAW;IACX,MAAM;IACN,QAAQ;IACR,SAAS;IACT,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"}
+{"version":3,"file":"ambient-identifiers.js","sourceRoot":"","sources":["../../../../src/resolvers/unbound-expressions/ambient-identifiers.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACU,QAAA,wBAAwB,GAAG,IAAI,GAAG,CAAS;IACtD,sCAAsC;IACtC,OAAO;IACP,qEAAqE;IACrE,4EAA4E;IAC5E,uEAAuE;IACvE,2EAA2E;IAC3E,gEAAgE;IAChE,aAAa;IACb,gBAAgB;IAChB,WAAW;IACX,MAAM;IACN,QAAQ;IACR,SAAS;IACT,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,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-fallback.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Recovers the literal an expression was authored to fall back to.
+ *
+ * Content bindings produced by the editor almost always carry a human-authored
+ * default — `company?.name || "N/A"`, `featured?.image_url || "https://…"`.
+ * When the reference at the head of such an expression turns out to be
+ * unbound, dropping the WHOLE expression throws that default away and leaves an
+ * empty cell / a broken `src`. Keeping the fallback preserves what the author
+ * actually wanted to show when the data is missing — which is precisely the
+ * situation an unbound reference represents.
+ *
+ * Only the tail of a top-level `||` / `??` chain is considered, and only when it
+ * is a single string or number literal. Anything else (a call, a ternary, a
+ * template with interpolations) is not a safe static substitute, so the caller
+ * falls back to an empty value.
+ */
+/**
+ * Returns the literal an expression falls back to, or `null` when it has no
+ * literal fallback that can stand on its own.
+ */
+export declare const extractFallbackLiteral: (expression: string) => string | null;
+//# sourceMappingURL=expression-fallback.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"expression-fallback.d.ts","sourceRoot":"","sources":["../../../../src/resolvers/unbound-expressions/expression-fallback.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AA8GH;;;GAGG;AACH,eAAO,MAAM,sBAAsB,eAAgB,MAAM,KAAG,MAAM,GAAG,IAWpE,CAAA"}