@teleporthq/teleport-plugin-next-data-source 0.43.54 → 0.43.57

package/__tests__/ecommerce-product-variant-availability.test.ts

@@ -0,0 +1,264 @@
+import { generateEcommerceProductTransformationCode } from '../src/transformations/ecommerce-product'
+import { generateSharedTransformationCode } from '../src/transformations/shared-utils'
+import { getTransformWrapperCode } from '../src/transformations'
+
+/**
+ * A product whose variant combinations are ALL out of stock — or whose axes have
+ * no combinations behind them at all — must reach the storefront saying so, in
+ * two ways the picker and the buy button read directly:
+ *
+ *   - every value carries `isDead: 'true'`, so the picker strikes them through;
+ *   - `hasPurchasableVariant: 'false'`, so the Add to Cart button is replaced by
+ *     the "select an available option" notice instead of adding a cart line with
+ *     no variant at all (`data-default-variant-id` is empty in that state).
+ *
+ * The hinge is knowing the difference between "we looked and there are none" and
+ * "we could not look": `options.variantsByProductId` is NULL for the latter, and
+ * a null must stay permissive — a missing table or a failed query must never
+ * make a whole catalogue unbuyable.
+ */
+
+const evalBuildProduct = (): ((r: unknown, o?: unknown) => Record<string, unknown>) => {
+  const code =
+    generateSharedTransformationCode() + '\n' + generateEcommerceProductTransformationCode()
+  return new Function(code + '\nreturn buildEcommerceProduct;')() as (
+    r: unknown,
+    o?: unknown
+  ) => Record<string, unknown>
+}
+
+type Axis = { key: string; values: Array<Record<string, unknown>> }
+
+const buildEcommerceProduct = evalBuildProduct()
+
+const SIZE_AXIS = JSON.stringify([
+  {
+    key: 'size',
+    name: 'Size',
+    type: 'text',
+    values: [
+      { value: 'xs', label: 'XS' },
+      { value: 's', label: 'S' },
+    ],
+  },
+])
+
+const variantProduct = (overrides: Record<string, unknown> = {}) => ({
+  id: 'p1',
+  name: 'Tee',
+  slug: 'tee',
+  price: 20,
+  currency: 'USD',
+  variant_options: SIZE_AXIS,
+  ...overrides,
+})
+
+const values = (product: Record<string, unknown>): Array<Record<string, unknown>> =>
+  (product.variantOptions as Axis[])[0].values
+
+describe('ecommerce product transform — variant availability', () => {
+  it('combinations UNKNOWN (no map at all): nothing dead, still purchasable', () => {
+    const product = buildEcommerceProduct(variantProduct())
+    expect(values(product).every((v) => v.isDead === 'false')).toBe(true)
+    expect(product.hasPurchasableVariant).toBe('true')
+  })
+
+  it('combinations UNKNOWN (the lookup failed → null map): unchanged', () => {
+    const product = buildEcommerceProduct(variantProduct(), { variantsByProductId: null })
+    expect(values(product).every((v) => v.isDead === 'false')).toBe(true)
+    expect(product.hasPurchasableVariant).toBe('true')
+  })
+
+  it('looked up and there are NO combinations: every value dead, not purchasable', () => {
+    const product = buildEcommerceProduct(variantProduct(), { variantsByProductId: {} })
+    expect(values(product).every((v) => v.isDead === 'true')).toBe(true)
+    expect(product.hasPurchasableVariant).toBe('false')
+    expect(product.defaultVariantId).toBe('')
+  })
+
+  it('every combination sold out: every value dead, not purchasable', () => {
+    const product = buildEcommerceProduct(variantProduct(), {
+      variantsByProductId: {
+        p1: [
+          { id: 'v-xs', options: { size: 'xs' }, quantity: 0 },
+          { id: 'v-s', options: { size: 's' }, quantity: 0 },
+        ],
+      },
+    })
+    expect(values(product).every((v) => v.isDead === 'true')).toBe(true)
+    expect(product.hasPurchasableVariant).toBe('false')
+    expect(product.defaultVariantId).toBe('')
+  })
+
+  it('one combination in stock: only the sold-out value is dead, and it is purchasable', () => {
+    const product = buildEcommerceProduct(variantProduct(), {
+      variantsByProductId: {
+        p1: [
+          { id: 'v-xs', options: { size: 'xs' }, quantity: 0 },
+          { id: 'v-s', options: { size: 's' }, quantity: 4 },
+        ],
+      },
+    })
+    expect(values(product)[0].isDead).toBe('true')
+    expect(values(product)[1].isDead).toBe('false')
+    expect(values(product)[1].isDefault).toBe('true')
+    expect(product.hasPurchasableVariant).toBe('true')
+    expect(product.defaultVariantId).toBe('v-s')
+  })
+
+  it('unlimited stock (null quantity) counts as in stock', () => {
+    const product = buildEcommerceProduct(variantProduct(), {
+      variantsByProductId: { p1: [{ id: 'v-xs', options: { size: 'xs' }, quantity: null }] },
+    })
+    expect(product.hasPurchasableVariant).toBe('true')
+    expect(values(product)[0].isDead).toBe('false')
+    // The value with no combination behind it is still dead.
+    expect(values(product)[1].isDead).toBe('true')
+  })
+
+  it('a FLAT product is always purchasable — outOfStock governs its stock', () => {
+    const flat = buildEcommerceProduct(
+      { id: 'f', name: 'Mug', slug: 'mug', price: 9, currency: 'USD', quantity: 0 },
+      { variantsByProductId: {} }
+    )
+    expect(flat.hasPurchasableVariant).toBe('true')
+    expect(flat.outOfStock).toBe('true')
+  })
+
+  it('always emits hasPurchasableVariant as a STRING (never boolean/undefined)', () => {
+    for (const options of [undefined, { variantsByProductId: null }, { variantsByProductId: {} }]) {
+      const product = buildEcommerceProduct(variantProduct(), options)
+      expect(typeof product.hasPurchasableVariant).toBe('string')
+      expect(['true', 'false']).toContain(product.hasPurchasableVariant)
+    }
+  })
+
+  it('a related product inherits the same known/unknown answer as its parent', () => {
+    const built = buildEcommerceProduct(variantProduct({ related_product_ids: '["p2"]' }), {
+      // Unknown for everybody — the nested build must NOT read this as "none".
+      variantsByProductId: null,
+      relatedProductsById: { p2: variantProduct({ id: 'p2', slug: 'p2' }) },
+    })
+    const related = (built.relatedProducts as Array<Record<string, unknown>>)[0]
+    expect(related.hasPurchasableVariant).toBe('true')
+  })
+})
+
+/**
+ * Runs the EMITTED `transformRecords` against a stub pg client, which is the only
+ * way to prove the wrapper's control flow — the order of the two lookups, and
+ * which ids reach the combinations query — rather than its text.
+ */
+describe('transform wrapper — executed end to end', () => {
+  interface StubQuery {
+    sql: string
+    params: unknown[]
+  }
+
+  const runWrapper = async (
+    records: Array<Record<string, unknown>>,
+    rows: {
+      related?: Array<Record<string, unknown>>
+      variants?: Array<Record<string, unknown>>
+      failVariantsQuery?: boolean
+    }
+  ): Promise<{ out: Array<Record<string, unknown>>; queries: StubQuery[] }> => {
+    const bundle =
+      generateSharedTransformationCode() +
+      '\n' +
+      generateEcommerceProductTransformationCode() +
+      '\n' +
+      getTransformWrapperCode('teleport_products')
+    const transformRecords = new Function(bundle + '\nreturn transformRecords;')() as (
+      r: unknown,
+      getClient: unknown,
+      q: unknown
+    ) => Promise<Array<Record<string, unknown>>>
+
+    const queries: StubQuery[] = []
+    const query = async (
+      sql: string,
+      params: unknown[] = []
+    ): Promise<{ rows: Array<Record<string, unknown>> }> => {
+      queries.push({ sql, params })
+      if (sql.includes('teleport_assets')) {
+        return { rows: [] }
+      }
+      if (sql.includes('teleport_product_variants')) {
+        if (rows.failVariantsQuery) {
+          throw new Error('relation "teleport_product_variants" does not exist')
+        }
+        return { rows: rows.variants || [] }
+      }
+      if (sql.includes('teleport_products')) {
+        return { rows: rows.related || [] }
+      }
+      return { rows: [] }
+    }
+    const getClientFn = () => ({
+      connect: async (): Promise<void> => undefined,
+      end: async (): Promise<void> => undefined,
+      query,
+    })
+
+    const out = await transformRecords(records, getClientFn, {})
+    return { out, queries }
+  }
+
+  const variantQueryOf = (queries: StubQuery[]): StubQuery | undefined =>
+    queries.find((q) => q.sql.includes('teleport_product_variants'))
+
+  it("asks for the RELATED products' combinations in the same batched query", async () => {
+    const { out, queries } = await runWrapper([variantProduct({ related_product_ids: '["p2"]' })], {
+      related: [variantProduct({ id: 'p2', slug: 'p2' })],
+      variants: [
+        { id: 'v-p1', product_id: 'p1', options: { size: 's' }, quantity: 5 },
+        { id: 'v-p2', product_id: 'p2', options: { size: 'xs' }, quantity: 2 },
+      ],
+    })
+    // Both the page's own product AND the related one.
+    expect(variantQueryOf(queries)?.params[0]).toEqual(['p1', 'p2'])
+
+    const related = (out[0].relatedProducts as Array<Record<string, unknown>>)[0]
+    expect(related.hasPurchasableVariant).toBe('true')
+    expect(related.defaultVariantId).toBe('v-p2')
+  })
+
+  it('a FAILED combinations query leaves every product permissive, not unbuyable', async () => {
+    const { out, queries } = await runWrapper([variantProduct()], { failVariantsQuery: true })
+    expect(variantQueryOf(queries)).toBeTruthy()
+    expect(out[0].hasPurchasableVariant).toBe('true')
+    expect(values(out[0]).every((v) => v.isDead === 'false')).toBe(true)
+  })
+
+  it('a query that RAN and returned nothing marks the product unbuyable', async () => {
+    const { out } = await runWrapper([variantProduct()], { variants: [] })
+    expect(out[0].hasPurchasableVariant).toBe('false')
+    expect(values(out[0]).every((v) => v.isDead === 'true')).toBe(true)
+  })
+})
+
+describe('transform wrapper — the batched combinations query', () => {
+  const wrapper = getTransformWrapperCode('teleport_products')
+
+  it('starts the map at NULL so a failed lookup reads as unknown, not as none', () => {
+    expect(wrapper).toContain('var variantsByProductId = null')
+  })
+
+  it('resolves related items BEFORE variants, and asks for their combinations too', () => {
+    // The details page draws each related product as a real card with its own
+    // picker; fetching only the page's own ids left every one of them looking
+    // like a product with no combinations.
+    expect(wrapper.indexOf('relatedProductsById = await')).toBeGreaterThan(-1)
+    expect(wrapper.indexOf('relatedProductsById = await')).toBeLessThan(
+      wrapper.indexOf('getVariantsMap(')
+    )
+    expect(wrapper).toContain('__variantPids.push(__rrow.id)')
+  })
+
+  it('leaves the blog wrapper without any variant enrichment', () => {
+    const blog = getTransformWrapperCode('teleport_blog_posts')
+    expect(blog).not.toContain('getVariantsMap')
+    expect(blog).toContain('relatedPostsById')
+  })
+})

package/dist/cjs/cache/ast.d.ts

@@ -0,0 +1,71 @@
+import * as types from '@babel/types';
+import { UIDLDependency } from '@teleporthq/teleport-types';
+import { ResolvedDataSourceCache } from './types';
+/** Identifiers the emitted page imports from `utils/tq-cache/client`. */
+export declare const CACHE_CLIENT_IMPORTS: string[];
+export declare const cachedValueVarFor: (index: number) => string;
+/**
+ * Registers the client runtime's named imports on the page.
+ *
+ * Each identifier is its own dependency entry because that is how the
+ * import-statements plugin keys them; they share one path, so they collapse
+ * into a single `import { … } from '…/utils/tq-cache/client'`.
+ */
+export declare const registerCacheClientImports: (dependencies: Record<string, UIDLDependency>, folderPath: string[] | undefined) => void;
+/**
+ * The terminal `.then` of a cached fetch: record the version the server
+ * answered with (which purges the scope if it moved) and store the rows.
+ *
+ * `tqCacheSet` returns the value it was given, so the promise still resolves to
+ * exactly what the uncached chain resolved to — `response?.data`.
+ */
+export declare const buildCacheStoreThen: (cache: ResolvedDataSourceCache) => types.ArrowFunctionExpression;
+/** Wraps a network chain in the peek preamble, producing the cached body. */
+export declare const buildCachedFetchBody: (networkChain: types.Expression, cache: ResolvedDataSourceCache) => types.BlockStatement;
+/**
+ * Finds the `return <fetch(...)…>` statement inside a cached `fetchData` body.
+ *
+ * Shared with `loading-state` so both modules agree on what "the network chain"
+ * means: the body also contains an early `return Promise.resolve(hit)`, and
+ * attaching in-flight bookkeeping to THAT would flip the loading flag on every
+ * cache hit — the exact flash this feature exists to remove.
+ */
+export declare const findCachedFetchNetworkChain: (body: types.BlockStatement) => {
+    statement: types.ReturnStatement;
+    index: number;
+} | undefined;
+/**
+ * Hoists a cached provider's `params` into a component const and adds the
+ * synchronous cache peek beside it.
+ *
+ * The peek is what removes the loading flash on a page or search change: those
+ * change the provider's `key`, so it REMOUNTS with `data: undefined` and paints
+ * `renderLoading()` before any promise — even an already-resolved one — can
+ * resume. Feeding a hit into `initialData` makes the provider skip its first
+ * fetch entirely and paint the cached rows on the very first frame.
+ *
+ * `sticky` is set because this value is handed to a mounted provider: once it
+ * has been, TTL expiry must not flip it back to `undefined`, or the list would
+ * blank out without refetching (its `params` never changed).
+ *
+ * Reference identity comes from the runtime's own map, not from this `useMemo`
+ * — the memo only keeps the peek from re-running on unrelated renders.
+ */
+export declare const buildCachedParamsDeclarations: (params: {
+    index: number;
+    paramsMemo: types.Expression;
+    cache: ResolvedDataSourceCache;
+}) => {
+    declarations: types.Statement[];
+    paramsIdentifier: string;
+    cachedIdentifier: string;
+};
+/**
+ * `useEffect(() => { tqMarkHydrated(); tqCacheRevalidate([...]) }, [])`
+ *
+ * One effect per page, covering every scope on it in a single request. Flipping
+ * the hydration latch here rather than at import time is what keeps the first
+ * client render byte-identical to the server render.
+ */
+export declare const buildCacheHydrationEffect: (scopes: string[]) => types.Statement;
+//# sourceMappingURL=ast.d.ts.map

package/dist/cjs/cache/ast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.d.ts","sourceRoot":"","sources":["../../../src/cache/ast.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAC3D,OAAO,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAA;AAEjD,yEAAyE;AACzE,eAAO,MAAM,oBAAoB,UAOhC,CAAA;AAMD,eAAO,MAAM,iBAAiB,UAAW,MAAM,KAAG,MAA8B,CAAA;AAEhF;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,iBACvB,OAAO,MAAM,EAAE,cAAc,CAAC,cAChC,MAAM,EAAE,GAAG,SAAS,KAC/B,IAaF,CAAA;AAyCD;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,UACvB,uBAAuB,KAC7B,MAAM,uBAkCR,CAAA;AAED,6EAA6E;AAC7E,eAAO,MAAM,oBAAoB,iBACjB,MAAM,UAAU,SACvB,uBAAuB,KAC7B,MAAM,cAIL,CAAA;AAEJ;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,SAChC,MAAM,cAAc,KACzB;IAAE,SAAS,EAAE,MAAM,eAAe,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,SAcxD,CAAA;AAkBD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,6BAA6B,WAAY;IACpD,KAAK,EAAE,MAAM,CAAA;IACb,UAAU,EAAE,MAAM,UAAU,CAAA;IAC5B,KAAK,EAAE,uBAAuB,CAAA;CAC/B;kBACe,MAAM,SAAS,EAAE;sBACb,MAAM;sBACN,MAAM;CAkCzB,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,WAAY,MAAM,EAAE,KAAG,MAAM,SAgBhE,CAAA"}

package/dist/cjs/cache/ast.js

@@ -0,0 +1,229 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCacheHydrationEffect = exports.buildCachedParamsDeclarations = exports.findCachedFetchNetworkChain = exports.buildCachedFetchBody = exports.buildCacheStoreThen = exports.registerCacheClientImports = exports.cachedValueVarFor = exports.CACHE_CLIENT_IMPORTS = void 0;
+var types = __importStar(require("@babel/types"));
+/** Identifiers the emitted page imports from `utils/tq-cache/client`. */
+exports.CACHE_CLIENT_IMPORTS = [
+    'tqCacheKey',
+    'tqCacheGet',
+    'tqCacheSet',
+    'tqCacheSetVersion',
+    'tqMarkHydrated',
+    'tqCacheRevalidate',
+];
+/** Local identifiers used inside the generated `fetchData` body. */
+var KEY_VAR = '__tqKey';
+var HIT_VAR = '__tqHit';
+var cachedValueVarFor = function (index) { return "ds_".concat(index, "_cached"); };
+exports.cachedValueVarFor = cachedValueVarFor;
+/**
+ * Registers the client runtime's named imports on the page.
+ *
+ * Each identifier is its own dependency entry because that is how the
+ * import-statements plugin keys them; they share one path, so they collapse
+ * into a single `import { … } from '…/utils/tq-cache/client'`.
+ */
+var registerCacheClientImports = function (dependencies, folderPath) {
+    var depth = (folderPath ? folderPath.length : 0) + 1;
+    var path = "".concat('../'.repeat(depth), "utils/tq-cache/client");
+    exports.CACHE_CLIENT_IMPORTS.forEach(function (identifier) {
+        if (!dependencies[identifier]) {
+            dependencies[identifier] = {
+                type: 'local',
+                path: path,
+                meta: { namedImport: true },
+            };
+        }
+    });
+};
+exports.registerCacheClientImports = registerCacheClientImports;
+/**
+ * `const __tqKey = tqCacheKey(params)` +
+ * `const __tqHit = tqCacheGet(SCOPE, __tqKey)` +
+ * `if (__tqHit !== undefined) return Promise.resolve(__tqHit)`
+ *
+ * The early return is what keeps a hit from ever touching the network — and,
+ * just as importantly, from raising the in-flight flag that would paint the
+ * loading slot. `loading-state` deliberately attaches its bookkeeping to the
+ * network chain BELOW this, never to the `Promise.resolve`.
+ */
+var buildCachePeekPreamble = function (scope) { return [
+    types.variableDeclaration('const', [
+        types.variableDeclarator(types.identifier(KEY_VAR), types.callExpression(types.identifier('tqCacheKey'), [types.identifier('params')])),
+    ]),
+    types.variableDeclaration('const', [
+        types.variableDeclarator(types.identifier(HIT_VAR), types.callExpression(types.identifier('tqCacheGet'), [
+            types.stringLiteral(scope),
+            types.identifier(KEY_VAR),
+        ])),
+    ]),
+    types.ifStatement(types.binaryExpression('!==', types.identifier(HIT_VAR), types.identifier('undefined')), types.blockStatement([
+        types.returnStatement(types.callExpression(types.memberExpression(types.identifier('Promise'), types.identifier('resolve')), [types.identifier(HIT_VAR)])),
+    ])),
+]; };
+/**
+ * The terminal `.then` of a cached fetch: record the version the server
+ * answered with (which purges the scope if it moved) and store the rows.
+ *
+ * `tqCacheSet` returns the value it was given, so the promise still resolves to
+ * exactly what the uncached chain resolved to — `response?.data`.
+ */
+var buildCacheStoreThen = function (cache) {
+    var responseData = types.optionalMemberExpression(types.identifier('response'), types.identifier('data'), false, true);
+    var responseVersion = types.optionalMemberExpression(types.identifier('response'), types.identifier('version'), false, true);
+    return types.arrowFunctionExpression([types.identifier('response')], types.blockStatement([
+        types.expressionStatement(types.callExpression(types.identifier('tqCacheSetVersion'), [
+            types.stringLiteral(cache.scope),
+            types.cloneNode(responseVersion, true),
+        ])),
+        types.returnStatement(types.callExpression(types.identifier('tqCacheSet'), [
+            types.stringLiteral(cache.scope),
+            types.identifier(KEY_VAR),
+            responseData,
+            types.numericLiteral(cache.ttlSeconds),
+            types.cloneNode(responseVersion, true),
+        ])),
+    ]));
+};
+exports.buildCacheStoreThen = buildCacheStoreThen;
+/** Wraps a network chain in the peek preamble, producing the cached body. */
+var buildCachedFetchBody = function (networkChain, cache) {
+    return types.blockStatement(__spreadArray(__spreadArray([], buildCachePeekPreamble(cache.scope), true), [
+        types.returnStatement(networkChain),
+    ], false));
+};
+exports.buildCachedFetchBody = buildCachedFetchBody;
+/**
+ * Finds the `return <fetch(...)…>` statement inside a cached `fetchData` body.
+ *
+ * Shared with `loading-state` so both modules agree on what "the network chain"
+ * means: the body also contains an early `return Promise.resolve(hit)`, and
+ * attaching in-flight bookkeeping to THAT would flip the loading flag on every
+ * cache hit — the exact flash this feature exists to remove.
+ */
+var findCachedFetchNetworkChain = function (body) {
+    for (var index = body.body.length - 1; index >= 0; index--) {
+        var statement = body.body[index];
+        if (statement.type !== 'ReturnStatement' || !statement.argument) {
+            continue;
+        }
+        if (statement.argument.type === 'CallExpression' &&
+            callChainStartsWithFetch(statement.argument)) {
+            return { statement: statement, index: index };
+        }
+    }
+    return undefined;
+};
+exports.findCachedFetchNetworkChain = findCachedFetchNetworkChain;
+var callChainStartsWithFetch = function (expression) {
+    var current = expression;
+    while (current.type === 'CallExpression') {
+        var callee = current.callee;
+        if (callee.type === 'Identifier' && callee.name === 'fetch') {
+            return true;
+        }
+        if (callee.type === 'MemberExpression') {
+            current = callee.object;
+            continue;
+        }
+        return false;
+    }
+    return false;
+};
+/**
+ * Hoists a cached provider's `params` into a component const and adds the
+ * synchronous cache peek beside it.
+ *
+ * The peek is what removes the loading flash on a page or search change: those
+ * change the provider's `key`, so it REMOUNTS with `data: undefined` and paints
+ * `renderLoading()` before any promise — even an already-resolved one — can
+ * resume. Feeding a hit into `initialData` makes the provider skip its first
+ * fetch entirely and paint the cached rows on the very first frame.
+ *
+ * `sticky` is set because this value is handed to a mounted provider: once it
+ * has been, TTL expiry must not flip it back to `undefined`, or the list would
+ * blank out without refetching (its `params` never changed).
+ *
+ * Reference identity comes from the runtime's own map, not from this `useMemo`
+ * — the memo only keeps the peek from re-running on unrelated renders.
+ */
+var buildCachedParamsDeclarations = function (params) {
+    var paramsIdentifier = "ds_".concat(params.index, "_params");
+    var cachedIdentifier = (0, exports.cachedValueVarFor)(params.index);
+    return {
+        paramsIdentifier: paramsIdentifier,
+        cachedIdentifier: cachedIdentifier,
+        declarations: [
+            types.variableDeclaration('const', [
+                types.variableDeclarator(types.identifier(paramsIdentifier), params.paramsMemo),
+            ]),
+            types.variableDeclaration('const', [
+                types.variableDeclarator(types.identifier(cachedIdentifier), types.callExpression(types.identifier('useMemo'), [
+                    types.arrowFunctionExpression([], types.callExpression(types.identifier('tqCacheGet'), [
+                        types.stringLiteral(params.cache.scope),
+                        types.callExpression(types.identifier('tqCacheKey'), [
+                            types.identifier(paramsIdentifier),
+                        ]),
+                        types.objectExpression([
+                            types.objectProperty(types.identifier('sticky'), types.booleanLiteral(true)),
+                        ]),
+                    ])),
+                    types.arrayExpression([types.identifier(paramsIdentifier)]),
+                ])),
+            ]),
+        ],
+    };
+};
+exports.buildCachedParamsDeclarations = buildCachedParamsDeclarations;
+/**
+ * `useEffect(() => { tqMarkHydrated(); tqCacheRevalidate([...]) }, [])`
+ *
+ * One effect per page, covering every scope on it in a single request. Flipping
+ * the hydration latch here rather than at import time is what keeps the first
+ * client render byte-identical to the server render.
+ */
+var buildCacheHydrationEffect = function (scopes) {
+    return types.expressionStatement(types.callExpression(types.identifier('useEffect'), [
+        types.arrowFunctionExpression([], types.blockStatement([
+            types.expressionStatement(types.callExpression(types.identifier('tqMarkHydrated'), [])),
+            types.expressionStatement(types.callExpression(types.identifier('tqCacheRevalidate'), [
+                types.arrayExpression(scopes.map(function (scope) { return types.stringLiteral(scope); })),
+            ])),
+        ])),
+        types.arrayExpression([]),
+    ]));
+};
+exports.buildCacheHydrationEffect = buildCacheHydrationEffect;
+//# sourceMappingURL=ast.js.map

package/dist/cjs/cache/ast.js.map

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

package/dist/cjs/cache/config.d.ts

@@ -0,0 +1,22 @@
+import { UIDLDataCacheConfig } from '@teleporthq/teleport-types';
+import { DataSourceServerCacheOptions, ResolvedDataSourceCache } from './types';
+/**
+ * Reads the `cache` block off a `cms-list-repeater`.
+ *
+ * Returns `undefined` — meaning "emit exactly what this generator emitted
+ * before caching existed" — for anything that is off, incomplete, or caches
+ * into neither layer.
+ */
+export declare const resolveCacheFromRepeaterContent: (cache: UIDLDataCacheConfig | undefined, resourceDefinition: {
+    dataSourceId?: string;
+    tableName?: string;
+} | undefined) => ResolvedDataSourceCache | undefined;
+/**
+ * Folds several mappers' requests for the same generated file into one.
+ *
+ * Enabled if ANY mapper wants it, but with the SHORTEST requested TTL and the
+ * shortest shared-cache window — a mapper that asked for fresher data must
+ * never be made staler by a sibling that asked for less.
+ */
+export declare const mergeServerCacheOptions: (entries: DataSourceServerCacheOptions[]) => DataSourceServerCacheOptions | undefined;
+//# sourceMappingURL=config.d.ts.map

package/dist/cjs/cache/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/cache/config.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAA;AAChE,OAAO,EAAE,4BAA4B,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAA;AAE/E;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B,UACnC,mBAAmB,GAAG,SAAS,sBAClB;IAAE,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,KAC5E,uBAAuB,GAAG,SAoC5B,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,YACzB,4BAA4B,EAAE,KACtC,4BAA4B,GAAG,SAiBjC,CAAA"}