@vtex/faststore 0.0.7 → 0.0.10

package/dist/sdk/navigation/route-map-provider.d.ts

@@ -0,0 +1,19 @@
+import { RouteMap } from "./types.js";
+import { ReactNode } from "react";
+//#region src/sdk/navigation/route-map-provider.d.ts
+/** The generated resolver's `toLogicalPath`: the path under a binding's base path. */
+export type ToLogicalPath = (entry: {
+  basePath: string;
+}, pathname: string) => string;
+export type RouteMapProviderProps = Readonly<{
+  routeMap: RouteMap;
+  toLogicalPath: ToLogicalPath;
+  children: ReactNode;
+}>;
+/**
+ * Publishes the generated route map and `toLogicalPath` to the Client tree. `toLogicalPath` is a prop
+ * because the SDK cannot import the generated resolver and must not reimplement the prefix rule.
+ */
+export declare function RouteMapProvider({ routeMap, toLogicalPath, children }: RouteMapProviderProps): import("react/jsx-runtime").JSX.Element;
+//#endregion
+//# sourceMappingURL=route-map-provider.d.ts.map

package/dist/sdk/navigation/route-map-provider.js

@@ -0,0 +1,29 @@
+"use client";
+import { createContext, useContext, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/sdk/navigation/route-map-provider.tsx
+const Context = createContext(null);
+/**
+* Publishes the generated route map and `toLogicalPath` to the Client tree. `toLogicalPath` is a prop
+* because the SDK cannot import the generated resolver and must not reimplement the prefix rule.
+*/
+function RouteMapProvider({ routeMap, toLogicalPath, children }) {
+	const value = useMemo(() => ({
+		routeMap,
+		toLogicalPath
+	}), [routeMap, toLogicalPath]);
+	return /* @__PURE__ */ jsx(Context.Provider, {
+		value,
+		children
+	});
+}
+/** The route map and `toLogicalPath`. Throws outside a `RouteMapProvider`. */
+function useRouteMap() {
+	const value = useContext(Context);
+	if (!value) throw new Error("useRouteMap: no route map in this tree. Render under a `RouteMapProvider` that receives `routeMap` and `toLogicalPath` — the generated `src/app/providers.tsx` mounts it.");
+	return value;
+}
+//#endregion
+export { RouteMapProvider, useRouteMap };
+
+//# sourceMappingURL=route-map-provider.js.map

package/dist/sdk/navigation/route-map-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-map-provider.js","names":[],"sources":["../../../src/sdk/navigation/route-map-provider.tsx"],"sourcesContent":["'use client';\n\nimport { createContext, type ReactNode, useContext, useMemo } from 'react';\nimport type { RouteMap } from './types.js';\n\n/** The generated resolver's `toLogicalPath`: the path under a binding's base path. */\nexport type ToLogicalPath = (entry: { basePath: string }, pathname: string) => string;\n\nexport type RouteMapProviderProps = Readonly<{\n  routeMap: RouteMap;\n  toLogicalPath: ToLogicalPath;\n  children: ReactNode;\n}>;\n\ntype RouteMapValue = { routeMap: RouteMap; toLogicalPath: ToLogicalPath };\n\nconst Context = createContext<RouteMapValue | null>(null);\n\n/**\n * Publishes the generated route map and `toLogicalPath` to the Client tree. `toLogicalPath` is a prop\n * because the SDK cannot import the generated resolver and must not reimplement the prefix rule.\n */\nexport function RouteMapProvider({ routeMap, toLogicalPath, children }: RouteMapProviderProps) {\n  const value = useMemo(() => ({ routeMap, toLogicalPath }), [routeMap, toLogicalPath]);\n  return <Context.Provider value={value}>{children}</Context.Provider>;\n}\n\n/** The route map and `toLogicalPath`. Throws outside a `RouteMapProvider`. */\nexport function useRouteMap(): RouteMapValue {\n  const value = useContext(Context);\n  if (!value) {\n    throw new Error(\n      'useRouteMap: no route map in this tree. Render under a `RouteMapProvider` that receives ' +\n        '`routeMap` and `toLogicalPath` — the generated `src/app/providers.tsx` mounts it.',\n    );\n  }\n  return value;\n}\n"],"mappings":";;;;AAgBA,MAAM,UAAU,cAAoC,IAAI;;;;;AAMxD,SAAgB,iBAAiB,EAAE,UAAU,eAAe,YAAmC;CAC7F,MAAM,QAAQ,eAAe;EAAE;EAAU;CAAc,IAAI,CAAC,UAAU,aAAa,CAAC;CACpF,OAAO,oBAAC,QAAQ,UAAT;EAAyB;EAAQ;CAA2B,CAAA;AACrE;;AAGA,SAAgB,cAA6B;CAC3C,MAAM,QAAQ,WAAW,OAAO;CAChC,IAAI,CAAC,OACH,MAAM,IAAI,MACR,2KAEF;CAEF,OAAO;AACT"}

package/dist/sdk/navigation/storefront-link.d.ts

@@ -0,0 +1,16 @@
+import { PageRef } from "./types.js";
+import { ComponentProps } from "react";
+import Link from "next/link";
+//#region src/sdk/navigation/storefront-link.d.ts
+export type StorefrontLinkProps = Omit<ComponentProps<typeof Link>, 'href'> & {
+  /** A page reference or a logical path, resolved for the current binding. */
+  href: PageRef | string;
+};
+/**
+ * `next/link` resolved through the binding. A target that does not resolve renders a `<span>` that
+ * keeps the class, `aria-*` and `data-fs-*` props, so the composing component's hooks still style it.
+ * An absolute URL renders a plain anchor, because it may cross bindings.
+ */
+export declare function StorefrontLink({ href, children, ...props }: StorefrontLinkProps): import("react/jsx-runtime").JSX.Element;
+//#endregion
+//# sourceMappingURL=storefront-link.d.ts.map

package/dist/sdk/navigation/storefront-link.js

@@ -0,0 +1,66 @@
+"use client";
+import { isClientHref, useStorefrontNavigation } from "./use-storefront-navigation.js";
+import { jsx } from "react/jsx-runtime";
+import Link from "next/link";
+//#region src/sdk/navigation/storefront-link.tsx
+/** Props `next/link` reads and a plain anchor must not receive. */
+const LINK_ONLY_PROPS = [
+	"replace",
+	"scroll",
+	"prefetch",
+	"onNavigate",
+	"shallow",
+	"passHref",
+	"legacyBehavior",
+	"locale",
+	"as",
+	"transitionTypes"
+];
+const LINK_ONLY_PROP_NAMES = new Set(LINK_ONLY_PROPS);
+/** What a `<span>` standing in for an unresolved link must not receive: the anchor's own attributes. */
+const NOT_ON_SPAN_PROP_NAMES = /* @__PURE__ */ new Set([
+	...LINK_ONLY_PROPS,
+	"ref",
+	"target",
+	"rel",
+	"download",
+	"hrefLang",
+	"ping",
+	"referrerPolicy",
+	"type",
+	"media"
+]);
+function withoutProps(props, names) {
+	return Object.fromEntries(Object.entries(props).filter(([key]) => !names.has(key)));
+}
+function withoutLinkOnlyProps(props) {
+	return withoutProps(props, LINK_ONLY_PROP_NAMES);
+}
+/**
+* `next/link` resolved through the binding. A target that does not resolve renders a `<span>` that
+* keeps the class, `aria-*` and `data-fs-*` props, so the composing component's hooks still style it.
+* An absolute URL renders a plain anchor, because it may cross bindings.
+*/
+function StorefrontLink({ href, children, ...props }) {
+	const { hrefFor } = useStorefrontNavigation();
+	const resolved = hrefFor(href);
+	if (resolved === null) return /* @__PURE__ */ jsx("span", {
+		...withoutProps(props, NOT_ON_SPAN_PROP_NAMES),
+		"data-fs-link-unresolved": "",
+		children
+	});
+	if (isClientHref(resolved)) return /* @__PURE__ */ jsx(Link, {
+		...props,
+		href: resolved,
+		children
+	});
+	return /* @__PURE__ */ jsx("a", {
+		...withoutLinkOnlyProps(props),
+		href: resolved,
+		children
+	});
+}
+//#endregion
+export { StorefrontLink };
+
+//# sourceMappingURL=storefront-link.js.map

package/dist/sdk/navigation/storefront-link.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storefront-link.js","names":[],"sources":["../../../src/sdk/navigation/storefront-link.tsx"],"sourcesContent":["'use client';\n\nimport Link from 'next/link';\nimport type { ComponentProps } from 'react';\nimport type { PageRef } from './types.js';\nimport { isClientHref, useStorefrontNavigation } from './use-storefront-navigation.js';\n\nexport type StorefrontLinkProps = Omit<ComponentProps<typeof Link>, 'href'> & {\n  /** A page reference or a logical path, resolved for the current binding. */\n  href: PageRef | string;\n};\n\ntype LinkOnlyProp = (typeof LINK_ONLY_PROPS)[number];\n\n/** Props `next/link` reads and a plain anchor must not receive. */\nconst LINK_ONLY_PROPS = [\n  'replace',\n  'scroll',\n  'prefetch',\n  'onNavigate',\n  'shallow',\n  'passHref',\n  'legacyBehavior',\n  'locale',\n  'as',\n  'transitionTypes',\n] as const;\n\nconst LINK_ONLY_PROP_NAMES: ReadonlySet<string> = new Set(LINK_ONLY_PROPS);\n\n/** What a `<span>` standing in for an unresolved link must not receive: the anchor's own attributes. */\nconst NOT_ON_SPAN_PROP_NAMES: ReadonlySet<string> = new Set([\n  ...LINK_ONLY_PROPS,\n  'ref',\n  'target',\n  'rel',\n  'download',\n  'hrefLang',\n  'ping',\n  'referrerPolicy',\n  'type',\n  'media',\n]);\n\nfunction withoutProps<T extends object>(props: T, names: ReadonlySet<string>): Partial<T> {\n  return Object.fromEntries(Object.entries(props).filter(([key]) => !names.has(key))) as Partial<T>;\n}\n\nfunction withoutLinkOnlyProps<T extends object>(props: T): Omit<T, LinkOnlyProp> {\n  return withoutProps(props, LINK_ONLY_PROP_NAMES) as Omit<T, LinkOnlyProp>;\n}\n\n/**\n * `next/link` resolved through the binding. A target that does not resolve renders a `<span>` that\n * keeps the class, `aria-*` and `data-fs-*` props, so the composing component's hooks still style it.\n * An absolute URL renders a plain anchor, because it may cross bindings.\n */\nexport function StorefrontLink({ href, children, ...props }: StorefrontLinkProps) {\n  const { hrefFor } = useStorefrontNavigation();\n  const resolved = hrefFor(href);\n\n  if (resolved === null) {\n    return (\n      <span {...(withoutProps(props, NOT_ON_SPAN_PROP_NAMES) as ComponentProps<'span'>)} data-fs-link-unresolved=\"\">\n        {children}\n      </span>\n    );\n  }\n\n  if (isClientHref(resolved)) {\n    return (\n      <Link {...props} href={resolved}>\n        {children}\n      </Link>\n    );\n  }\n\n  return (\n    <a {...withoutLinkOnlyProps(props)} href={resolved}>\n      {children}\n    </a>\n  );\n}\n"],"mappings":";;;;;;AAeA,MAAM,kBAAkB;CACtB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAEA,MAAM,uBAA4C,IAAI,IAAI,eAAe;;AAGzE,MAAM,yCAA8C,IAAI,IAAI;CAC1D,GAAG;CACH;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;AAED,SAAS,aAA+B,OAAU,OAAwC;CACxF,OAAO,OAAO,YAAY,OAAO,QAAQ,KAAK,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,MAAM,IAAI,GAAG,CAAC,CAAC;AACpF;AAEA,SAAS,qBAAuC,OAAiC;CAC/E,OAAO,aAAa,OAAO,oBAAoB;AACjD;;;;;;AAOA,SAAgB,eAAe,EAAE,MAAM,UAAU,GAAG,SAA8B;CAChF,MAAM,EAAE,YAAY,wBAAwB;CAC5C,MAAM,WAAW,QAAQ,IAAI;CAE7B,IAAI,aAAa,MACf,OACE,oBAAC,QAAD;EAAM,GAAK,aAAa,OAAO,sBAAsB;EAA8B,2BAAwB;EACxG;CACG,CAAA;CAIV,IAAI,aAAa,QAAQ,GACvB,OACE,oBAAC,MAAD;EAAM,GAAI;EAAO,MAAM;EACpB;CACG,CAAA;CAIV,OACE,oBAAC,KAAD;EAAG,GAAI,qBAAqB,KAAK;EAAG,MAAM;EACvC;CACA,CAAA;AAEP"}

package/dist/sdk/navigation/types.d.ts

@@ -0,0 +1,45 @@
+//#region src/sdk/navigation/types.d.ts
+/** The standard page names, copied from the compiler's `StandardName`. FastStore does not depend on sukima. */
+export type StandardName = 'home' | 'search' | 'cart' | 'checkout' | 'order-placed' | 'sign-in' | 'product' | 'category' | 'brand' | 'collection' | 'account' | 'profile' | 'orders' | 'order' | 'address' | 'payments' | 'security' | 'subscriptions' | 'subscription';
+/**
+ * A page named either by the store's page name or by a standard name. `params`, `query`, and `hash`
+ * apply to either form. A query key with a list appears once per value.
+ */
+export type PageRef = ({
+  page: string;
+} | {
+  standard: StandardName;
+}) & {
+  params?: Record<string, string | string[]>;
+  query?: Record<string, string | string[]>;
+  hash?: string;
+};
+export type RouteKind = 'singleton' | 'dynamic';
+/**
+ * One page in the route map. `pattern` keeps the bracket text (`/[slug]/p`, `/docs/[...slug]`,
+ * `/blog/[[...slug]]`). `params` lists the bare names. No base path.
+ */
+export type RouteMapEntry = {
+  pattern: string;
+  kind: RouteKind;
+  standard?: StandardName;
+  params?: string[];
+  aliases?: Record<string, string>;
+  bindings?: string[];
+};
+/** Keyed by page name. */
+export type RouteMap = Record<string, RouteMapEntry>;
+export type RouteIdentity = {
+  name: string;
+  kind: RouteKind;
+  standard?: StandardName;
+};
+export type ResolveHrefReason = 'unknown-page' | 'unknown-standard' | 'ambiguous-standard' | 'outside-bindings' | 'missing-param' | 'invalid-ref' | 'blank' | 'malformed' | 'protocol-relative' | 'forbidden-scheme';
+export type ResolveHrefResult = {
+  href: string;
+} | {
+  href: null;
+  reason: ResolveHrefReason;
+};
+//#endregion
+//# sourceMappingURL=types.d.ts.map

package/dist/sdk/navigation/use-storefront-navigation.d.ts

@@ -0,0 +1,26 @@
+import { PageRef } from "./types.js";
+//#region src/sdk/navigation/use-storefront-navigation.d.ts
+export type NavigateOptions = {
+  scroll?: boolean;
+};
+export type StorefrontNavigation = {
+  /** The href for the current binding, or `null` when the target does not resolve. */
+  hrefFor: (target: PageRef | string) => string | null;
+  /** Navigates to the target. Does nothing when it does not resolve. */
+  push: (target: PageRef | string, options?: NavigateOptions) => void;
+  /** Navigates to the target, replacing the history entry. Does nothing when it does not resolve. */
+  replace: (target: PageRef | string, options?: NavigateOptions) => void;
+  /** Prefetches a page of this store. Does nothing for an anchor, an absolute URL, or `null`. */
+  prefetch: (target: PageRef | string) => void;
+  back: () => void;
+  forward: () => void;
+  refresh: () => void;
+};
+/**
+ * The router of `next/navigation`, resolved through the binding. Depends only on the binding
+ * context and the route map, so a component that only links does not re-render on navigation.
+ * A link that does not resolve is reported once per component, not once per render.
+ */
+export declare function useStorefrontNavigation(): StorefrontNavigation;
+//#endregion
+//# sourceMappingURL=use-storefront-navigation.d.ts.map

package/dist/sdk/navigation/use-storefront-navigation.js

@@ -0,0 +1,73 @@
+"use client";
+import { resolveStorefrontHref } from "./resolve-storefront-href.js";
+import { useStorefrontContext } from "../context/storefront-context.js";
+import { reportUnresolved, warnSuspiciousPath } from "./report.js";
+import { useRouteMap } from "./route-map-provider.js";
+import { useMemo } from "react";
+import { useRouter } from "next/navigation";
+//#region src/sdk/navigation/use-storefront-navigation.ts
+/** Whether Next's router handles the href, as opposed to a document navigation. */
+function isClientHref(href) {
+	return href.startsWith("/") || href.startsWith("#");
+}
+/**
+* The router of `next/navigation`, resolved through the binding. Depends only on the binding
+* context and the route map, so a component that only links does not re-render on navigation.
+* A link that does not resolve is reported once per component, not once per render.
+*/
+function useStorefrontNavigation() {
+	const router = useRouter();
+	const { bindingId, basePath } = useStorefrontContext();
+	const { routeMap } = useRouteMap();
+	return useMemo(() => {
+		const reported = /* @__PURE__ */ new Set();
+		function hrefFor(target) {
+			if (typeof target === "string") warnSuspiciousPath({ basePath }, routeMap, target);
+			const result = resolveStorefrontHref({
+				bindingId,
+				basePath
+			}, routeMap, target);
+			if (result.href === null) {
+				const key = `${result.reason}\n${JSON.stringify(target)}`;
+				if (!reported.has(key)) {
+					reported.add(key);
+					reportUnresolved(result.reason, target);
+				}
+				return null;
+			}
+			return result.href;
+		}
+		function navigate(method, target, options) {
+			const href = hrefFor(target);
+			if (href === null) return;
+			if (!isClientHref(href)) {
+				if (method === "push") globalThis.location.assign(href);
+				else globalThis.location.replace(href);
+				return;
+			}
+			if (options?.scroll === void 0) router[method](href);
+			else router[method](href, { scroll: options.scroll });
+		}
+		return {
+			hrefFor,
+			push: (target, options) => navigate("push", target, options),
+			replace: (target, options) => navigate("replace", target, options),
+			prefetch: (target) => {
+				const href = hrefFor(target);
+				if (href?.startsWith("/")) router.prefetch(href);
+			},
+			back: () => router.back(),
+			forward: () => router.forward(),
+			refresh: () => router.refresh()
+		};
+	}, [
+		router,
+		bindingId,
+		basePath,
+		routeMap
+	]);
+}
+//#endregion
+export { isClientHref, useStorefrontNavigation };
+
+//# sourceMappingURL=use-storefront-navigation.js.map

package/dist/sdk/navigation/use-storefront-navigation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-storefront-navigation.js","names":[],"sources":["../../../src/sdk/navigation/use-storefront-navigation.ts"],"sourcesContent":["'use client';\n\nimport { useRouter } from 'next/navigation';\nimport { useMemo } from 'react';\nimport { useStorefrontContext } from '../context/storefront-context.js';\nimport { reportUnresolved, warnSuspiciousPath } from './report.js';\nimport { resolveStorefrontHref } from './resolve-storefront-href.js';\nimport { useRouteMap } from './route-map-provider.js';\nimport type { PageRef } from './types.js';\n\nexport type NavigateOptions = { scroll?: boolean };\n\nexport type StorefrontNavigation = {\n  /** The href for the current binding, or `null` when the target does not resolve. */\n  hrefFor: (target: PageRef | string) => string | null;\n  /** Navigates to the target. Does nothing when it does not resolve. */\n  push: (target: PageRef | string, options?: NavigateOptions) => void;\n  /** Navigates to the target, replacing the history entry. Does nothing when it does not resolve. */\n  replace: (target: PageRef | string, options?: NavigateOptions) => void;\n  /** Prefetches a page of this store. Does nothing for an anchor, an absolute URL, or `null`. */\n  prefetch: (target: PageRef | string) => void;\n  back: () => void;\n  forward: () => void;\n  refresh: () => void;\n};\n\n/** Whether Next's router handles the href, as opposed to a document navigation. */\nexport function isClientHref(href: string): boolean {\n  return href.startsWith('/') || href.startsWith('#');\n}\n\n/**\n * The router of `next/navigation`, resolved through the binding. Depends only on the binding\n * context and the route map, so a component that only links does not re-render on navigation.\n * A link that does not resolve is reported once per component, not once per render.\n */\nexport function useStorefrontNavigation(): StorefrontNavigation {\n  const router = useRouter();\n  const { bindingId, basePath } = useStorefrontContext();\n  const { routeMap } = useRouteMap();\n\n  return useMemo(() => {\n    const reported = new Set<string>();\n\n    function hrefFor(target: PageRef | string): string | null {\n      if (typeof target === 'string') warnSuspiciousPath({ basePath }, routeMap, target);\n      const result = resolveStorefrontHref({ bindingId, basePath }, routeMap, target);\n      if (result.href === null) {\n        const key = `${result.reason}\\n${JSON.stringify(target)}`;\n        if (!reported.has(key)) {\n          reported.add(key);\n          reportUnresolved(result.reason, target);\n        }\n        return null;\n      }\n      return result.href;\n    }\n\n    function navigate(method: 'push' | 'replace', target: PageRef | string, options?: NavigateOptions): void {\n      const href = hrefFor(target);\n      if (href === null) return;\n      if (!isClientHref(href)) {\n        if (method === 'push') globalThis.location.assign(href);\n        else globalThis.location.replace(href);\n        return;\n      }\n      if (options?.scroll === undefined) router[method](href);\n      else router[method](href, { scroll: options.scroll });\n    }\n\n    return {\n      hrefFor,\n      push: (target, options) => navigate('push', target, options),\n      replace: (target, options) => navigate('replace', target, options),\n      prefetch: (target) => {\n        const href = hrefFor(target);\n        if (href?.startsWith('/')) router.prefetch(href);\n      },\n      back: () => router.back(),\n      forward: () => router.forward(),\n      refresh: () => router.refresh(),\n    };\n  }, [router, bindingId, basePath, routeMap]);\n}\n"],"mappings":";;;;;;;;;AA2BA,SAAgB,aAAa,MAAuB;CAClD,OAAO,KAAK,WAAW,GAAG,KAAK,KAAK,WAAW,GAAG;AACpD;;;;;;AAOA,SAAgB,0BAAgD;CAC9D,MAAM,SAAS,UAAU;CACzB,MAAM,EAAE,WAAW,aAAa,qBAAqB;CACrD,MAAM,EAAE,aAAa,YAAY;CAEjC,OAAO,cAAc;EACnB,MAAM,2BAAW,IAAI,IAAY;EAEjC,SAAS,QAAQ,QAAyC;GACxD,IAAI,OAAO,WAAW,UAAU,mBAAmB,EAAE,SAAS,GAAG,UAAU,MAAM;GACjF,MAAM,SAAS,sBAAsB;IAAE;IAAW;GAAS,GAAG,UAAU,MAAM;GAC9E,IAAI,OAAO,SAAS,MAAM;IACxB,MAAM,MAAM,GAAG,OAAO,OAAO,IAAI,KAAK,UAAU,MAAM;IACtD,IAAI,CAAC,SAAS,IAAI,GAAG,GAAG;KACtB,SAAS,IAAI,GAAG;KAChB,iBAAiB,OAAO,QAAQ,MAAM;IACxC;IACA,OAAO;GACT;GACA,OAAO,OAAO;EAChB;EAEA,SAAS,SAAS,QAA4B,QAA0B,SAAiC;GACvG,MAAM,OAAO,QAAQ,MAAM;GAC3B,IAAI,SAAS,MAAM;GACnB,IAAI,CAAC,aAAa,IAAI,GAAG;IACvB,IAAI,WAAW,QAAQ,WAAW,SAAS,OAAO,IAAI;SACjD,WAAW,SAAS,QAAQ,IAAI;IACrC;GACF;GACA,IAAI,SAAS,WAAW,KAAA,GAAW,OAAO,OAAO,CAAC,IAAI;QACjD,OAAO,OAAO,CAAC,MAAM,EAAE,QAAQ,QAAQ,OAAO,CAAC;EACtD;EAEA,OAAO;GACL;GACA,OAAO,QAAQ,YAAY,SAAS,QAAQ,QAAQ,OAAO;GAC3D,UAAU,QAAQ,YAAY,SAAS,WAAW,QAAQ,OAAO;GACjE,WAAW,WAAW;IACpB,MAAM,OAAO,QAAQ,MAAM;IAC3B,IAAI,MAAM,WAAW,GAAG,GAAG,OAAO,SAAS,IAAI;GACjD;GACA,YAAY,OAAO,KAAK;GACxB,eAAe,OAAO,QAAQ;GAC9B,eAAe,OAAO,QAAQ;EAChC;CACF,GAAG;EAAC;EAAQ;EAAW;EAAU;CAAQ,CAAC;AAC5C"}

package/dist/sdk/navigation/use-storefront-route.d.ts

@@ -0,0 +1,26 @@
+import { RouteIdentity } from "./types.js";
+//#region src/sdk/navigation/use-storefront-route.d.ts
+export type StorefrontRoute = {
+  /** Which page is rendering, from the route marker and the route map. `null` outside a marker. */
+  page: RouteIdentity | null;
+  /** The route params, without the internal binding segment. */
+  params: Record<string, string | string[]>;
+  /** The logical path: the page's path inside the binding. */
+  path: string;
+  /** The public path: what the browser shows, binding base path included. */
+  publicPath: string;
+  /** `location.search` (`''` or `'?…'`), and `null` on the server and during hydration. */
+  search: string | null;
+};
+/**
+ * The current route: the page, its params, and its logical and public paths. Changes on every
+ * navigation, so a component that only links uses `useStorefrontNavigation` instead.
+ *
+ * `search` is read from `location.search` and refreshes on `popstate` or on a render the pathname or
+ * params cause. A soft navigation that changes only the query (`router.push('?q=x')`) fires no
+ * `popstate`, so `search` keeps its previous value until the next such render. A component whose
+ * state lives in the query reads `useStorefrontSearchParams()` instead.
+ */
+export declare function useStorefrontRoute(): StorefrontRoute;
+//#endregion
+//# sourceMappingURL=use-storefront-route.d.ts.map

package/dist/sdk/navigation/use-storefront-route.js

@@ -0,0 +1,87 @@
+"use client";
+import { useStorefrontContext } from "../context/storefront-context.js";
+import { useRouteMap } from "./route-map-provider.js";
+import { useRouteIdentityName } from "./route-identity-provider.js";
+import { useMemo, useSyncExternalStore } from "react";
+import { useParams, usePathname } from "next/navigation";
+//#region src/sdk/navigation/use-storefront-route.ts
+/** The internal route segment the generated root layout names the binding with. */
+const BINDING_PARAM = "binding";
+function subscribeToPopState(onChange) {
+	globalThis.addEventListener("popstate", onChange);
+	return () => globalThis.removeEventListener("popstate", onChange);
+}
+function readSearch() {
+	return globalThis.location.search;
+}
+function readServerSearch() {
+	return null;
+}
+/** Next's params without the binding segment. An empty optional catch-all is `undefined` and is left out. */
+function routeParams(raw) {
+	const params = {};
+	for (const [key, value] of Object.entries(raw)) if (key !== BINDING_PARAM && value !== void 0) params[key] = value;
+	return params;
+}
+const reportedMissingPages = /* @__PURE__ */ new Set();
+/**
+* The page the marker names, or `null` when the route map does not hold it. The generator emits both,
+* so they disagree only for a moment of Fast Refresh or through a generator bug; either way the page
+* reads as a layout does instead of failing to render. Logged once per name.
+*/
+function pageIdentity(routeMap, name) {
+	if (name === null) return null;
+	const entry = Object.hasOwn(routeMap, name) ? routeMap[name] : void 0;
+	if (entry === void 0) {
+		if (!reportedMissingPages.has(name)) {
+			reportedMissingPages.add(name);
+			console.error(`useStorefrontRoute: the route marker names page ${JSON.stringify(name)}, which the route map does not hold. The generator emits both, so they must agree; reading the page as null.`);
+		}
+		return null;
+	}
+	return entry.standard === void 0 ? {
+		name,
+		kind: entry.kind
+	} : {
+		name,
+		kind: entry.kind,
+		standard: entry.standard
+	};
+}
+/**
+* The current route: the page, its params, and its logical and public paths. Changes on every
+* navigation, so a component that only links uses `useStorefrontNavigation` instead.
+*
+* `search` is read from `location.search` and refreshes on `popstate` or on a render the pathname or
+* params cause. A soft navigation that changes only the query (`router.push('?q=x')`) fires no
+* `popstate`, so `search` keeps its previous value until the next such render. A component whose
+* state lives in the query reads `useStorefrontSearchParams()` instead.
+*/
+function useStorefrontRoute() {
+	const publicPath = usePathname();
+	const rawParams = useParams();
+	const { basePath } = useStorefrontContext();
+	const { routeMap, toLogicalPath } = useRouteMap();
+	const name = useRouteIdentityName();
+	const search = useSyncExternalStore(subscribeToPopState, readSearch, readServerSearch);
+	const params = useMemo(() => routeParams(rawParams ?? {}), [rawParams]);
+	const page = useMemo(() => pageIdentity(routeMap, name), [routeMap, name]);
+	const path = toLogicalPath({ basePath }, publicPath);
+	return useMemo(() => ({
+		page,
+		params,
+		path,
+		publicPath,
+		search
+	}), [
+		page,
+		params,
+		path,
+		publicPath,
+		search
+	]);
+}
+//#endregion
+export { useStorefrontRoute };
+
+//# sourceMappingURL=use-storefront-route.js.map

package/dist/sdk/navigation/use-storefront-route.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-storefront-route.js","names":[],"sources":["../../../src/sdk/navigation/use-storefront-route.ts"],"sourcesContent":["'use client';\n\nimport { useParams, usePathname } from 'next/navigation';\nimport { useMemo, useSyncExternalStore } from 'react';\nimport { useStorefrontContext } from '../context/storefront-context.js';\nimport { useRouteIdentityName } from './route-identity-provider.js';\nimport { useRouteMap } from './route-map-provider.js';\nimport type { RouteIdentity, RouteMap } from './types.js';\n\n/** The internal route segment the generated root layout names the binding with. */\nconst BINDING_PARAM = 'binding';\n\nexport type StorefrontRoute = {\n  /** Which page is rendering, from the route marker and the route map. `null` outside a marker. */\n  page: RouteIdentity | null;\n  /** The route params, without the internal binding segment. */\n  params: Record<string, string | string[]>;\n  /** The logical path: the page's path inside the binding. */\n  path: string;\n  /** The public path: what the browser shows, binding base path included. */\n  publicPath: string;\n  /** `location.search` (`''` or `'?…'`), and `null` on the server and during hydration. */\n  search: string | null;\n};\n\nfunction subscribeToPopState(onChange: () => void): () => void {\n  globalThis.addEventListener('popstate', onChange);\n  return () => globalThis.removeEventListener('popstate', onChange);\n}\n\nfunction readSearch(): string {\n  return globalThis.location.search;\n}\n\nfunction readServerSearch(): null {\n  return null;\n}\n\n/** Next's params without the binding segment. An empty optional catch-all is `undefined` and is left out. */\nfunction routeParams(raw: Record<string, string | string[] | undefined>): Record<string, string | string[]> {\n  const params: Record<string, string | string[]> = {};\n  for (const [key, value] of Object.entries(raw)) {\n    if (key !== BINDING_PARAM && value !== undefined) params[key] = value;\n  }\n  return params;\n}\n\nconst reportedMissingPages = new Set<string>();\n\n/**\n * The page the marker names, or `null` when the route map does not hold it. The generator emits both,\n * so they disagree only for a moment of Fast Refresh or through a generator bug; either way the page\n * reads as a layout does instead of failing to render. Logged once per name.\n */\nfunction pageIdentity(routeMap: RouteMap, name: string | null): RouteIdentity | null {\n  if (name === null) return null;\n  const entry = Object.hasOwn(routeMap, name) ? routeMap[name] : undefined;\n  if (entry === undefined) {\n    if (!reportedMissingPages.has(name)) {\n      reportedMissingPages.add(name);\n      console.error(\n        `useStorefrontRoute: the route marker names page ${JSON.stringify(name)}, which the route map ` +\n          'does not hold. The generator emits both, so they must agree; reading the page as null.',\n      );\n    }\n    return null;\n  }\n  return entry.standard === undefined\n    ? { name, kind: entry.kind }\n    : { name, kind: entry.kind, standard: entry.standard };\n}\n\n/**\n * The current route: the page, its params, and its logical and public paths. Changes on every\n * navigation, so a component that only links uses `useStorefrontNavigation` instead.\n *\n * `search` is read from `location.search` and refreshes on `popstate` or on a render the pathname or\n * params cause. A soft navigation that changes only the query (`router.push('?q=x')`) fires no\n * `popstate`, so `search` keeps its previous value until the next such render. A component whose\n * state lives in the query reads `useStorefrontSearchParams()` instead.\n */\nexport function useStorefrontRoute(): StorefrontRoute {\n  const publicPath = usePathname();\n  const rawParams = useParams();\n  const { basePath } = useStorefrontContext();\n  const { routeMap, toLogicalPath } = useRouteMap();\n  const name = useRouteIdentityName();\n  const search = useSyncExternalStore(subscribeToPopState, readSearch, readServerSearch);\n\n  const params = useMemo(() => routeParams(rawParams ?? {}), [rawParams]);\n  const page = useMemo(() => pageIdentity(routeMap, name), [routeMap, name]);\n  const path = toLogicalPath({ basePath }, publicPath);\n\n  return useMemo(() => ({ page, params, path, publicPath, search }), [page, params, path, publicPath, search]);\n}\n"],"mappings":";;;;;;;;AAUA,MAAM,gBAAgB;AAetB,SAAS,oBAAoB,UAAkC;CAC7D,WAAW,iBAAiB,YAAY,QAAQ;CAChD,aAAa,WAAW,oBAAoB,YAAY,QAAQ;AAClE;AAEA,SAAS,aAAqB;CAC5B,OAAO,WAAW,SAAS;AAC7B;AAEA,SAAS,mBAAyB;CAChC,OAAO;AACT;;AAGA,SAAS,YAAY,KAAuF;CAC1G,MAAM,SAA4C,CAAC;CACnD,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,GAAG,GAC3C,IAAI,QAAQ,iBAAiB,UAAU,KAAA,GAAW,OAAO,OAAO;CAElE,OAAO;AACT;AAEA,MAAM,uCAAuB,IAAI,IAAY;;;;;;AAO7C,SAAS,aAAa,UAAoB,MAA2C;CACnF,IAAI,SAAS,MAAM,OAAO;CAC1B,MAAM,QAAQ,OAAO,OAAO,UAAU,IAAI,IAAI,SAAS,QAAQ,KAAA;CAC/D,IAAI,UAAU,KAAA,GAAW;EACvB,IAAI,CAAC,qBAAqB,IAAI,IAAI,GAAG;GACnC,qBAAqB,IAAI,IAAI;GAC7B,QAAQ,MACN,mDAAmD,KAAK,UAAU,IAAI,EAAE,6GAE1E;EACF;EACA,OAAO;CACT;CACA,OAAO,MAAM,aAAa,KAAA,IACtB;EAAE;EAAM,MAAM,MAAM;CAAK,IACzB;EAAE;EAAM,MAAM,MAAM;EAAM,UAAU,MAAM;CAAS;AACzD;;;;;;;;;;AAWA,SAAgB,qBAAsC;CACpD,MAAM,aAAa,YAAY;CAC/B,MAAM,YAAY,UAAU;CAC5B,MAAM,EAAE,aAAa,qBAAqB;CAC1C,MAAM,EAAE,UAAU,kBAAkB,YAAY;CAChD,MAAM,OAAO,qBAAqB;CAClC,MAAM,SAAS,qBAAqB,qBAAqB,YAAY,gBAAgB;CAErF,MAAM,SAAS,cAAc,YAAY,aAAa,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC;CACtE,MAAM,OAAO,cAAc,aAAa,UAAU,IAAI,GAAG,CAAC,UAAU,IAAI,CAAC;CACzE,MAAM,OAAO,cAAc,EAAE,SAAS,GAAG,UAAU;CAEnD,OAAO,eAAe;EAAE;EAAM;EAAQ;EAAM;EAAY;CAAO,IAAI;EAAC;EAAM;EAAQ;EAAM;EAAY;CAAM,CAAC;AAC7G"}

package/dist/sdk/navigation/use-storefront-search-params.d.ts

@@ -0,0 +1,11 @@
+import { ReadonlyURLSearchParams } from "next/navigation";
+//#region src/sdk/navigation/use-storefront-search-params.d.ts
+/**
+ * The live query of the current URL. It follows a query-only soft navigation, which
+ * `useStorefrontRoute().search` does not, so a component whose state lives in the query (a filter, a
+ * search field, a page cursor) reads it here. On a prerendered page it needs a `<Suspense>` boundary,
+ * as Next's `useSearchParams` does.
+ */
+export declare function useStorefrontSearchParams(): ReadonlyURLSearchParams;
+//#endregion
+//# sourceMappingURL=use-storefront-search-params.d.ts.map

package/dist/sdk/navigation/use-storefront-search-params.js

@@ -0,0 +1,16 @@
+"use client";
+import { useSearchParams } from "next/navigation";
+//#region src/sdk/navigation/use-storefront-search-params.ts
+/**
+* The live query of the current URL. It follows a query-only soft navigation, which
+* `useStorefrontRoute().search` does not, so a component whose state lives in the query (a filter, a
+* search field, a page cursor) reads it here. On a prerendered page it needs a `<Suspense>` boundary,
+* as Next's `useSearchParams` does.
+*/
+function useStorefrontSearchParams() {
+	return useSearchParams();
+}
+//#endregion
+export { useStorefrontSearchParams };
+
+//# sourceMappingURL=use-storefront-search-params.js.map

package/dist/sdk/navigation/use-storefront-search-params.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-storefront-search-params.js","names":[],"sources":["../../../src/sdk/navigation/use-storefront-search-params.ts"],"sourcesContent":["'use client';\n\nimport { type ReadonlyURLSearchParams, useSearchParams } from 'next/navigation';\n\n/**\n * The live query of the current URL. It follows a query-only soft navigation, which\n * `useStorefrontRoute().search` does not, so a component whose state lives in the query (a filter, a\n * search field, a page cursor) reads it here. On a prerendered page it needs a `<Suspense>` boundary,\n * as Next's `useSearchParams` does.\n */\nexport function useStorefrontSearchParams(): ReadonlyURLSearchParams {\n  return useSearchParams();\n}\n"],"mappings":";;;;;;;;;AAUA,SAAgB,4BAAqD;CACnE,OAAO,gBAAgB;AACzB"}

package/dist/sdk/orders/completion-badge.d.ts

@@ -0,0 +1,8 @@
+import "../../particles/order-status-badge/order-status-badge.js";
+//#region src/sdk/orders/completion-badge.d.ts
+export type OrderCompletionData = {
+  view: string;
+  label: string;
+};
+//#endregion
+//# sourceMappingURL=completion-badge.d.ts.map

package/dist/sdk/orders/completion-badge.js

@@ -0,0 +1,47 @@
+//#region src/sdk/orders/completion-badge.ts
+function viewTone(view) {
+	switch (view) {
+		case "ONGOING": return {
+			state: "ongoing",
+			tone: "progress"
+		};
+		case "COMPLETED": return {
+			state: "completed",
+			tone: "success"
+		};
+		case "CANCELLED": return {
+			state: "cancelled",
+			tone: "danger"
+		};
+		default: return null;
+	}
+}
+function badgeLabel(label) {
+	switch (label) {
+		case "CANCELLED": return "cancelled";
+		case "CANCELLATION_REQUESTED": return "cancellation-requested";
+		case "IN_PROGRESS": return "in-progress";
+		case "DELIVERED": return "delivered";
+		case "SHIPPED": return "shipped";
+		case "READY_FOR_PICKUP": return "ready-for-pickup";
+		case "COLLECTED": return "collected";
+		default: return "";
+	}
+}
+/**
+* Maps the API's `CustomerOrderCompletion` enums to `OrderStatusBadge` props. An unknown view
+* yields `null`, so the caller omits the badge; an unknown label yields `''`, so the badge
+* renders its catalogue placeholder.
+*/
+function completionBadgeModel(completion) {
+	const tone = viewTone(completion.view);
+	if (!tone) return null;
+	return {
+		...tone,
+		label: badgeLabel(completion.label)
+	};
+}
+//#endregion
+export { completionBadgeModel };
+
+//# sourceMappingURL=completion-badge.js.map

package/dist/sdk/orders/completion-badge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"completion-badge.js","names":[],"sources":["../../../src/sdk/orders/completion-badge.ts"],"sourcesContent":["import type { OrderStatusState, OrderStatusTone } from '../../particles/order-status-badge/order-status-badge.js';\n\nexport type OrderCompletionData = { view: string; label: string };\n\nexport type CompletionBadgeModel = {\n  state: OrderStatusState;\n  tone: OrderStatusTone;\n  label: string;\n};\n\nfunction viewTone(view: string): { state: OrderStatusState; tone: OrderStatusTone } | null {\n  switch (view) {\n    case 'ONGOING':\n      return { state: 'ongoing', tone: 'progress' };\n    case 'COMPLETED':\n      return { state: 'completed', tone: 'success' };\n    case 'CANCELLED':\n      return { state: 'cancelled', tone: 'danger' };\n    default:\n      return null;\n  }\n}\n\nfunction badgeLabel(label: string): string {\n  switch (label) {\n    case 'CANCELLED':\n      return 'cancelled';\n    case 'CANCELLATION_REQUESTED':\n      return 'cancellation-requested';\n    case 'IN_PROGRESS':\n      return 'in-progress';\n    case 'DELIVERED':\n      return 'delivered';\n    case 'SHIPPED':\n      return 'shipped';\n    case 'READY_FOR_PICKUP':\n      return 'ready-for-pickup';\n    case 'COLLECTED':\n      return 'collected';\n    default:\n      return '';\n  }\n}\n\n/**\n * Maps the API's `CustomerOrderCompletion` enums to `OrderStatusBadge` props. An unknown view\n * yields `null`, so the caller omits the badge; an unknown label yields `''`, so the badge\n * renders its catalogue placeholder.\n */\nexport function completionBadgeModel(completion: OrderCompletionData): CompletionBadgeModel | null {\n  const tone = viewTone(completion.view);\n  if (!tone) {\n    return null;\n  }\n  return { ...tone, label: badgeLabel(completion.label) };\n}\n"],"mappings":";AAUA,SAAS,SAAS,MAAyE;CACzF,QAAQ,MAAR;EACE,KAAK,WACH,OAAO;GAAE,OAAO;GAAW,MAAM;EAAW;EAC9C,KAAK,aACH,OAAO;GAAE,OAAO;GAAa,MAAM;EAAU;EAC/C,KAAK,aACH,OAAO;GAAE,OAAO;GAAa,MAAM;EAAS;EAC9C,SACE,OAAO;CACX;AACF;AAEA,SAAS,WAAW,OAAuB;CACzC,QAAQ,OAAR;EACE,KAAK,aACH,OAAO;EACT,KAAK,0BACH,OAAO;EACT,KAAK,eACH,OAAO;EACT,KAAK,aACH,OAAO;EACT,KAAK,WACH,OAAO;EACT,KAAK,oBACH,OAAO;EACT,KAAK,aACH,OAAO;EACT,SACE,OAAO;CACX;AACF;;;;;;AAOA,SAAgB,qBAAqB,YAA8D;CACjG,MAAM,OAAO,SAAS,WAAW,IAAI;CACrC,IAAI,CAAC,MACH,OAAO;CAET,OAAO;EAAE,GAAG;EAAM,OAAO,WAAW,WAAW,KAAK;CAAE;AACxD"}

package/dist/sdk/orders/order-operations.d.ts

@@ -0,0 +1,19 @@
+import { TypedDocumentNode } from "@apollo/client";
+//#region src/sdk/orders/order-operations.d.ts
+/**
+ * The order-cancel write document.
+ *
+ * Authored with the hand `gql` tag, like `sdk/region/region-operations.ts`. The document selects
+ * the order identity so Apollo can merge the entity, and the typed errors the caller shows.
+ * A null `customerOrder` with empty `userErrors` is a successful write whose re-read failed.
+ */
+export type OrderCancelUserError = Readonly<{
+  code?: string;
+  message: string;
+}>;
+export type OrderCancelOrder = Readonly<{
+  __typename: 'CustomerOrder';
+  id: string;
+}>;
+//#endregion
+//# sourceMappingURL=order-operations.d.ts.map

package/dist/sdk/orders/order-operations.js

@@ -0,0 +1,21 @@
+import { gql } from "../graphql-tag.js";
+//#region src/sdk/orders/order-operations.ts
+const CUSTOMER_ORDER_CANCEL = gql`
+  mutation CustomerOrderCancel($id: ID!, $input: CustomerOrderCancelInput!) {
+    customerOrderCancel(id: $id, input: $input) {
+      __typename
+      customerOrder {
+        __typename
+        id
+      }
+      userErrors {
+        code
+        message
+      }
+    }
+  }
+`;
+//#endregion
+export { CUSTOMER_ORDER_CANCEL };
+
+//# sourceMappingURL=order-operations.js.map

package/dist/sdk/orders/order-operations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-operations.js","names":[],"sources":["../../../src/sdk/orders/order-operations.ts"],"sourcesContent":["import type { TypedDocumentNode } from '@apollo/client';\nimport { gql } from '../graphql-tag.js';\n\n/**\n * The order-cancel write document.\n *\n * Authored with the hand `gql` tag, like `sdk/region/region-operations.ts`. The document selects\n * the order identity so Apollo can merge the entity, and the typed errors the caller shows.\n * A null `customerOrder` with empty `userErrors` is a successful write whose re-read failed.\n */\n\nexport type OrderCancelUserError = Readonly<{ code?: string; message: string }>;\n\nexport type OrderCancelOrder = Readonly<{ __typename: 'CustomerOrder'; id: string }>;\n\nexport type OrderCancelPayload = Readonly<{\n  __typename: 'CustomerOrderCancelPayload';\n  customerOrder: OrderCancelOrder | null;\n  userErrors: readonly OrderCancelUserError[];\n}>;\n\ntype CustomerOrderCancelData = Readonly<{ customerOrderCancel: OrderCancelPayload }>;\n\nexport type CustomerOrderCancelVariables = Readonly<{\n  id: string;\n  input: Readonly<{ reason?: string }>;\n}>;\n\nexport const CUSTOMER_ORDER_CANCEL: TypedDocumentNode<CustomerOrderCancelData, CustomerOrderCancelVariables> = gql`\n  mutation CustomerOrderCancel($id: ID!, $input: CustomerOrderCancelInput!) {\n    customerOrderCancel(id: $id, input: $input) {\n      __typename\n      customerOrder {\n        __typename\n        id\n      }\n      userErrors {\n        code\n        message\n      }\n    }\n  }\n`;\n"],"mappings":";;AA4BA,MAAa,wBAAkG,GAAG"}

package/dist/sdk/orders/use-order-actions.d.ts

@@ -0,0 +1,23 @@
+import "../../core/dist/index.js";
+import { OrderCancelOrder, OrderCancelUserError } from "./order-operations.js";
+//#region src/sdk/orders/use-order-actions.d.ts
+/**
+ * The `order` action namespace. `cancel` awaits `customerOrderCancel` and returns the payload.
+ * It does not throw: a typed refusal stays in `userErrors`, and a transport failure becomes one
+ * `NETWORK_ERROR`. A null order with empty `userErrors` means the write was accepted and the
+ * re-read failed. The order id and the reason are never logged.
+ */
+export type OrderCancelInput = Readonly<{
+  id: string;
+  reason?: string | null;
+}>;
+export type OrderCancelResult = Readonly<{
+  customerOrder: OrderCancelOrder | null;
+  userErrors: readonly OrderCancelUserError[];
+}>;
+export type OrderActions = Readonly<{
+  cancel: (input: OrderCancelInput) => Promise<OrderCancelResult>;
+}>;
+//#endregion
+export type { OrderCancelOrder, OrderCancelUserError };
+//# sourceMappingURL=use-order-actions.d.ts.map