@ecomiq/storefront 2.1.4 → 3.0.0

package/dist/settings.d.ts

@@ -0,0 +1,51 @@
+import { CatalogLink, CatalogLinkReference, ProductSort, ProductSummary, StorefrontClient } from "@ecomiq/core";
+import { ComponentProps, ReactNode } from "react";
+declare function link(url: string, label?: string, reference?: null): string;
+declare function link(url: string, label: string | undefined, reference: CatalogLinkReference): CatalogLink;
+declare function link(url: string, label: string | undefined, reference: CatalogLinkReference | null | undefined): string | CatalogLink;
+export type SettingOptions = {
+  readonly [value: string]: string;
+};
+export type SettingLimits = {
+  readonly min: number;
+  readonly max: number;
+  readonly step?: number;
+};
+declare function select<const Options extends SettingOptions>(value: Extract<keyof Options, string>, _label: string | undefined, _options: Options): Extract<keyof Options, string>;
+export declare const setting: {
+  text: (value: string, _label?: string) => string;
+  richtext: (html: string, _label?: string) => string;
+  image: (url: string, _label?: string) => string;
+  video: (url: string, _label?: string) => string;
+  link: typeof link;
+  collection: (handle: string, _label?: string) => string;
+  category: (handle: string, _label?: string) => string;
+  product: (handle: string, _label?: string) => string;
+  products: (handles: string[], _label?: string) => string[];
+  number: (value: number, _label?: string) => number;
+  range: (value: number, _label: string | undefined, _limits: SettingLimits) => number;
+  toggle: (value: boolean, _label?: string) => boolean;
+  color: (value: string, _label?: string) => string;
+  select: typeof select;
+  scheme: (id: string, _label?: string) => string;
+};
+export type SectionGroup = "products" | "collections" | "content" | "reviews";
+export type SectionCatalog = {
+  readonly name: string;
+  readonly description: string;
+  readonly group?: SectionGroup;
+};
+export type SectionRoot = Omit<ComponentProps<"section">, "className" | "children">;
+export type SectionProps<Settings> = { readonly [Key in keyof Settings]?: Settings[Key] extends readonly unknown[] ? Settings[Key] : Settings[Key] extends object ? Partial<Settings[Key]> : Settings[Key]; } & {
+  readonly children?: ReactNode;
+};
+export declare function section<Settings extends object>(defaults: Settings, props: SectionProps<Settings>): Settings;
+export type ProductSource = {
+  collection?: string;
+  category?: string;
+  products?: string[];
+  limit?: number;
+  sort?: ProductSort;
+};
+export declare function pickProducts(client: StorefrontClient, source: ProductSource): Promise<ProductSummary[]>;
+export {};

package/dist/source-marker-DhqSkW7n.js

@@ -0,0 +1,4 @@
+// src/source-marker.ts
+const SOURCE = /^\{\{\s*((?:product|collection|page)(?:\.[A-Za-z0-9_-]+)+)\s*\}\}$/;
+const SOURCES_PROP = "data-ecomiq-sources";
+export { SOURCE, SOURCES_PROP };

package/dist/sources-B-3JFJfb.js

@@ -0,0 +1,46 @@
+import { createContext, use } from "react";
+import { jsx } from "react/jsx-runtime";
+// src/sources.tsx
+const SourceData = createContext(null);
+function SourceProvider({ value, children }) {
+	return /* @__PURE__ */ jsx(SourceData, {
+		value,
+		children
+	});
+}
+function field(value, key) {
+	if (key === void 0 || typeof value !== "object" || value === null) return void 0;
+	return value[key];
+}
+function text(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number") return String(value);
+	return "";
+}
+function sourceValue(data, path) {
+	const [kind, name, key] = path.split(".");
+	if (kind === "product") {
+		const product = field(data, "product");
+		if (name === "description") return text(field(data, "description"));
+		if (name === "image") {
+			const images = field(product, "images");
+			return text(field(product, "imageUrl")) || text(field(Array.isArray(images) ? images[0] : void 0, "url"));
+		}
+		if (name === "attributes") {
+			const specifications = field(product, "specifications");
+			const found = Array.isArray(specifications) ? specifications.find((item) => field(item, "key") === key) : void 0;
+			return text(field(found, "valueName")) || text(field(found, "value"));
+		}
+		return text(field(product, name));
+	}
+	if (kind === "collection") {
+		const collection = field(data, "collection");
+		if (name === "image") return text(field(collection, "imageUrl"));
+		return text(field(collection, name));
+	}
+	return text(field(data, name));
+}
+function source(path) {
+	return sourceValue(use(SourceData), path);
+}
+export { SourceProvider, source, sourceValue };

package/dist/sources.d.ts

@@ -0,0 +1,7 @@
+import { ReactElement, ReactNode } from "react";
+export declare function SourceProvider({ value, children }: {
+  value: unknown;
+  children?: ReactNode;
+}): ReactElement;
+export declare function sourceValue(data: unknown, path: string): string;
+export declare function source(path: string): string;

package/dist/store-8Q-_LFrQ.js

@@ -0,0 +1,152 @@
+import { apiCacheFetch, uncachedFetch } from "./api-cache-DsuIn5hX.js";
+import { previewClient } from "./preview-BiIBif3C.js";
+import { productPreviewClient } from "./product-preview-BspMAecJ.js";
+import { observeStorefrontClient } from "./telemetry-HuZXWBPi.js";
+import { worker } from "./worker-CNi-gzCu.js";
+import { data } from "react-router";
+import { ApiError, GraphQLResponseError, createClient } from "@ecomiq/core";
+import { z } from "zod";
+// src/store.ts
+const requestClients = /* @__PURE__ */ new WeakMap();
+const REQUEST_READS = /* @__PURE__ */ new Set([
+	"getSettings",
+	"getLayout",
+	"getStoreId",
+	"getCollections",
+	"getPaymentMethods",
+	"getCollectionBySlug",
+	"getPageBySlug",
+	"getCategoryBySlug",
+	"resolveUrl",
+	"getLinks",
+	"listArticles",
+	"getArticleBySlug",
+	"getSellers",
+	"getSellerBySlug",
+	"getProducts",
+	"getProductBySlug",
+	"getRelatedProducts",
+	"listProductReviews",
+	"listStoreReviews"
+]);
+function shareRequestReads(client) {
+	const reads = /* @__PURE__ */ new Map();
+	return new Proxy(client, { get(target, property, receiver) {
+		if (property === "clearCache") return () => {
+			reads.clear();
+			target.clearCache();
+		};
+		const value = Reflect.get(target, property, receiver);
+		if (typeof property !== "string" || !REQUEST_READS.has(property) || typeof value !== "function") return value;
+		return (...args) => {
+			const key = `${property}:${JSON.stringify(args)}`;
+			const shared = reads.get(key);
+			if (shared) return shared;
+			const read = Promise.resolve(Reflect.apply(value, target, args));
+			reads.set(key, read);
+			read.catch(() => {
+				if (reads.get(key) === read) reads.delete(key);
+			});
+			return read;
+		};
+	} });
+}
+function store(context) {
+	let client = requestClients.get(context);
+	if (client) return client;
+	const { env, ctx, sdkTiming, productPreview, cacheRevision } = context.get(worker);
+	const count = () => sdkTiming?.recordSubrequest();
+	const cached = productPreview || env.ECOMIQ_PREVIEW === "1" || cacheRevision === void 0 ? void 0 : apiCacheFetch(ctx, env.ECOMIQ_STORE, count, cacheRevision);
+	client = createClient({
+		domain: env.ECOMIQ_STORE,
+		baseUrl: env.ECOMIQ_API_URL,
+		storeId: env.ECOMIQ_STORE_ID,
+		fetch: cached ?? uncachedFetch(count)
+	});
+	if (env.ECOMIQ_PREVIEW === "1") client = previewClient(client);
+	if (productPreview) client = productPreviewClient(client, productPreview);
+	client = shareRequestReads(client);
+	if (sdkTiming) client = observeStorefrontClient(client, sdkTiming);
+	requestClients.set(context, client);
+	return client;
+}
+async function storeHeaders(client) {
+	return { headers: { "x-Store-Id": await client.getStoreId() } };
+}
+async function found(read, missing = (status) => status === 404) {
+	try {
+		return await read;
+	} catch (error) {
+		if (error instanceof ApiError && missing(error.status)) throw data(null, { status: 404 });
+		throw error;
+	}
+}
+const CollectionImagesSchema = z.record(z.string(), z.object({ products: z.array(z.object({ imageUrl: z.string() })) }).nullable());
+async function collectionImageCandidates({ client, collections, pageSize }) {
+	const missing = [...new Map(collections.filter((collection) => !collection.imageUrl).map((collection) => [collection.id, collection])).values()].sort((left, right) => left.id.localeCompare(right.id));
+	const candidates = /* @__PURE__ */ new Map();
+	const batches = [];
+	for (let offset = 0; offset < missing.length; offset += 10) {
+		const batch = missing.slice(offset, offset + 10);
+		const variables = Object.fromEntries(batch.map((collection, index) => [`c${index}`, {
+			collectionId: collection.id,
+			pageSize,
+			includeFilters: false
+		}]));
+		const parameters = batch.map((_, index) => `$c${index}: StorefrontProductsInput!`).join(", ");
+		const fields = batch.map((_, index) => `c${index}: products(input: $c${index}) { products { imageUrl } }`).join("\n");
+		batches.push(client.graphql(`query CollectionImages(${parameters}) { ${fields} }`, CollectionImagesSchema, variables).catch(async (error) => {
+			const partial = CollectionImagesSchema.safeParse(error instanceof GraphQLResponseError ? error.data : null);
+			if (partial.success) return partial.data;
+			const result = {};
+			await Promise.all(batch.map(async (collection, index) => {
+				result[`c${index}`] = await client.getProducts({
+					collectionId: collection.id,
+					pageSize,
+					includeFilters: false
+				}).catch(() => null);
+			}));
+			return result;
+		}).then((result) => {
+			batch.forEach((collection, index) => {
+				candidates.set(collection.id, (result[`c${index}`]?.products ?? []).map((product) => product.imageUrl).filter((image) => image !== ""));
+			});
+		}));
+	}
+	await Promise.all(batches);
+	return candidates;
+}
+async function withImages(client, collections) {
+	const candidates = await collectionImageCandidates({
+		client,
+		collections,
+		pageSize: 6
+	});
+	const used = /* @__PURE__ */ new Set();
+	return collections.map((collection) => {
+		const options = collection.imageUrl ? [collection.imageUrl] : candidates.get(collection.id) ?? [];
+		const image = options.find((option) => !used.has(option)) ?? options[0] ?? null;
+		if (image !== null) used.add(image);
+		return {
+			collection,
+			image
+		};
+	});
+}
+async function readCountries(client) {
+	const { store } = await client.getSettings();
+	const names = new Intl.DisplayNames([store.language], { type: "region" });
+	return [{
+		code: store.countryCode,
+		name: names.of(store.countryCode) ?? store.countryCode
+	}];
+}
+async function readDocumentCountries(client) {
+	const [settings, countries] = await Promise.all([client.getSettings(), client.getCountries()]);
+	const names = new Intl.DisplayNames([settings.store.language], { type: "region" });
+	return countries.map((country) => ({
+		code: country.code,
+		name: names.of(country.code) ?? country.name
+	})).sort((a, b) => a.name.localeCompare(b.name, settings.store.language));
+}
+export { collectionImageCandidates, found, readCountries, readDocumentCountries, store, storeHeaders, withImages };

package/dist/store-contact--hY6CoFb.js

@@ -0,0 +1,19 @@
+// src/store-contact.ts
+function storefrontContact(settings) {
+	const business = settings.store.businessSettings;
+	const address = business.address;
+	return {
+		...settings.cms.settings.contact,
+		supportEmail: business.contactEmail,
+		phone: business.phone,
+		address: address === null ? null : [
+			address.address1,
+			address.address2,
+			address.district,
+			address.city,
+			address.province,
+			address.postalCode
+		].filter((part) => part !== null && part !== "").join(", ")
+	};
+}
+export { storefrontContact };

package/dist/store-contact.d.ts

@@ -0,0 +1,6 @@
+import { StorefrontSettings } from "@ecomiq/core";
+export declare function storefrontContact(settings: StorefrontSettings): StorefrontSettings["cms"]["settings"]["contact"] & {
+  supportEmail: string | null;
+  phone: string | null;
+  address: string | null;
+};

package/dist/store.d.ts

@@ -0,0 +1,17 @@
+import { RouterContextProvider } from "react-router";
+import { Collection, StorefrontClient } from "@ecomiq/core";
+export declare function store(context: Readonly<RouterContextProvider>): StorefrontClient;
+export declare function found<T>(read: Promise<T>, missing?: (status: number) => boolean): Promise<T>;
+export declare function collectionImageCandidates({ client, collections, pageSize }: {
+  client: StorefrontClient;
+  collections: readonly Collection[];
+  pageSize: number;
+}): Promise<ReadonlyMap<string, readonly string[]>>;
+export declare function withImages(client: StorefrontClient, collections: Collection[]): Promise<{
+  collection: Collection;
+  image: string | null;
+}[]>;
+export declare function readCountries(client: StorefrontClient): Promise<{
+  code: string;
+  name: string;
+}[]>;

package/dist/storefront-language-DrMjVbmk.js

@@ -0,0 +1,29 @@
+import { storefrontText } from "./storefront-text-D25ae1qf.js";
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+// src/storefront-language.tsx
+const StorefrontLanguage = createContext({
+	language: "es",
+	locale: "es",
+	timeZone: "UTC",
+	translations: {}
+});
+function StorefrontLanguageProvider({ language, locale = language, timeZone = "UTC", translations = {}, children }) {
+	return /* @__PURE__ */ jsx(StorefrontLanguage, {
+		value: {
+			language,
+			locale,
+			timeZone,
+			translations
+		},
+		children
+	});
+}
+function useStorefrontText() {
+	const { translations } = useContext(StorefrontLanguage);
+	return (source, values) => storefrontText(translations, source, values);
+}
+function useStorefrontLocale() {
+	return useContext(StorefrontLanguage);
+}
+export { StorefrontLanguageProvider, useStorefrontLocale, useStorefrontText };

package/dist/storefront-language.d.ts

@@ -0,0 +1,14 @@
+import { StorefrontTextValues, StorefrontTranslations } from "./storefront-text.js";
+import { ReactNode } from "react";
+export declare function StorefrontLanguageProvider({ language, locale, timeZone, translations, children }: {
+  language: string;
+  locale?: string;
+  timeZone?: string;
+  translations?: StorefrontTranslations;
+  children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useStorefrontText(): (source: string, values?: StorefrontTextValues) => string;
+export declare function useStorefrontLocale(): {
+  locale: string;
+  timeZone: string;
+};

package/dist/storefront-text-D25ae1qf.js

@@ -0,0 +1,11 @@
+// src/storefront-text.ts
+async function loadStorefrontTranslations(language) {
+	const code = language.split("-")[0];
+	if (code === "en") return (await import("./storefront-text-en-ljjjSS4q.js")).default;
+	if (code === "pt") return (await import("./storefront-text-pt-BtHaJLcp.js")).default;
+	return {};
+}
+function storefrontText(translations, source, values = {}) {
+	return (translations[source] ?? source).replace(/\{(\w+)\}/g, (token, key) => Object.hasOwn(values, key) ? String(values[key] ?? "") : token);
+}
+export { loadStorefrontTranslations, storefrontText };