@teleporthq/teleport-plugin-common 0.43.57 → 0.43.60

package/__tests__/builders/style-builders.ts

@@ -24,6 +24,29 @@ describe('CSS Class Generation', () => {
     expect(result).toEqual(`.name h1 > h2 .ab.cd #id {
   some-key: value;
   other-key: otherValue;
+}`)
+  })
+
+  it('attaches an ATTRIBUTE subselector with no separating space', () => {
+    // ⛔ THE SELECTED-PAGE CONTRACT. A numbered pagination strip repeats one
+    // authored node per visible page, so the copies cannot differ in the
+    // document. Both runtimes instead mark the showing page with
+    // `aria-current="page"` (`numbered-pagination.ts` here, `element-node.tsx`
+    // in the canvas editor), and the LOOK is a compound project class whose
+    // subselector is that attribute.
+    //
+    // A space before the bracket would turn this into a DESCENDANT selector —
+    // `.thq-page-number [aria-current='page']` matches something INSIDE the
+    // button, never the button — and the selected page would silently render
+    // identically to every other one. Which is exactly the bug the marker was
+    // added to fix.
+    const result = createCSSClassWithSelector('thq-page-number', "&[aria-current='page']", {
+      background: '#2563eb',
+      fontWeight: '600',
+    })
+    expect(result).toEqual(`.thq-page-number[aria-current='page'] {
+  background: #2563eb;
+  font-weight: 600;
 }`)
   })
 })

package/__tests__/node-handlers/node-to-jsx/calendar-events-reviver.ts

@@ -40,6 +40,7 @@ const buildParams = (): JSXGenerationParams => ({
   nodesLookup: {},
   windowImports: {},
   localeReferences: [],
+  localeAttributeReferences: [],
   globalReferences: [],
   globalStateReferences: [],
   hoistedConstants: [],

package/__tests__/node-handlers/node-to-jsx/cms-list-repeater-loading.ts

@@ -28,6 +28,7 @@ const params = (): JSXGenerationParams => ({
   nodesLookup: {},
   windowImports: {},
   localeReferences: [],
+  localeAttributeReferences: [],
   globalReferences: [],
   globalStateReferences: [],
   hoistedConstants: [],

package/__tests__/node-handlers/node-to-jsx/index.ts

@@ -20,6 +20,7 @@ describe('generateJSXSyntax', () => {
     nodesLookup: {},
     windowImports: {},
     localeReferences: [],
+    localeAttributeReferences: [],
     globalReferences: [],
     globalStateReferences: [],
     hoistedConstants: [],
@@ -119,6 +120,7 @@ describe('generateJSXSyntax', () => {
       nodesLookup: {},
       windowImports: {},
       localeReferences: [],
+      localeAttributeReferences: [],
       globalReferences: [],
       globalStateReferences: [],
       hoistedConstants: [],
@@ -545,6 +547,7 @@ describe('generateJSXSyntax', () => {
       nodesLookup: {},
       windowImports: {},
       localeReferences: [],
+      localeAttributeReferences: [],
       globalReferences: [],
       globalStateReferences: [],
       hoistedConstants: [],

package/__tests__/node-handlers/node-to-jsx/utils.ts

@@ -188,6 +188,7 @@ describe('createConditionIdentifier', () => {
     nodesLookup: {},
     windowImports: {},
     localeReferences: [],
+    localeAttributeReferences: [],
     globalReferences: [],
     globalStateReferences: [],
     hoistedConstants: [],

package/__tests__/utils/url-query-writer.ts

@@ -0,0 +1,239 @@
+import * as types from '@babel/types'
+import generator from '@babel/generator'
+import {
+  QUERY_SYNC_REF_ID,
+  QUERY_WRITER_ID,
+  buildQuerySettledExpr,
+  buildQuerySyncDeclarations,
+  buildQueryWriteCall,
+  ensureQuerySyncDeclarations,
+  hasQuerySyncDeclarations,
+} from '../../src/utils/url-query-writer'
+
+const codeOf = (nodes: types.Statement[]): string =>
+  generator(types.program(nodes) as types.Node).code
+
+/**
+ * A router that behaves like Next's.
+ *
+ * The two properties that caused the defect are reproduced faithfully:
+ *   • `replace` resolves ASYNCHRONOUSLY, and `query` is only updated when it
+ *     does — so a second writer running in the same tick still sees the old one;
+ *   • `query` is a fresh object each time, as `makePublicRouterInstance` makes it.
+ */
+const makeRouter = (initialQuery: Record<string, string>) => {
+  const replaced: Array<Record<string, string>> = []
+  let resolveAll: Array<() => void> = []
+  const router = {
+    pathname: '/products',
+    query: { ...initialQuery },
+    replace(url: { query: Record<string, string> }) {
+      replaced.push({ ...url.query })
+      return new Promise<boolean>((resolve) => {
+        resolveAll.push(() => {
+          // Next applies the navigation, THEN resolves.
+          router.query = { ...url.query }
+          resolve(true)
+        })
+      })
+    },
+  }
+  const settleAll = async (): Promise<void> => {
+    while (resolveAll.length > 0) {
+      const pending = resolveAll
+      resolveAll = []
+      pending.forEach((fn) => fn())
+      await Promise.resolve()
+      await Promise.resolve()
+    }
+  }
+  return { router, replaced, settleAll }
+}
+
+/** Evaluates the emitted declarations and hands back the writer they define. */
+const instantiate = (router: unknown) => {
+  const code = codeOf(buildQuerySyncDeclarations())
+  // tslint:disable-next-line:function-constructor
+  const factory = new Function(
+    'useRef',
+    'router',
+    `${code}\nreturn { ref: ${QUERY_SYNC_REF_ID}, write: ${QUERY_WRITER_ID} }`
+  )
+  // tslint:disable-next-line:no-any
+  const useRef = (initial: any) => ({ current: initial })
+  return factory(useRef, router) as {
+    ref: { current: { pending: Record<string, string> | null; inFlight: number } }
+    // tslint:disable-next-line:no-any
+    write: (key: string, value: any) => void
+  }
+}
+
+describe('URLQueryWriter — emitted shape', () => {
+  it('merges into the pending query, not into router.query', () => {
+    // Babel prints objects multi-line; the assertions read better flattened.
+    const code = codeOf(buildQuerySyncDeclarations()).replace(/\s+/g, ' ')
+
+    expect(code).toContain('const base = __tqQuerySyncRef.current.pending || router.query')
+    expect(code).toContain('const next = { ...base }')
+    // The only bail: this key already holds the value we would write.
+    expect(code).toContain('if (next[key] === base[key]) return')
+    expect(code).toContain('__tqQuerySyncRef.current.pending = next')
+    expect(code).toContain('__tqQuerySyncRef.current.inFlight += 1')
+    // Released once every replace it was built from has settled, so an external
+    // navigation is never merged into a stale snapshot.
+    expect(code).toContain('__tqQuerySyncRef.current.pending = null')
+    expect(code).toContain('shallow: true')
+  })
+
+  it('builds a call and a settled-check callers can compose', () => {
+    expect(generator(buildQueryWriteCall('page', types.identifier('__statePage'))).code).toBe(
+      '__tqWriteQueryParam("page", __statePage);'
+    )
+    expect(generator(buildQuerySettledExpr()).code).toBe('__tqQuerySyncRef.current.inFlight === 0')
+  })
+
+  it('declares itself once, after `const router = useRouter()`', () => {
+    const routerDecl = types.variableDeclaration('const', [
+      types.variableDeclarator(
+        types.identifier('router'),
+        types.callExpression(types.identifier('useRouter'), [])
+      ),
+    ])
+    const body: types.Statement[] = [routerDecl, types.returnStatement(types.nullLiteral())]
+
+    expect(hasQuerySyncDeclarations(body)).toBe(false)
+    expect(ensureQuerySyncDeclarations(body)).toBe(true)
+    expect(body.length).toBe(4)
+    expect(codeOf(body).indexOf('useRouter')).toBeLessThan(codeOf(body).indexOf(QUERY_SYNC_REF_ID))
+
+    // A second plugin needing the same pair must not emit a duplicate hook —
+    // that would also shift the hook order between renders.
+    expect(ensureQuerySyncDeclarations(body)).toBe(false)
+    expect(body.length).toBe(4)
+  })
+})
+
+/**
+ * ⛔ These run the generated code. Every other guard in this repo is a
+ * source-text assertion, and effect INTERLEAVING is exactly what source text
+ * cannot see — which is why the defect below shipped green.
+ */
+describe('URLQueryWriter — behaviour under a Next-like async router', () => {
+  it('keeps both keys when two controls write in the same flush', async () => {
+    // The live repro: on `?page=5`, picking a category writes the filter AND
+    // resets the page, so both writers run before either replace has landed.
+    const { router, replaced, settleAll } = makeRouter({ page: '5' })
+    const { write } = instantiate(router)
+
+    write('categoryFilter', 'Rings')
+    write('page', undefined) // page 1 ⇒ remove the key
+
+    expect(replaced).toHaveLength(2)
+    // The SECOND write built on the first's payload rather than on the stale
+    // `router.query` — this is the whole fix.
+    expect(replaced[1]).toEqual({ categoryFilter: 'Rings' })
+
+    await settleAll()
+    expect(router.query).toEqual({ categoryFilter: 'Rings' })
+  })
+
+  it('does not resurrect a key another writer removed in the same flush', async () => {
+    // The mirror image: clearing the search box on page 3 removes
+    // `?searchKeyword` and resets the page. A stale base would have put the
+    // search term the visitor just deleted straight back into the URL.
+    const { router, replaced, settleAll } = makeRouter({ page: '3', searchKeyword: 'shoes' })
+    const { write } = instantiate(router)
+
+    write('searchKeyword', '')
+    write('page', undefined)
+
+    expect(replaced[1]).toEqual({})
+    await settleAll()
+    expect(router.query).toEqual({})
+  })
+
+  it('settles, and never oscillates when both sides are re-asserted', async () => {
+    // Re-running every writer after the URL lands — which is what a re-render
+    // does — must produce NO further navigation. An extra replace here is the
+    // first step of the infinite loop.
+    const { router, replaced, settleAll } = makeRouter({ page: '5' })
+    const { write } = instantiate(router)
+
+    write('categoryFilter', 'Rings')
+    write('page', undefined)
+    await settleAll()
+
+    const settledCount = replaced.length
+    write('categoryFilter', 'Rings')
+    write('page', undefined)
+    expect(replaced).toHaveLength(settledCount)
+  })
+
+  it('bails without a replace when the key already holds the value', () => {
+    const { router, replaced } = makeRouter({ sortBy: 'price-asc' })
+    const { write } = instantiate(router)
+
+    write('sortBy', 'price-asc')
+    expect(replaced).toHaveLength(0)
+
+    // ...and removing an absent key is equally a no-op.
+    write('missing', undefined)
+    expect(replaced).toHaveLength(0)
+  })
+
+  it('coerces to a string, so a numeric page and a string filter round-trip alike', () => {
+    const { router, replaced } = makeRouter({})
+    const { write } = instantiate(router)
+
+    write('page', 3)
+    expect(replaced[0]).toEqual({ page: '3' })
+  })
+
+  it('reports settled only once every replace it issued has landed', async () => {
+    const { router, settleAll } = makeRouter({ page: '5' })
+    const { ref, write } = instantiate(router)
+
+    expect(ref.current.inFlight).toBe(0)
+    write('categoryFilter', 'Rings')
+    write('page', undefined)
+    // The page ⇄ URL effect reads this to know that `router.query` is a value
+    // the page is on its way OUT of, and must not be adopted.
+    expect(ref.current.inFlight).toBe(2)
+
+    await settleAll()
+    expect(ref.current.inFlight).toBe(0)
+    expect(ref.current.pending).toBeNull()
+  })
+
+  it('releases the pending query even when a navigation is rejected', async () => {
+    // A cancelled route must not freeze every later write against a stale base.
+    const router = {
+      pathname: '/products',
+      query: { page: '5' } as Record<string, string>,
+      replace: () => Promise.reject(new Error('route cancelled')),
+    }
+    const { ref, write } = instantiate(router)
+
+    write('categoryFilter', 'Rings')
+    await Promise.resolve()
+    await Promise.resolve()
+
+    expect(ref.current.inFlight).toBe(0)
+    expect(ref.current.pending).toBeNull()
+  })
+
+  it('picks up an external navigation once nothing is in flight', async () => {
+    // Browser back/forward moves the URL without asking us. The next write must
+    // build on where the browser actually is, not on our last request.
+    const { router, replaced, settleAll } = makeRouter({ page: '5' })
+    const { write } = instantiate(router)
+
+    write('categoryFilter', 'Rings')
+    await settleAll()
+
+    router.query = { locale: 'fr' } // an external navigation
+    write('page', 2)
+
+    expect(replaced[replaced.length - 1]).toEqual({ locale: 'fr', page: '2' })
+  })
+})

package/__tests__/utils/url-search-param-sync.ts

@@ -11,7 +11,7 @@ import {
 const codeOf = (node: types.Node): string => generator(node).code
 
 describe('URLSearchParamSync.buildUrlWriteBackEffect', () => {
-  it('emits a loop-free state→URL write-back for a bare state identifier (dropdown case)', () => {
+  it('delegates the write to the shared query writer (dropdown case)', () => {
     const effect = buildUrlWriteBackEffect(
       'categoryFilter',
       types.identifier('selectedCategory'),
@@ -22,17 +22,25 @@ describe('URLSearchParamSync.buildUrlWriteBackEffect', () => {
     // SSR + router-ready guards.
     expect(code).toContain('if (typeof window === "undefined") return')
     expect(code).toContain('if (!router.isReady) return')
-    // Snapshot the current query, then set or delete the bound key.
-    expect(code).toContain('const __nextQuery =')
-    expect(code).toContain('...router.query')
-    expect(code).toContain('if (selectedCategory === "" || selectedCategory == null)')
-    expect(code).toContain('delete __nextQuery.categoryFilter')
-    expect(code).toContain('__nextQuery.categoryFilter = String(selectedCategory)')
-    // Skip-if-equal guard prevents a redundant replace (the loop breaker on the URL side).
-    expect(code).toContain('if (__nextQuery.categoryFilter === router.query.categoryFilter) return')
-    expect(code).toContain('shallow: true')
-    // Deps: the value + router.isReady (so it re-runs once the router hydrates).
+
+    // ⛔ The effect must NOT build the next query itself. Spreading
+    // `router.query` here is what let two controls writing in one flush erase
+    // each other's keys — and, through their read-backs, oscillate forever.
+    expect(code).not.toContain('__nextQuery')
+    expect(code).not.toContain('...router.query')
+    expect(code).not.toContain('router.replace')
+
+    // One key, one call. `undefined` is the writer's "remove this key".
+    expect(code).toContain(
+      '__tqWriteQueryParam("categoryFilter", selectedCategory === "" || selectedCategory == null ? undefined : selectedCategory)'
+    )
+
+    // ⛔ `router.query` is deliberately NOT a dependency. It was added once as a
+    // way to RE-ASSERT a key another writer had dropped, which is precisely the
+    // edge that closed the loop; with clobbering fixed at its source there is
+    // nothing to re-assert.
     expect(code).toContain('}, [selectedCategory, router.isReady])')
+    expect(code).not.toContain('router.isReady, router.query]')
   })
 
   it('emits the write-back reading a member expression (search debounced-query case)', () => {
@@ -44,16 +52,14 @@ describe('URLSearchParamSync.buildUrlWriteBackEffect', () => {
     // The value pushed to the URL is read from the combined state object,
     // not a bare identifier — this is the generalization the search input needs.
     expect(code).toContain(
-      'if (ds_0_state.debouncedQuery === "" || ds_0_state.debouncedQuery == null)'
+      '__tqWriteQueryParam("searchKeyword", ds_0_state.debouncedQuery === "" || ds_0_state.debouncedQuery == null ? undefined : ds_0_state.debouncedQuery)'
     )
-    expect(code).toContain('__nextQuery.searchKeyword = String(ds_0_state.debouncedQuery)')
-    expect(code).toContain('if (__nextQuery.searchKeyword === router.query.searchKeyword) return')
     // Dependency is the debounced member expression, so the URL only updates
     // after the debounce commits — never on every keystroke.
     expect(code).toContain('}, [ds_0_state.debouncedQuery, router.isReady])')
   })
 
-  it('uses bracket notation for URL keys that are not valid JS identifiers', () => {
+  it('passes a non-identifier URL key through as a plain string argument', () => {
     const effect = buildUrlWriteBackEffect(
       'search-keyword',
       types.identifier('q'),
@@ -61,12 +67,12 @@ describe('URLSearchParamSync.buildUrlWriteBackEffect', () => {
     )
     const code = codeOf(effect)
 
-    expect(code).toContain('delete __nextQuery["search-keyword"]')
-    expect(code).toContain('__nextQuery["search-keyword"] = String(q)')
-    expect(code).not.toContain('__nextQuery.search-keyword')
+    // The writer indexes with `next[key]`, so an awkward key needs no bracket
+    // gymnastics at the call site any more.
+    expect(code).toContain('__tqWriteQueryParam("search-keyword"')
   })
 
-  it('also deletes the key when the value equals a non-empty default (clean canonical URL)', () => {
+  it('also removes the key when the value equals a non-empty default (clean canonical URL)', () => {
     const effect = buildUrlWriteBackEffect(
       'sortBy',
       types.identifier('sortBy'),
@@ -75,18 +81,16 @@ describe('URLSearchParamSync.buildUrlWriteBackEffect', () => {
     )
     const code = codeOf(effect)
 
-    // The default now also routes to the delete branch, so loading the page at
-    // its default sort never writes a sticky `?sortBy=name-asc`.
-    expect(code).toContain('if (sortBy === "" || sortBy == null || sortBy === "name-asc")')
-    expect(code).toContain('delete __nextQuery.sortBy')
-    expect(code).toContain('__nextQuery.sortBy = String(sortBy)')
+    // The default routes to the remove branch, so loading the page at its
+    // default sort never writes a sticky `?sortBy=name-asc`.
+    expect(code).toContain('sortBy === "" || sortBy == null || sortBy === "name-asc" ? undefined')
   })
 
-  it('omits the default clause when no default is supplied (byte-identical fallback)', () => {
+  it('omits the default clause when no default is supplied', () => {
     const withoutDefault = codeOf(
       buildUrlWriteBackEffect('sortBy', types.identifier('sortBy'), types.identifier('sortBy'))
     )
-    expect(withoutDefault).toContain('if (sortBy === "" || sortBy == null)')
+    expect(withoutDefault).toContain('sortBy === "" || sortBy == null ? undefined : sortBy')
     expect(withoutDefault).not.toContain('=== "name-asc"')
   })
 })

package/dist/cjs/index.d.ts

@@ -5,10 +5,11 @@ import * as ASTUtils from './utils/ast-utils';
 import * as StyleUtils from './utils/style-utils';
 import * as HASTUtils from './utils/hast-utils';
 import * as URLSearchParamSync from './utils/url-search-param-sync';
+import * as URLQueryWriter from './utils/url-query-writer';
 import * as RouteUtils from './utils/route-utils';
 import ParsedASTNode from './utils/parsed-ast';
 import { createBinaryExpression } from './node-handlers/node-to-jsx/utils';
-export { ASTBuilders, StyleBuilders, HASTBuilders, ASTUtils, StyleUtils, HASTUtils, URLSearchParamSync, RouteUtils, ParsedASTNode, createBinaryExpression, };
+export { ASTBuilders, StyleBuilders, HASTBuilders, ASTUtils, StyleUtils, HASTUtils, URLSearchParamSync, URLQueryWriter, RouteUtils, ParsedASTNode, createBinaryExpression, };
 export { default as createHTMLTemplateSyntax } from './node-handlers/node-to-html';
 export { default as createJSXSyntax } from './node-handlers/node-to-jsx';
 export * from './node-handlers/node-to-html/types';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAA;AACtD,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAA;AAC1D,OAAO,KAAK,YAAY,MAAM,0BAA0B,CAAA;AAExD,OAAO,KAAK,QAAQ,MAAM,mBAAmB,CAAA;AAC7C,OAAO,KAAK,UAAU,MAAM,qBAAqB,CAAA;AACjD,OAAO,KAAK,SAAS,MAAM,oBAAoB,CAAA;AAC/C,OAAO,KAAK,kBAAkB,MAAM,+BAA+B,CAAA;AACnE,OAAO,KAAK,UAAU,MAAM,qBAAqB,CAAA;AACjD,OAAO,aAAa,MAAM,oBAAoB,CAAA;AAE9C,OAAO,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAA;AAE1E,OAAO,EACL,WAAW,EACX,aAAa,EACb,YAAY,EACZ,QAAQ,EACR,UAAU,EACV,SAAS,EACT,kBAAkB,EAClB,UAAU,EACV,aAAa,EACb,sBAAsB,GACvB,CAAA;AAED,OAAO,EAAE,OAAO,IAAI,wBAAwB,EAAE,MAAM,8BAA8B,CAAA;AAClF,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,6BAA6B,CAAA;AAExE,cAAc,oCAAoC,CAAA;AAClD,cAAc,mCAAmC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAA;AACtD,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAA;AAC1D,OAAO,KAAK,YAAY,MAAM,0BAA0B,CAAA;AAExD,OAAO,KAAK,QAAQ,MAAM,mBAAmB,CAAA;AAC7C,OAAO,KAAK,UAAU,MAAM,qBAAqB,CAAA;AACjD,OAAO,KAAK,SAAS,MAAM,oBAAoB,CAAA;AAC/C,OAAO,KAAK,kBAAkB,MAAM,+BAA+B,CAAA;AACnE,OAAO,KAAK,cAAc,MAAM,0BAA0B,CAAA;AAC1D,OAAO,KAAK,UAAU,MAAM,qBAAqB,CAAA;AACjD,OAAO,aAAa,MAAM,oBAAoB,CAAA;AAE9C,OAAO,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAA;AAE1E,OAAO,EACL,WAAW,EACX,aAAa,EACb,YAAY,EACZ,QAAQ,EACR,UAAU,EACV,SAAS,EACT,kBAAkB,EAClB,cAAc,EACd,UAAU,EACV,aAAa,EACb,sBAAsB,GACvB,CAAA;AAED,OAAO,EAAE,OAAO,IAAI,wBAAwB,EAAE,MAAM,8BAA8B,CAAA;AAClF,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,6BAA6B,CAAA;AAExE,cAAc,oCAAoC,CAAA;AAClD,cAAc,mCAAmC,CAAA"}

package/dist/cjs/index.js

@@ -29,7 +29,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createJSXSyntax = exports.createHTMLTemplateSyntax = exports.createBinaryExpression = exports.ParsedASTNode = exports.RouteUtils = exports.URLSearchParamSync = exports.HASTUtils = exports.StyleUtils = exports.ASTUtils = exports.HASTBuilders = exports.StyleBuilders = exports.ASTBuilders = void 0;
+exports.createJSXSyntax = exports.createHTMLTemplateSyntax = exports.createBinaryExpression = exports.ParsedASTNode = exports.RouteUtils = exports.URLQueryWriter = exports.URLSearchParamSync = exports.HASTUtils = exports.StyleUtils = exports.ASTUtils = exports.HASTBuilders = exports.StyleBuilders = exports.ASTBuilders = void 0;
 var ASTBuilders = __importStar(require("./builders/ast-builders"));
 exports.ASTBuilders = ASTBuilders;
 var StyleBuilders = __importStar(require("./builders/style-builders"));
@@ -44,6 +44,8 @@ var HASTUtils = __importStar(require("./utils/hast-utils"));
 exports.HASTUtils = HASTUtils;
 var URLSearchParamSync = __importStar(require("./utils/url-search-param-sync"));
 exports.URLSearchParamSync = URLSearchParamSync;
+var URLQueryWriter = __importStar(require("./utils/url-query-writer"));
+exports.URLQueryWriter = URLQueryWriter;
 var RouteUtils = __importStar(require("./utils/route-utils"));
 exports.RouteUtils = RouteUtils;
 var parsed_ast_1 = __importDefault(require("./utils/parsed-ast"));

package/dist/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,mEAAsD;AAcpD,kCAAW;AAbb,uEAA0D;AAcxD,sCAAa;AAbf,qEAAwD;AActD,oCAAY;AAZd,0DAA6C;AAa3C,4BAAQ;AAZV,8DAAiD;AAa/C,gCAAU;AAZZ,4DAA+C;AAa7C,8BAAS;AAZX,gFAAmE;AAajE,gDAAkB;AAZpB,8DAAiD;AAa/C,gCAAU;AAZZ,kEAA8C;AAa5C,wBAbK,oBAAa,CAaL;AAXf,2DAA0E;AAYxE,uGAZO,8BAAsB,OAYP;AAGxB,6DAAkF;AAAzE,yIAAA,OAAO,OAA4B;AAC5C,2DAAwE;AAA/D,+HAAA,OAAO,OAAmB;AAEnC,qEAAkD;AAClD,oEAAiD"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,mEAAsD;AAepD,kCAAW;AAdb,uEAA0D;AAexD,sCAAa;AAdf,qEAAwD;AAetD,oCAAY;AAbd,0DAA6C;AAc3C,4BAAQ;AAbV,8DAAiD;AAc/C,gCAAU;AAbZ,4DAA+C;AAc7C,8BAAS;AAbX,gFAAmE;AAcjE,gDAAkB;AAbpB,uEAA0D;AAcxD,wCAAc;AAbhB,8DAAiD;AAc/C,gCAAU;AAbZ,kEAA8C;AAc5C,wBAdK,oBAAa,CAcL;AAZf,2DAA0E;AAaxE,uGAbO,8BAAsB,OAaP;AAGxB,6DAAkF;AAAzE,yIAAA,OAAO,OAA4B;AAC5C,2DAAwE;AAA/D,+HAAA,OAAO,OAAmB;AAEnC,qEAAkD;AAClD,oEAAiD"}

package/dist/cjs/node-handlers/node-to-jsx/index.js

@@ -779,14 +779,36 @@ var addAttributesToJSXTag = function (attrs, elementTag, options, params, elemen
                     params.globalReferences.push(normRef.content.id);
                     // Use the normalized ref to generate the attribute expression
                     var globalExpr = (0, utils_1.createDynamicValueExpression)(normRef, options);
-                    elementTag.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier((0, ast_utils_1.convertToReactAttributeName)(attrKey)), types.jsxExpressionContainer(globalExpr)));
+                    elementTag.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier((0, ast_utils_1.resolveAttributeNameForTag)(elementTag, attrKey)), types.jsxExpressionContainer(globalExpr)));
                     break;
                 }
                 if (referenceType === 'globalState') {
                     var gsName = (0, utils_1.resolveGlobalStateName)(dynamicRef.content.id, params.globalStateDefinitions);
                     params.globalStateReferences.push({ id: dynamicRef.content.id, name: gsName });
                     var expr = (0, utils_1.createGlobalStateExpression)(dynamicRef, params.globalStateDefinitions);
-                    elementTag.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier((0, ast_utils_1.convertToReactAttributeName)(attrKey)), types.jsxExpressionContainer(expr)));
+                    elementTag.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier((0, ast_utils_1.resolveAttributeNameForTag)(elementTag, attrKey)), types.jsxExpressionContainer(expr)));
+                    break;
+                }
+                // A translated attribute (`placeholder`, `alt`, `title`, `aria-label`, …).
+                // It cannot be emitted the way a translated CHILD is — that path produces a
+                // `<span>` the framework plugin fills through `dangerouslySetInnerHTML`, and
+                // an attribute needs a plain string. So the attribute is written with the
+                // main-language text (carried on the reference's `fallback`) and recorded on
+                // `params.localeAttributeReferences`; the target framework's i18n plugin
+                // rewrites the recorded attributes into its own translation lookup — see
+                // `createNextInternationalizationPlugin`. A framework without such a plugin
+                // keeps the main-language string, which is valid, readable markup.
+                if (referenceType === 'locale') {
+                    var translationKey = dynamicRef.content.id;
+                    if (!translationKey) {
+                        break;
+                    }
+                    // `fallback` only exists on the plain reference member of the union, and
+                    // narrowing happened on the destructured `referenceType`, not on the ref.
+                    var fallback = dynamicRef.content.fallback;
+                    var attribute = types.jsxAttribute(types.jsxIdentifier((0, ast_utils_1.resolveAttributeNameForTag)(elementTag, attrKey)), types.stringLiteral(teleport_shared_1.StringUtils.encode(fallback === undefined ? '' : String(fallback))));
+                    elementTag.openingElement.attributes.push(attribute);
+                    params.localeAttributeReferences.push({ attribute: attribute, key: translationKey });
                     break;
                 }
                 switch (referenceType) {
@@ -832,7 +854,7 @@ var addAttributesToJSXTag = function (attrs, elementTag, options, params, elemen
                     var constName = "__staticProp".concat(params.hoistedConstants.length);
                     var expression = (0, ast_utils_1.objectToObjectExpression)(attributeValue.content);
                     params.hoistedConstants.push({ name: constName, expression: expression });
-                    elementTag.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier((0, ast_utils_1.convertToReactAttributeName)(attrKey)), types.jsxExpressionContainer(types.identifier(constName))));
+                    elementTag.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier((0, ast_utils_1.resolveAttributeNameForTag)(elementTag, attrKey)), types.jsxExpressionContainer(types.identifier(constName))));
                 }
                 else {
                     (0, ast_utils_1.addAttributeToJSXTag)(elementTag, attrKey, attributeValue.content);