@teleporthq/teleport-plugin-next-data-source 0.43.55 → 0.43.59

package/__tests__/ecommerce-product-allow-backorders.test.ts

@@ -0,0 +1,156 @@
+import { generateEcommerceProductTransformationCode } from '../src/transformations/ecommerce-product'
+import { generateSharedTransformationCode } from '../src/transformations/shared-utils'
+import { buildProductTransformOptions } from '../src/transformations'
+
+/**
+ * With backorders allowed (or stock management disabled) the merchant sells
+ * past zero, so NOTHING in the storefront may present a product or a variant
+ * combination as sold out:
+ *
+ *   - `outOfStock` stays 'false' even at quantity <= 0;
+ *   - a zero-stock combination is NOT dead, IS default-selectable, and keeps
+ *     `hasPurchasableVariant: 'true'` / a non-empty `defaultVariantId`;
+ *   - a combination that does not exist at all is STILL unavailable — there
+ *     is no variant row to backorder.
+ *
+ * The flag is baked at export time via
+ * `EcommerceProductTransformOptions.allowBackorders`, resolved in ONE place
+ * (`buildProductTransformOptions`) as: stock management off OR
+ * `stockManagementConfig.allowBackorders` on.
+ */
+
+const evalBuildProduct = (
+  allowBackorders: boolean
+): ((r: unknown, o?: unknown) => Record<string, unknown>) => {
+  const code =
+    generateSharedTransformationCode() +
+    '\n' +
+    generateEcommerceProductTransformationCode({ allowBackorders })
+  return new Function(code + '\nreturn buildEcommerceProduct;')() as (
+    r: unknown,
+    o?: unknown
+  ) => Record<string, unknown>
+}
+
+type Axis = { key: string; values: Array<Record<string, unknown>> }
+
+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 — allowBackorders', () => {
+  const withBackorders = evalBuildProduct(true)
+  const withoutBackorders = evalBuildProduct(false)
+
+  it('a zero-quantity FLAT product is never out of stock with backorders', () => {
+    const record = { id: 'f', name: 'Mug', slug: 'mug', price: 9, currency: 'USD', quantity: 0 }
+    expect(withBackorders(record).outOfStock).toBe('false')
+    expect(withoutBackorders(record).outOfStock).toBe('true')
+  })
+
+  it('a NEGATIVE quantity (already oversold) is still not out of stock', () => {
+    const record = { id: 'f', name: 'Mug', slug: 'mug', price: 9, currency: 'USD', quantity: -3 }
+    expect(withBackorders(record).outOfStock).toBe('false')
+  })
+
+  it('every combination sold out: values stay alive and purchasable with backorders', () => {
+    const options = {
+      variantsByProductId: {
+        p1: [
+          { id: 'v-xs', options: { size: 'xs' }, quantity: 0 },
+          { id: 'v-s', options: { size: 's' }, quantity: 0 },
+        ],
+      },
+    }
+    const product = withBackorders(variantProduct(), options)
+    expect(values(product).every((v) => v.isDead === 'false')).toBe(true)
+    expect(product.hasPurchasableVariant).toBe('true')
+    // The first covering combination becomes the default selection again.
+    expect(product.defaultVariantId).toBe('v-xs')
+
+    // The strict build keeps its sold-out answer (regression guard for the
+    // flag's default).
+    const strict = withoutBackorders(variantProduct(), options)
+    expect(strict.hasPurchasableVariant).toBe('false')
+    expect(strict.defaultVariantId).toBe('')
+  })
+
+  it('a value with NO combination behind it stays dead even with backorders', () => {
+    const product = withBackorders(variantProduct(), {
+      variantsByProductId: { p1: [{ id: 'v-xs', options: { size: 'xs' }, quantity: 0 }] },
+    })
+    expect(values(product)[0].isDead).toBe('false')
+    // 's' has no variant row — nothing exists to backorder.
+    expect(values(product)[1].isDead).toBe('true')
+  })
+
+  it('looked up and there are NO combinations at all: still not purchasable', () => {
+    const product = withBackorders(variantProduct(), { variantsByProductId: {} })
+    expect(values(product).every((v) => v.isDead === 'true')).toBe(true)
+    expect(product.hasPurchasableVariant).toBe('false')
+  })
+
+  it('omitting the option keeps the strict pre-flag behaviour', () => {
+    const code =
+      generateSharedTransformationCode() + '\n' + generateEcommerceProductTransformationCode()
+    const build = new Function(code + '\nreturn buildEcommerceProduct;')() as (
+      r: unknown
+    ) => Record<string, unknown>
+    expect(
+      build({ id: 'f', name: 'Mug', slug: 'mug', price: 9, currency: 'USD', quantity: 0 })
+        .outOfStock
+    ).toBe('true')
+  })
+})
+
+describe('buildProductTransformOptions — allowBackorders resolution', () => {
+  const settings = (stockManagement: boolean, allowBackorders?: boolean) =>
+    ({
+      stockManagement,
+      stockManagementConfig:
+        allowBackorders === undefined ? null : { allowBackorders, lowStockThreshold: 5 },
+    } as never)
+
+  it('stock management ON + backorders ON → true', () => {
+    expect(
+      buildProductTransformOptions({ ecommerceSettings: settings(true, true) }).allowBackorders
+    ).toBe(true)
+  })
+
+  it('stock management ON + backorders OFF → false', () => {
+    expect(
+      buildProductTransformOptions({ ecommerceSettings: settings(true, false) }).allowBackorders
+    ).toBe(false)
+  })
+
+  it('stock management OFF → true regardless of the config block', () => {
+    expect(
+      buildProductTransformOptions({ ecommerceSettings: settings(false) }).allowBackorders
+    ).toBe(true)
+  })
+
+  it('no e-commerce settings at all → false (strict default)', () => {
+    expect(buildProductTransformOptions({}).allowBackorders).toBe(false)
+  })
+})

package/__tests__/ecommerce-product-model.test.ts

@@ -0,0 +1,179 @@
+import { generateEcommerceProductTransformationCode } from '../src/transformations/ecommerce-product'
+import { generateSharedTransformationCode } from '../src/transformations/shared-utils'
+
+// A product's optional 3D model. The transform must hand the storefront
+// resolved URLs, STRING gates ('true' / 'false' — the builders compare with
+// `=`/`!=`, so an absent field reads as the IMAGE branch), and the gallery as
+// media entries in display order. MUST stay in sync with the renderer mirror
+// (packages/renderer/src/utils/ecommerce-products.ts) and the GUI's
+// `PRODUCT_PROP_DEFAULT` — see the GUI-side specs.
+
+type Product = Record<string, unknown> & {
+  galleryMedia: Array<{ kind: string; src: string; poster: string; thumbnail: string; alt: string }>
+  galleryThumbnails: Array<{ kind: string; src: string }>
+}
+
+const evalBuildProduct = (): ((record: unknown, options?: unknown) => Product) => {
+  const code =
+    generateSharedTransformationCode() + '\n' + generateEcommerceProductTransformationCode()
+  const fn = new Function(code + '\nreturn buildEcommerceProduct;')
+  return fn() as (record: unknown, options?: unknown) => Product
+}
+
+const ASSET_MAP = {
+  TQ_model: { remoteSrc: 'https://storage.example.com/p/model.glb' },
+  TQ_poster: { remoteSrc: 'https://cdn.example.com/poster.png' },
+  TQ_img1: { remoteSrc: 'https://cdn.example.com/img1.jpg' },
+  TQ_img2: { remoteSrc: 'https://cdn.example.com/img2.jpg' },
+}
+
+const baseRecord = {
+  id: 'p1',
+  name: 'Chair',
+  slug: 'chair',
+  price: '10',
+  currency: 'USD',
+  image_url: 'TQ_img1',
+  gallery_images: JSON.stringify(['TQ_img2']),
+}
+
+describe('ecommerce product transform — 3D model', () => {
+  const buildEcommerceProduct = evalBuildProduct()
+  const build = (record: Record<string, unknown>) =>
+    buildEcommerceProduct(record, { assetMap: ASSET_MAP })
+
+  it('emits the image branch for a product without a model', () => {
+    const product = build(baseRecord)
+    expect(product.modelUrl).toBeNull()
+    expect(product.modelPoster).toBeNull()
+    expect(product.hasModel).toBe('false')
+    expect(product.showModel).toBe('false')
+    expect(product.galleryMedia.map((m) => m.kind)).toEqual(['image', 'image'])
+    expect(product.galleryThumbnails.map((m) => m.src)).toEqual([ASSET_MAP.TQ_img2.remoteSrc])
+  })
+
+  it('resolves the model and poster asset ids to URLs and shows the model by default', () => {
+    const product = build({ ...baseRecord, model_url: 'TQ_model', model_poster_url: 'TQ_poster' })
+    expect(product.modelUrl).toBe(ASSET_MAP.TQ_model.remoteSrc)
+    expect(product.modelPoster).toBe(ASSET_MAP.TQ_poster.remoteSrc)
+    expect(product.hasModel).toBe('true')
+    // NULL / absent flag = ON
+    expect(product.showModel).toBe('true')
+    // hero first, then the images
+    expect(product.galleryMedia.map((m) => m.kind)).toEqual(['model', 'image', 'image'])
+    expect(product.galleryMedia[0]).toEqual({
+      kind: 'model',
+      src: ASSET_MAP.TQ_model.remoteSrc,
+      poster: ASSET_MAP.TQ_poster.remoteSrc,
+      thumbnail: ASSET_MAP.TQ_poster.remoteSrc,
+      alt: 'Chair',
+    })
+    // the main image moves into the strip when the model is the hero
+    expect(product.galleryThumbnails.map((m) => m.src)).toEqual([
+      ASSET_MAP.TQ_img1.remoteSrc,
+      ASSET_MAP.TQ_img2.remoteSrc,
+    ])
+  })
+
+  it('keeps the image hero when the merchant switched the model off, with the model last', () => {
+    const product = build({
+      ...baseRecord,
+      model_url: 'TQ_model',
+      model_poster_url: 'TQ_poster',
+      show_model_by_default: false,
+    })
+    expect(product.hasModel).toBe('true')
+    expect(product.showModel).toBe('false')
+    expect(product.galleryMedia.map((m) => m.kind)).toEqual(['image', 'image', 'model'])
+    expect(product.galleryThumbnails.map((m) => m.kind)).toEqual(['image', 'model'])
+    expect(product.galleryThumbnails[1].src).toBe(ASSET_MAP.TQ_model.remoteSrc)
+  })
+
+  it.each([
+    [true, 'true'],
+    [false, 'false'],
+    [1, 'true'],
+    [0, 'false'],
+    ['true', 'true'],
+    ['false', 'false'],
+    ['t', 'true'],
+    ['f', 'false'],
+    ['1', 'true'],
+    ['0', 'false'],
+    [null, 'true'],
+    [undefined, 'true'],
+    ['', 'true'],
+  ])('normalizes show_model_by_default = %p to showModel %s', (raw, expected) => {
+    const product = build({ ...baseRecord, model_url: 'TQ_model', show_model_by_default: raw })
+    expect(product.showModel).toBe(expected)
+  })
+
+  it('always shows the model when it is the only media, whatever the flag says', () => {
+    const product = build({
+      id: 'p2',
+      name: 'Lamp',
+      slug: 'lamp',
+      price: '5',
+      currency: 'USD',
+      model_url: 'TQ_model',
+      show_model_by_default: false,
+    })
+    expect(product.showModel).toBe('true')
+    expect(product.galleryMedia).toHaveLength(1)
+    expect(product.galleryThumbnails).toEqual([])
+    // nothing to poster with — the viewer paints its transparent poster
+    expect(product.modelPoster).toBeNull()
+  })
+
+  it('falls back to the main image as poster and thumbnail when the model has none', () => {
+    const product = build({ ...baseRecord, model_url: 'TQ_model', show_model_by_default: false })
+    expect(product.modelPoster).toBe(ASSET_MAP.TQ_img1.remoteSrc)
+    const modelEntry = product.galleryMedia.find((m) => m.kind === 'model')
+    expect(modelEntry?.poster).toBe(ASSET_MAP.TQ_img1.remoteSrc)
+    expect(modelEntry?.thumbnail).toBe(ASSET_MAP.TQ_img1.remoteSrc)
+  })
+
+  it('treats an asset id the asset map cannot resolve as no model at all', () => {
+    // resolveAssetUrl returns unknown ids verbatim; a bare 'TQ_…' must never
+    // reach <model-viewer src>.
+    const product = build({ ...baseRecord, model_url: 'TQ_deleted', model_poster_url: 'TQ_gone' })
+    expect(product.modelUrl).toBeNull()
+    expect(product.hasModel).toBe('false')
+    expect(product.showModel).toBe('false')
+    expect(product.galleryMedia.map((m) => m.kind)).toEqual(['image', 'image'])
+  })
+
+  it('drops a stale poster id but keeps the model', () => {
+    const product = build({ ...baseRecord, model_url: 'TQ_model', model_poster_url: 'TQ_gone' })
+    expect(product.modelUrl).toBe(ASSET_MAP.TQ_model.remoteSrc)
+    expect(product.modelPoster).toBe(ASSET_MAP.TQ_img1.remoteSrc)
+  })
+
+  it('accepts raw URLs in the model columns', () => {
+    const product = build({
+      ...baseRecord,
+      model_url: 'https://cdn.example.com/raw.glb',
+      model_poster_url: '/local/poster.png',
+    })
+    expect(product.modelUrl).toBe('https://cdn.example.com/raw.glb')
+    expect(product.modelPoster).toBe('/local/poster.png')
+  })
+
+  it('carries the model fields into related products', () => {
+    const related = { ...baseRecord, id: 'p9', slug: 'chair-9', model_url: 'TQ_model' }
+    const product = buildEcommerceProduct(
+      { ...baseRecord, related_product_ids: JSON.stringify(['p9']) },
+      { assetMap: ASSET_MAP, relatedProductsById: { p9: related } }
+    )
+    const relatedProducts = product.relatedProducts as Product[]
+    expect(relatedProducts).toHaveLength(1)
+    expect(relatedProducts[0].showModel).toBe('true')
+    expect(relatedProducts[0].modelUrl).toBe(ASSET_MAP.TQ_model.remoteSrc)
+  })
+
+  it('uses the image alt for pictures and the product name for the model', () => {
+    const product = build({ ...baseRecord, image_alt: 'A chair', model_url: 'TQ_model' })
+    expect(product.galleryMedia[0].alt).toBe('Chair')
+    expect(product.galleryMedia[1].alt).toBe('A chair')
+  })
+})

package/__tests__/ecommerce-product-storefront-tax.test.ts

@@ -0,0 +1,118 @@
+import { generateEcommerceProductTransformationCode } from '../src/transformations/ecommerce-product'
+import { generateSharedTransformationCode } from '../src/transformations/shared-utils'
+import { buildProductTransformOptions } from '../src/transformations'
+import type { UIDLInvoiceSettings } from '@teleporthq/teleport-types'
+
+// The storefront quotes tax-inclusive prices when the merchant picked
+// "Added on top", but `teleport_products.price` stays NET — it is what the
+// merchant typed, what the admin panel edits, and what the invoice route
+// re-derives VAT from. The transform therefore emits SEPARATE display fields
+// and must never move `price` itself.
+
+const evalBuildProduct = (
+  storefrontTaxRate: number
+): ((record: unknown) => Record<string, unknown>) => {
+  const code =
+    generateSharedTransformationCode() +
+    '\n' +
+    generateEcommerceProductTransformationCode({ storefrontTaxRate })
+  const fn = new Function(code + '\nreturn buildEcommerceProduct;')
+  return fn() as (record: unknown) => Record<string, unknown>
+}
+
+const FLAT_PRODUCT = { id: 'p1', name: 'P', slug: 'p', price: '19.99', currency: 'USD' }
+
+const invoiceSettings = (over: Partial<UIDLInvoiceSettings>): UIDLInvoiceSettings =>
+  ({ defaultTaxRate: 0, taxIncludedInPrice: false, ...over } as UIDLInvoiceSettings)
+
+describe('ecommerce product transform — storefront tax display fields', () => {
+  it('leaves `price` NET and adds a gross `displayPrice`', () => {
+    const product = evalBuildProduct(19)(FLAT_PRODUCT)
+    expect(product.price).toBe(19.99)
+    expect(product.displayPrice).toBe('23.79')
+  })
+
+  it('is a formatting-only no-op at rate 0 — the number is untouched', () => {
+    const product = evalBuildProduct(0)(FLAT_PRODUCT)
+    expect(product.price).toBe(19.99)
+    expect(product.displayPrice).toBe('19.99')
+  })
+
+  it('always emits two decimals, so a trailing-zero price never renders as "19.9"', () => {
+    const product = evalBuildProduct(0)({ ...FLAT_PRODUCT, price: '19.90' })
+    expect(product.displayPrice).toBe('19.90')
+  })
+
+  it('rounds per UNIT, so unit x quantity equals the line total the cart prints', () => {
+    const product = evalBuildProduct(19)(FLAT_PRODUCT)
+    expect(Number(product.displayPrice) * 3).toBeCloseTo(71.37, 5)
+  })
+
+  it('grosses the default variant price and the picker JSON, leaving their net twins alone', () => {
+    const record = {
+      ...FLAT_PRODUCT,
+      variant_options: JSON.stringify([
+        { key: 'size', name: 'Size', type: 'text', values: [{ value: 's', label: 'S' }] },
+      ]),
+    }
+    const withVariants = new Function(
+      generateSharedTransformationCode() +
+        '\n' +
+        generateEcommerceProductTransformationCode({ storefrontTaxRate: 19 }) +
+        '\nreturn buildEcommerceProduct;'
+    )() as (r: unknown, o: unknown) => Record<string, unknown>
+
+    const product = withVariants(record, {
+      variantsByProductId: {
+        // `price: null` INHERITS the product price — the gross copy has to
+        // resolve the inheritance before taxing, or an inheriting combination
+        // would show the net base price beside an overriding gross one.
+        p1: [
+          { id: 'v1', options: { size: 's' }, price: null, quantity: 5 },
+          { id: 'v2', options: { size: 'm' }, price: '30.00', quantity: 5 },
+        ],
+      },
+    })
+
+    expect(product.defaultVariantPrice).toBe('19.99')
+    expect(product.defaultVariantDisplayPrice).toBe('23.79')
+
+    const net = JSON.parse(String(product.variantsJson))
+    const gross = JSON.parse(String(product.variantsDisplayJson))
+    expect(net[0].price).toBeNull()
+    expect(net[1].price).toBe(30)
+    expect(gross[0].price).toBe(23.79)
+    expect(gross[1].price).toBe(35.7)
+    // Everything except the price rides through untouched — the picker resolves
+    // the selected combination by id and gates on quantity.
+    expect(gross[0].id).toBe('v1')
+    expect(gross[0].options).toEqual({ size: 's' })
+    expect(gross[0].quantity).toBe(5)
+  })
+
+  it('tolerates a missing / unparseable price', () => {
+    const build = evalBuildProduct(19)
+    expect(build({ id: 'x', name: 'X', slug: 'x' }).displayPrice).toBe('0.00')
+    expect(build({ id: 'x', name: 'X', slug: 'x', price: 'abc' }).displayPrice).toBe('0.00')
+  })
+})
+
+describe('buildProductTransformOptions', () => {
+  it('resolves the rate from the invoice settings and carries the taxonomy through', () => {
+    const options = buildProductTransformOptions({
+      ecommerceSettings: { categories: [{ id: 'c1', name: 'C', slug: 'c' }] } as never,
+      invoiceSettings: invoiceSettings({ defaultTaxRate: 21 }),
+    })
+    expect(options.storefrontTaxRate).toBe(21)
+    expect(options.categories).toHaveLength(1)
+  })
+
+  it('is 0 for tax-inclusive pricing and for a store with no invoice settings at all', () => {
+    expect(
+      buildProductTransformOptions({
+        invoiceSettings: invoiceSettings({ defaultTaxRate: 19, taxIncludedInPrice: true }),
+      }).storefrontTaxRate
+    ).toBe(0)
+    expect(buildProductTransformOptions({}).storefrontTaxRate).toBe(0)
+  })
+})

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