@akinon/pz-theme 2.0.157 → 2.0.158-rc.14

package/CHANGELOG.md

@@ -1,10 +1,54 @@
 # @akinon/pz-theme
 
+## 2.0.158-rc.14
+
+### Patch Changes
+
+- 8e040731: ZERO-5235: let brands hang actions on order detail lines
+- c761b9fd: ZERO-5296: fall back to the storefront default language in the text block
+- 17a598da: ZERO-5296: report the storefront default language to the editor
+- 3b05a407: ZERO-5232: allow richtext settings on custom blocks
+- ad5240c4: ZERO-5254: add custom render and theme editor support to pz-rate-review
+- Updated dependencies [86187b1c2]
+- Updated dependencies [0cf9ea239]
+- Updated dependencies [97d29893]
+- Updated dependencies [324f97d55]
+- Updated dependencies [51ea06888]
+- Updated dependencies
+- Updated dependencies [2fea41430]
+- Updated dependencies [b55acb768]
+- Updated dependencies [760258c1c]
+- Updated dependencies [143be2b9d]
+- Updated dependencies [7889b08fe]
+- Updated dependencies [9f8cd3bc5]
+- Updated dependencies [bfafa3f49]
+- Updated dependencies [ac6cada1]
+- Updated dependencies [57d7eb305]
+- Updated dependencies [d99a6a7d5]
+- Updated dependencies [9db81a714]
+- Updated dependencies [591e345e1]
+- Updated dependencies [4de5303c5]
+- Updated dependencies [95b139dc1]
+- Updated dependencies [1d00f2d06]
+- Updated dependencies [4ac7b2a1e]
+- Updated dependencies [4998a9631]
+- Updated dependencies [804d2bd6c]
+- Updated dependencies [3909d3224]
+- Updated dependencies [6a3d8a631]
+- Updated dependencies [e18836b20]
+- Updated dependencies [b1111d7b1]
+- Updated dependencies [1595d458e]
+- Updated dependencies [dca128112]
+  - @akinon/next@2.0.158-rc.14
+  - @akinon/theme-contract@2.0.158-rc.14
+
 ## 2.0.157
 
 ### Patch Changes
 
+- 3002c2cc: ZERO-5302: The order detail's return and cancel links offer what commerce allows and what a storefront's order-action rules let through (`registerOrderActionRules`: which lines a return may start from, whether an order may be cancelled). With no rules registered, commerce's `is_refundable` and `is_cancellable` flags decide; the block no longer limits returns to delivered lines on its own.
 - Updated dependencies [219164a3]
+- Updated dependencies [9c778307]
   - @akinon/next@2.0.157
   - @akinon/theme-contract@2.0.157
 

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "@akinon/pz-theme",
   "description": "Theme package for Project Zero Next — ThemePlaceholder system and theme editor infrastructure",
-  "version": "2.0.157",
+  "version": "2.0.158-rc.14",
   "license": "MIT",
   "main": "src/index.ts",
   "scripts": {
     "test": "jest"
   },
   "peerDependencies": {
-    "@akinon/next": "2.0.157",
+    "@akinon/next": "2.0.158-rc.14",
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0"
   },
   "dependencies": {
-    "@akinon/theme-contract": "2.0.157",
+    "@akinon/theme-contract": "2.0.158-rc.14",
     "clsx": "2.1.1",
     "lottie-web": "^5.13.0",
     "react-multi-carousel": "2.8.4",
@@ -21,7 +21,7 @@
     "zod": "4.4.1"
   },
   "devDependencies": {
-    "@akinon/next": "2.0.157",
+    "@akinon/next": "2.0.158-rc.14",
     "@testing-library/jest-dom": "5.16.4",
     "@testing-library/react": "16.3.2",
     "@testing-library/user-event": "14.1.1",

package/src/__tests__/editor-locale-bridge.test.tsx

@@ -28,6 +28,7 @@ const SETTINGS_LOCALES = [
 const mockLocalization = {
   locale: 'tr',
   locales: SETTINGS_LOCALES as Array<Record<string, unknown>>,
+  defaultLocaleValue: 'tr',
   setLocale: jest.fn()
 };
 
@@ -106,6 +107,7 @@ beforeEach(() => {
   postMessage.mockClear();
   mockLocalization.locale = 'tr';
   mockLocalization.locales = SETTINGS_LOCALES;
+  mockLocalization.defaultLocaleValue = 'tr';
   mockLocalization.setLocale = jest.fn();
   delete (window as { __iframeReadySent?: boolean }).__iframeReadySent;
 });
@@ -144,7 +146,8 @@ describe('inside the editor', () => {
             { value: 'en', label: 'English' },
             { value: 'tr', label: 'Türkçe' },
             { value: 'de', label: 'de' }
-          ]
+          ],
+          defaultLocale: 'tr'
         }
       })
     ]);
@@ -154,6 +157,34 @@ describe('inside the editor', () => {
     expect(targetOrigin).toBe(EDITOR_ORIGIN);
   });
 
+  it('posts the languages before the document reports ready', () => {
+    // The editor holds every per-language write until IFRAME_READY and takes
+    // "ready without languages" to mean they are never coming, so the order
+    // of the two frames is part of the contract.
+    render(placeholder('header'));
+
+    const types = postMessage.mock.calls.map(([message]) => message?.type);
+    expect(types).toContain('LOCALE_UPDATE');
+    expect(types).toContain('IFRAME_READY');
+    expect(types.indexOf('LOCALE_UPDATE')).toBeLessThan(
+      types.indexOf('IFRAME_READY')
+    );
+  });
+
+  it("posts the brand's default language, whichever it is", () => {
+    // The editor's per-language text controls take the plain-string form to
+    // mean this language; left to guess, the editor assumed English.
+    mockLocalization.defaultLocaleValue = 'de';
+
+    render(<EditorLocaleBridge />);
+
+    expect(localeFrames()).toEqual([
+      expect.objectContaining({
+        data: expect.objectContaining({ locale: 'tr', defaultLocale: 'de' })
+      })
+    ]);
+  });
+
   it("follows the editor's switch exactly once, with several placeholders mounted", () => {
     render(
       <>

package/src/__tests__/row-scope.test.tsx

@@ -0,0 +1,118 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import { ItemTemplateList } from '../blocks/item-template';
+import { useThemeProduct } from '../blocks/product-block-utils';
+import { useThemeRowScope } from '../blocks/row-scope';
+import blockRendererRegistry from '../blocks/block-renderer-registry';
+import { resetCustomCatalog } from '../custom/catalog';
+import { resetCustomCollection } from '../custom/collect';
+import { isCustomThemeType, registerCustomBlocks } from '../custom';
+import type { Block } from '../theme-block';
+
+const READER = 'custom:acme:row-reader';
+
+function RowReader() {
+  const scope = useThemeRowScope();
+  const product = useThemeProduct();
+
+  return (
+    <span
+      data-testid="reader"
+      data-list={scope?.listType ?? ''}
+      data-index={scope?.index ?? ''}
+      data-number={String(scope?.row.number ?? '')}
+      data-product={String(product?.pk ?? '')}
+    />
+  );
+}
+
+const template = (): Block =>
+  ({
+    id: 'tpl',
+    type: 'group',
+    label: 'Row',
+    order: 0,
+    hidden: false,
+    value: '',
+    properties: { role: { desktop: 'item-template' } },
+    styles: {},
+    blocks: [
+      {
+        id: 'tpl-reader',
+        type: READER,
+        label: 'Reader',
+        order: 0,
+        hidden: false,
+        value: '',
+        properties: {},
+        styles: {},
+        blocks: []
+      }
+    ]
+  } as Block);
+
+const list = (type: string): Block =>
+  ({
+    id: 'list',
+    type,
+    label: 'List',
+    order: 0,
+    hidden: false,
+    value: '',
+    properties: {},
+    styles: {},
+    blocks: [template()]
+  } as Block);
+
+const renderRows = (type: string, items: Record<string, unknown>[]) =>
+  render(
+    <ItemTemplateList
+      block={list(type)}
+      items={items}
+      placeholderId="p1"
+      sectionId="s1"
+    />
+  );
+
+beforeAll(() => {
+  registerCustomBlocks('acme', { 'row-reader': RowReader });
+});
+
+afterAll(() => {
+  const map = (
+    blockRendererRegistry as unknown as { renderers: Map<string, unknown> }
+  ).renderers;
+  Array.from(map.keys())
+    .filter(isCustomThemeType)
+    .forEach((key) => map.delete(key));
+  resetCustomCatalog();
+  resetCustomCollection();
+});
+
+describe('the row scope', () => {
+  it('hands every repeated row to the blocks inside it, on any list', () => {
+    renderRows('order-list', [{ number: 'ORD-1' }, { number: 'ORD-2' }]);
+
+    const readers = screen.getAllByTestId('reader');
+    expect(readers).toHaveLength(2);
+    expect(readers[0]).toHaveAttribute('data-list', 'order-list');
+    expect(readers[0]).toHaveAttribute('data-index', '0');
+    expect(readers[0]).toHaveAttribute('data-number', 'ORD-1');
+    expect(readers[1]).toHaveAttribute('data-number', 'ORD-2');
+    expect(readers[0]).toHaveAttribute('data-product', '');
+  });
+
+  it('keeps the product scope on product lists next to the row scope', () => {
+    renderRows('product-grid', [{ pk: 7, name: 'Sneaker' }]);
+
+    const reader = screen.getByTestId('reader');
+    expect(reader).toHaveAttribute('data-list', 'product-grid');
+    expect(reader).toHaveAttribute('data-product', '7');
+  });
+
+  it('is closed outside a repeated row', () => {
+    render(<RowReader />);
+
+    expect(screen.getByTestId('reader')).toHaveAttribute('data-list', '');
+  });
+});

package/src/blocks/__tests__/order-detail-return.test.tsx

@@ -1,6 +1,10 @@
 import React from 'react';
 import { render } from '@testing-library/react';
 import OrderDetailBlock from '../order-detail-block';
+import {
+  __resetOrderActionRulesForTests,
+  registerOrderActionRules
+} from '../../utils/order-action-rules';
 
 /**
  * ZERO-5183 — the order detail is where an easy return starts and where a
@@ -64,6 +68,8 @@ const texts = (root: ParentNode, part: string) =>
     (e.textContent || '').replace(/\s+/g, ' ').trim()
   );
 
+afterEach(() => __resetOrderActionRulesForTests());
+
 beforeEach(() => {
   order = {
     id: 42,
@@ -164,7 +170,7 @@ describe('order detail — easy returns', () => {
     expect(container.querySelector('[data-part="return-link"]')).toBeNull();
   });
 
-  it('links only a delivered line that has no request yet', () => {
+  it('links a refundable line that has no request yet', () => {
     // As commerce answers after a return: the order and its lines stay
     // refundable while the request is open.
     const flagged: Record<string, unknown>[] = (
@@ -194,15 +200,74 @@ describe('order detail — easy returns', () => {
     };
     expect(returnLink()).toBeNull();
 
-    // Commerce calls a shipped line refundable too; it is not returned yet.
+    // Commerce calls a shipped line refundable too, and with no rule from
+    // the brand that is what decides (ZERO-5302).
     order = {
       ...order,
       orderitem_set: flagged.map((item) =>
-        item.id === 3
-          ? { ...item, status: { value: '500', label: 'Gönderildi' } }
-          : item
+        item.id === 3 ? { ...item, status: { value: '500' } } : item
       )
     };
+    expect(returnLink()).not.toBeNull();
+  });
+
+  it("asks the brand's rules about a line commerce lets go back (ZERO-5302)", () => {
+    const asked: string[] = [];
+    registerOrderActionRules({
+      returnLine: (item) => {
+        asked.push(String(item.status?.value));
+        return item.status?.value === '550';
+      }
+    });
+    const returnLink = () =>
+      render(
+        <OrderDetailBlock
+          block={blockOf(ALL_ON) as never}
+          placeholderId="p1"
+          sectionId="s1"
+          isDesigner={false}
+        />
+      ).container.querySelector('[data-part="return-link"]');
+    const withLine3 = (status: string) => ({
+      ...order,
+      orderitem_set: (order?.orderitem_set as Record<string, unknown>[]).map(
+        (item) =>
+          item.id === 3
+            ? { ...item, is_refundable: true, status: { value: status } }
+            : { ...item, is_refundable: false }
+      )
+    });
+
+    order = withLine3('550');
+    expect(returnLink()).not.toBeNull();
+
+    order = withLine3('500');
     expect(returnLink()).toBeNull();
+    // Only the line commerce lets go back is put to the brand.
+    expect(new Set(asked)).toEqual(new Set(['550', '500']));
+  });
+
+  it('withholds the cancel link when the brand switches cancellation off (ZERO-5302)', () => {
+    order = { ...order, is_cancellable: true };
+    const cancelLink = () =>
+      render(
+        <OrderDetailBlock
+          block={
+            blockOf({
+              ...ALL_ON,
+              showCancelLink: { desktop: true },
+              cancelLinkLabel: { desktop: 'Cancel' }
+            }) as never
+          }
+          placeholderId="p1"
+          sectionId="s1"
+          isDesigner={false}
+        />
+      ).container.querySelector('[data-part="cancel-link"]');
+
+    expect(cancelLink()).not.toBeNull();
+
+    registerOrderActionRules({ cancelOrder: () => false });
+    expect(cancelLink()).toBeNull();
   });
 });

package/src/blocks/__tests__/order-line-actions.test.tsx

@@ -0,0 +1,54 @@
+import React from 'react';
+import {
+  registerOrderLineActions,
+  renderOrderLineActions
+} from '../order-line-actions';
+
+const context = {
+  order: { id: 7, number: '20920397829', created_date: '2026-10-01' },
+  line: {
+    key: '1',
+    name: 'Product',
+    image: '',
+    href: '',
+    price: '100',
+    total: 100,
+    quantity: 1,
+    item: { id: 1, status: { value: '550', label: 'Delivered' } }
+  },
+  isDesigner: false
+};
+
+describe('order line actions registry', () => {
+  it('renders nothing until a brand registers', () => {
+    expect(renderOrderLineActions(context)).toBeNull();
+  });
+
+  it('hands the line and order to the registered renderer', () => {
+    const renderer = jest.fn(() => <span>action</span>);
+    const unregister = registerOrderLineActions(renderer);
+
+    expect(renderOrderLineActions(context)).toEqual(<span>action</span>);
+    expect(renderer).toHaveBeenCalledWith(context);
+
+    unregister();
+    expect(renderOrderLineActions(context)).toBeNull();
+  });
+
+  it('swallows a throwing renderer so a brand bug cannot break the line', () => {
+    const unregister = registerOrderLineActions(() => {
+      throw new Error('boom');
+    });
+
+    expect(renderOrderLineActions(context)).toBeNull();
+    unregister();
+  });
+
+  it('only forgets the renderer it was asked to forget', () => {
+    const first = registerOrderLineActions(() => 'first');
+    registerOrderLineActions(() => 'second');
+
+    first();
+    expect(renderOrderLineActions(context)).toBe('second');
+  });
+});

package/src/blocks/__tests__/order-list-rows.test.tsx

@@ -0,0 +1,112 @@
+import React from 'react';
+import { render } from '@testing-library/react';
+import OrderListBlock from '../order-list-block';
+
+const captured: { items: Record<string, unknown>[] } = { items: [] };
+
+jest.mock('../item-template', () => ({
+  __esModule: true,
+  hasItemTemplate: () => true,
+  ItemTemplateList: ({ items }: { items: Record<string, unknown>[] }) => {
+    captured.items = items;
+    return <div data-testid="item-template-list" />;
+  }
+}));
+
+jest.mock('next-auth/react', () => ({
+  useSession: () => ({ data: null, status: 'authenticated' })
+}));
+
+jest.mock('@akinon/next/hooks', () => ({
+  __esModule: true,
+  useLocalization: () => ({ locale: 'tr', currency: 'try' })
+}));
+
+jest.mock('@akinon/next/redux/hooks', () => ({
+  __esModule: true,
+  useAppSelector: () => undefined,
+  useAppDispatch: () => jest.fn()
+}));
+
+jest.mock('@akinon/next/data/client/account', () => ({
+  __esModule: true,
+  useGetOrdersQuery: () => ({
+    data: {
+      count: 1,
+      results: [
+        {
+          id: 42,
+          number: 'ORD-42',
+          amount: '100.00',
+          created_date: '2026-09-01T10:00:00Z',
+          status: { value: '550', label: 'Delivered' },
+          orderitem_set: [
+            {
+              id: 7,
+              status: { value: 550, label: 'Delivered' },
+              product: {
+                sku: 'SKU-1',
+                base_code: 'BASE-1',
+                name: 'Sneaker',
+                image: '/s.jpg'
+              }
+            },
+            {
+              status: { value: '400', label: 'Approved' },
+              product: { name: 'Boot' }
+            }
+          ]
+        }
+      ]
+    },
+    isLoading: false
+  })
+}));
+
+describe('order list rows', () => {
+  it('publishes the order items with their product codes and status code', () => {
+    render(
+      <OrderListBlock
+        block={{
+          id: 'order-list-1',
+          type: 'order-list',
+          properties: {},
+          styles: {},
+          blocks: []
+        }}
+        placeholderId="p1"
+        sectionId="s1"
+      />
+    );
+
+    expect(captured.items).toHaveLength(1);
+    expect(captured.items[0]).toMatchObject({
+      id: 42,
+      number: 'ORD-42',
+      createdDate: '2026-09-01T10:00:00Z'
+    });
+    expect(captured.items[0].items).toEqual([
+      {
+        id: 7,
+        name: 'Sneaker',
+        image: '/s.jpg',
+        status: 'Delivered',
+        statusValue: '550',
+        product: {
+          sku: 'SKU-1',
+          base_code: 'BASE-1',
+          name: 'Sneaker',
+          image: '/s.jpg'
+        }
+      },
+      {
+        id: 1,
+        name: 'Boot',
+        image: '',
+        status: 'Approved',
+        statusValue: '400',
+        product: { sku: '', base_code: '', name: 'Boot', image: '' }
+      }
+    ]);
+  });
+});

package/src/blocks/__tests__/text-block.test.tsx

@@ -2,9 +2,31 @@ import React from 'react';
 import { render } from '@testing-library/react';
 import TextBlock from '../text-block';
 
-// The mocked useLocalization (jest/__mocks__/akinon-next-hooks.js) returns
-// locale: 'en-us'. process.env.NEXT_PUBLIC_DEFAULT_LOCALE is unset in the
-// jest env, so the component's defaultLocale falls back to 'en'.
+// The page's language and the storefront's default, as the localization
+// provider reports them. Most cases run on an English-default store showing
+// English; the fallback case moves both.
+const mockLocalization = { locale: 'en-us', defaultLocaleValue: 'en-us' };
+
+jest.mock('@akinon/next/hooks', () => ({
+  __esModule: true,
+  useLocalization: () => ({
+    t: (path: string) => path,
+    setLocale: () => {},
+    setCurrency: () => {},
+    locale: mockLocalization.locale,
+    currency: 'USD',
+    locales: [{ value: 'en-us' }, { value: 'tr-tr' }],
+    currencies: ['USD'],
+    defaultLocaleValue: mockLocalization.defaultLocaleValue,
+    defaultCurrencyCode: 'USD',
+    localeUrlStrategy: 'hide-default-locale'
+  })
+}));
+
+beforeEach(() => {
+  mockLocalization.locale = 'en-us';
+  mockLocalization.defaultLocaleValue = 'en-us';
+});
 
 const renderBlock = (value: unknown, styles?: Record<string, unknown>) => {
   const block: any = { id: 'b1', type: 'text', value, styles };
@@ -34,10 +56,16 @@ describe('TextBlock value-shape resolution', () => {
     );
   });
 
-  it('falls back to defaultLocale ("en") when active locale is absent', () => {
-    const { container } = renderBlock({ en: 'EN', fr: 'FR' });
+  it("falls back to the storefront's default language when the active one is absent", () => {
+    // A Turkish-default store showing German. The entry under `en` is what
+    // the block used to show: its default was read from an env variable
+    // that falls back to English, not from the storefront (ZERO-5296).
+    mockLocalization.locale = 'de-de';
+    mockLocalization.defaultLocaleValue = 'tr-tr';
+
+    const { container } = renderBlock({ en: 'EN', 'tr-tr': 'TR' });
     expect((container.querySelector('div') as HTMLDivElement).innerHTML).toBe(
-      'EN'
+      'TR'
     );
   });
 

package/src/blocks/item-template.tsx

@@ -15,6 +15,7 @@ import {
   resolveItemProduct
 } from './item-template-utils';
 import { ThemeItemScopeProvider } from './product-block-utils';
+import { ThemeRowScopeProvider } from './row-scope';
 
 export {
   findItemTemplate,
@@ -120,20 +121,15 @@ export const ItemTemplateList = ({
   const scopesProducts = publishesProductItems(block.type);
   // The same slice the iterator applied, so clone N is handed the row it
   // was built from rather than row N.
-  const scopedRows = scopesProducts
-    ? sliceIteratorItems(block, rows).items
-    : rows;
+  const slicedRows = sliceIteratorItems(block, rows).items;
 
   return (
     <>
       {clones.map((clone, index) => {
         const key = clone.id || `${template.id}-item-${index}`;
+        const rowData = slicedRows[index] ?? {};
         const row = (
           <ThemeBlock
-            // Keyed here so the non-scoped branch is the element it always
-            // was: wrapping it in anything, even a fragment, would change the
-            // element type at this position and remount every existing row.
-            key={key}
             block={clone}
             placeholderId={placeholderId}
             sectionId={sectionId}
@@ -143,22 +139,32 @@ export const ItemTemplateList = ({
             currentBreakpoint={currentBreakpoint}
           />
         );
+        const scoped = scopesProducts
+          ? resolveItemProduct(block.type, rowData)
+          : null;
 
-        if (!scopesProducts) return row;
-
-        const scoped = resolveItemProduct(block.type, scopedRows[index]);
-
-        // Context only — the provider renders no element, so the markup a
-        // published row produces is unchanged.
+        // Context only — the providers render no element, so the markup a
+        // published row produces is unchanged. Every list opens the row
+        // scope; only product lists open the product scope on top of it.
         return (
-          <ThemeItemScopeProvider
+          <ThemeRowScopeProvider
             key={key}
-            product={
-              scoped ?? (isDesigner ? DESIGNER_SAMPLE_PRODUCT : null)
-            }
+            listType={block.type}
+            row={rowData}
+            index={index}
           >
-            {row}
-          </ThemeItemScopeProvider>
+            {scopesProducts ? (
+              <ThemeItemScopeProvider
+                product={
+                  scoped ?? (isDesigner ? DESIGNER_SAMPLE_PRODUCT : null)
+                }
+              >
+                {row}
+              </ThemeItemScopeProvider>
+            ) : (
+              row
+            )}
+          </ThemeRowScopeProvider>
         );
       })}
     </>