@justanarthur/payload-www 0.1.1

package/dist/hooks.js

@@ -0,0 +1,196 @@
+
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/render/_locale.ts
+function prefixFor(locale, defaultLocale, mode) {
+  if (mode === "never")
+    return "";
+  if (mode === "as-needed" && locale === defaultLocale)
+    return "";
+  return `/${locale}`;
+}
+function resolveLocale(req) {
+  if (!req || typeof req !== "object")
+    return "";
+  const r = req;
+  if (typeof r.locale === "string" && r.locale.length > 0)
+    return r.locale;
+  const fallback = r.payload?.config?.localization?.defaultLocale;
+  if (typeof fallback === "string" && fallback.length > 0)
+    return fallback;
+  return "";
+}
+function allLocales(req) {
+  if (!req || typeof req !== "object")
+    return [];
+  const r = req;
+  const list = r.payload?.config?.localization?.locales;
+  if (!Array.isArray(list) || list.length === 0)
+    return [];
+  const out = [];
+  for (const entry of list) {
+    if (typeof entry === "string" && entry.length > 0) {
+      out.push(entry);
+    } else if (entry && typeof entry === "object" && "code" in entry) {
+      const code = entry.code;
+      if (typeof code === "string" && code.length > 0)
+        out.push(code);
+    }
+  }
+  return out;
+}
+
+// src/render/hooks/_shared.ts
+var cachePromise = null;
+function nextCacheImport() {
+  return cachePromise ??= import("next/cache");
+}
+function shouldSkipRevalidate(context) {
+  return Boolean(context?.disableRevalidate);
+}
+async function safeRevalidatePath(payload, path) {
+  try {
+    const { revalidatePath } = await nextCacheImport();
+    revalidatePath(path);
+  } catch (error) {
+    payload.logger.error(`revalidatePath("${path}") failed: ${String(error)}`);
+  }
+}
+async function safeRevalidateTag(payload, tag, profile = "max") {
+  try {
+    const { revalidateTag } = await nextCacheImport();
+    revalidateTag(tag, profile);
+  } catch (error) {
+    payload.logger.error(`revalidateTag("${tag}") failed: ${String(error)}`);
+  }
+}
+
+// src/render/hooks/revalidateCollection.ts
+function createRevalidateCollectionHook(options) {
+  const {
+    collectionSlug,
+    urlPathPrefix = "",
+    sitemapTag,
+    localePrefix: modeOption,
+    defaultLocale: defaultLocaleOption,
+    pathMode = "url"
+  } = options;
+  const resolvedSitemapTag = sitemapTag === false ? false : sitemapTag ?? `${collectionSlug}-sitemap`;
+  const resolveDefaults = (req) => {
+    const mode = modeOption ?? "always";
+    const defaultLocale = defaultLocaleOption ?? req?.payload?.config?.localization?.defaultLocale ?? "";
+    return { mode, defaultLocale };
+  };
+  const localesToFanOut = (req) => {
+    const all = allLocales(req);
+    if (all.length > 0)
+      return all;
+    const single = resolveLocale(req);
+    return single ? [single] : [];
+  };
+  const collectionPath = (slug, locale, mode, defaultLocale) => {
+    const prefix = prefixFor(locale, defaultLocale, mode);
+    if (!slug)
+      return `${prefix}${urlPathPrefix}` || "/";
+    return `${prefix}${urlPathPrefix}/${slug}`;
+  };
+  const fanOutPaths = async (payload, req, slug, label) => {
+    const { mode, defaultLocale } = resolveDefaults(req);
+    const locales = localesToFanOut(req);
+    for (const locale of locales) {
+      const path = collectionPath(slug, locale, mode, defaultLocale);
+      payload.logger.info?.(`${label} ${path}`);
+      await safeRevalidatePath(payload, path);
+    }
+  };
+  const fireCollectionTags = async (payload, docId, req) => {
+    if (typeof docId === "string" || typeof docId === "number") {
+      await safeRevalidateTag(payload, `collection_${collectionSlug}_${docId}`);
+    }
+    if (resolvedSitemapTag !== false) {
+      await safeRevalidateTag(payload, resolvedSitemapTag);
+    }
+  };
+  const afterChange = async ({ doc, previousDoc, req }) => {
+    if (shouldSkipRevalidate(req.context))
+      return doc;
+    const { payload } = req;
+    const typed = doc;
+    const prev = previousDoc;
+    const isPublished = typed._status === "published";
+    const wasPublished = prev?._status === "published";
+    const prevSlugIsString = typeof prev?.slug === "string";
+    const slugChanged = prevSlugIsString && prev?.slug !== typed.slug;
+    if (isPublished) {
+      if (pathMode !== "tag-only") {
+        await fanOutPaths(payload, req, typed.slug, `Revalidating ${collectionSlug} at path:`);
+      }
+      await fireCollectionTags(payload, typed.id, req);
+    }
+    if (wasPublished && (!isPublished || slugChanged)) {
+      if (pathMode !== "tag-only") {
+        await fanOutPaths(payload, req, prev?.slug, `Revalidating old ${collectionSlug} at path:`);
+      }
+      await fireCollectionTags(payload, typed.id, req);
+    }
+    return doc;
+  };
+  const afterDelete = async ({ doc, req }) => {
+    if (shouldSkipRevalidate(req.context))
+      return doc ?? null;
+    const { payload } = req;
+    const typed = doc;
+    if (pathMode !== "tag-only") {
+      await fanOutPaths(payload, req, typed?.slug, `Revalidating deleted ${collectionSlug} at path:`);
+    }
+    await fireCollectionTags(payload, typed?.id, req);
+    return doc ?? null;
+  };
+  return { afterChange, afterDelete };
+}
+var createRevalidatePageHooks = (opts = {}) => createRevalidateCollectionHook({
+  collectionSlug: "pages",
+  urlPathPrefix: "",
+  ...opts
+});
+
+// src/render/hooks/revalidateGlobal.ts
+function createRevalidateGlobalHook(slug) {
+  return async ({ doc, req: { payload, context, locale } }) => {
+    if (shouldSkipRevalidate(context))
+      return doc;
+    const tags = [`global_${slug}`, `global_${slug}_${locale}`];
+    payload.logger.info?.(`Revalidating global: ${tags.join(", ")}`);
+    for (const tag of tags) {
+      await safeRevalidateTag(payload, tag);
+    }
+    return doc;
+  };
+}
+
+// src/exports/hooks.ts
+var hooks_default = {
+  createRevalidateCollectionHook,
+  createRevalidatePageHooks,
+  createRevalidateGlobalHook
+};
+export {
+  hooks_default as default,
+  createRevalidatePageHooks,
+  createRevalidateGlobalHook,
+  createRevalidateCollectionHook
+};

package/dist/imagehash.d.ts

@@ -0,0 +1,3 @@
+import { imageHashPlugin } from "@justanarthur/payload-imagehash-plugin";
+import { BlurhashPluginOptions } from "@justanarthur/payload-imagehash-plugin/types";
+export { imageHashPlugin, imageHashPlugin as default, BlurhashPluginOptions };

package/dist/imagehash.js

@@ -0,0 +1,24 @@
+
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/exports/imagehash.ts
+import { imageHashPlugin } from "@justanarthur/payload-imagehash-plugin";
+var imagehash_default = imageHashPlugin;
+export {
+  imageHashPlugin,
+  imagehash_default as default
+};

package/dist/import-map-provider.d.ts

@@ -0,0 +1,20 @@
+import { ImportMap } from "payload";
+/**
+* Marker kept for backwards compatibility with hosts that
+* imported `setImportMapProvider` / `getImportMap` from earlier
+* versions of the lib. New code should pass the importMap directly
+* to `createRootLayoutExports` and `createCollectionPageExports` —
+* no global state, no module-load-time coupling.
+*
+* The functions are no-ops. The lib reads the importMap exclusively
+* from the per-factory `importMap` option now.
+*
+* @deprecated pass `importMap` to the factories instead.
+*/
+declare function setImportMapProvider(_provider: () => Promise<ImportMap> | ImportMap): void;
+/**
+* @deprecated pass `importMap` to the factories instead. Always
+* returns `{}` now — the lib never reads global state.
+*/
+declare function getImportMap(): Promise<ImportMap>;
+export { setImportMapProvider, getImportMap };

package/dist/import-map-provider.js

@@ -0,0 +1,26 @@
+
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/exports/import-map-provider.ts
+function setImportMapProvider(_provider) {}
+async function getImportMap() {
+  return {};
+}
+export {
+  setImportMapProvider,
+  getImportMap
+};

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { FC } from "react";
+type LivePreviewListenerProps = {
+	serverURL?: string;
+};
+declare const LivePreviewListener: FC<LivePreviewListenerProps>;
+export { LivePreviewListener as default, LivePreviewListenerProps, LivePreviewListener };

package/dist/index.js

@@ -0,0 +1,38 @@
+"use client";
+
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/render/components/LivePreviewListener.tsx
+import { RefreshRouteOnSave as PayloadLivePreview } from "@payloadcms/live-preview-react";
+import { useRouter } from "next/navigation";
+import { jsx } from "react/jsx-runtime";
+
+var LivePreviewListener = ({ serverURL }) => {
+  const router = useRouter();
+  const url = serverURL ?? process.env.NEXT_PUBLIC_SERVER_URL ?? (typeof window !== "undefined" ? window.location.origin : "");
+  return /* @__PURE__ */ jsx(PayloadLivePreview, {
+    refresh: router.refresh,
+    serverURL: url
+  });
+};
+
+// src/exports/index.ts
+var exports_default = LivePreviewListener;
+export {
+  exports_default as default,
+  LivePreviewListener
+};

package/dist/metadata.d.ts

@@ -0,0 +1,122 @@
+type ArticleLdOptions = {
+	doc: Record<string, any>;
+	url: string;
+	locale: string;
+	siteUrl: string;
+	type?: "BlogPosting" | "Article" | "NewsArticle" | "TechArticle";
+	publisherName?: string;
+	publisherLogo?: string | null;
+};
+declare function buildArticleLd({ doc, url, locale, siteUrl, type, publisherName, publisherLogo }: ArticleLdOptions): Record<string, unknown>;
+type BreadcrumbItem = {
+	label: string;
+	url: string;
+};
+declare function buildBreadcrumbsLd({ items, currentUrl }: {
+	items: BreadcrumbItem[];
+	currentUrl: string;
+}): Record<string, unknown>;
+declare function buildOrganizationLd({ siteUrl, name, logo, sameAs }: {
+	siteUrl: string;
+	name?: string;
+	logo?: string;
+	sameAs?: string[];
+}): Record<string, unknown>;
+declare function buildHreflangAlternates<L extends string>({ siteUrl, locale, urlPrefix, storedSlug, queryAllLocaleSlugs, nested, homeSlug, defaultLocale, locales, localePrefix }: {
+	siteUrl: string;
+	locale: L;
+	urlPrefix: string;
+	storedSlug: string;
+	queryAllLocaleSlugs: (slug: string, locale: L) => Promise<Partial<Record<L, string>> | undefined>;
+	nested: boolean;
+	homeSlug: string;
+	defaultLocale: L;
+	locales: readonly L[];
+	/**
+	* Locale prefix mode — mirrors next-intl's `localePrefix` so each
+	* alternate URL matches the host's actual route shape:
+	*
+	* - `'always'`: every URL is prefixed with `/{locale}/…`
+	*   (e.g. `/en/about`, `/uk/about`). The default — preserves
+	*   the helper's prior behavior.
+	* - `'as-needed'`: the default locale renders without a prefix
+	*   (e.g. `/about`), other locales are prefixed (`/uk/about`).
+	*   Critical: callers that emit hreflang alongside a canonical
+	*   URL built with `as-needed` mode MUST pass this through,
+	*   otherwise the `en` and `x-default` alternates point to URLs
+	*   the host doesn't actually serve.
+	* - `'never'`: no locale prefix at all.
+	*/
+	localePrefix?: "always" | "as-needed" | "never";
+}): Promise<Record<string, string>>;
+declare function segmentsToStoredSlug(segments: string[] | string, nested?: boolean): string;
+declare function segmentsToUrlPath(segments: string[] | string, nested?: boolean): string;
+declare function storedSlugToSegments(storedSlug: string, nested?: boolean): string[] | string;
+declare function buildCanonicalUrl<L extends string>({ siteUrl, locale, urlPrefix, urlPath }: {
+	siteUrl: string;
+	locale: L;
+	urlPrefix: string;
+	urlPath: string;
+}): string;
+declare function getUrlPath(segments: string[] | string, nested: boolean, homeSlug: string): string;
+import { DataFromCollectionSlug, ImportMap, SanitizedConfig } from "payload";
+declare const queryDocBySlug: <S extends string>({ collectionSlug, slug, slugField, locale, draft, config }: {
+	collectionSlug: S;
+	slug: string;
+	slugField?: string;
+	locale: string;
+	draft?: boolean;
+	config: Promise<SanitizedConfig>;
+}) => Promise<DataFromCollectionSlug<S> | null>;
+declare const queryAllDocs: <S extends string>({ collectionSlug, slugField, locale, config }: {
+	collectionSlug: S;
+	slugField?: string;
+	locale: string;
+	config: Promise<SanitizedConfig>;
+}) => Promise<DataFromCollectionSlug<S>[]>;
+declare const queryAllLocaleSlugs2: <S extends string>({ collectionSlug, slug, slugField, locale, config }: {
+	collectionSlug: S;
+	slug: string;
+	slugField?: string;
+	locale: string;
+	config: Promise<SanitizedConfig>;
+}) => Promise<Record<string, string> | undefined>;
+declare function getRenderModuleExports(exportName: string, collection: {
+	custom?: Record<string, unknown>;
+} | undefined, importMap: ImportMap): unknown;
+import { SanitizedConfig as SanitizedConfig_ee8ogz } from "payload";
+import { DataFromCollectionSlug as DataFromCollectionSlug_2e2bqb } from "payload";
+declare const _default: {
+	buildArticleLd: typeof buildArticleLd;
+	buildBreadcrumbsLd: typeof buildBreadcrumbsLd;
+	buildOrganizationLd: typeof buildOrganizationLd;
+	buildHreflangAlternates: typeof buildHreflangAlternates;
+	queryDocBySlug: <S extends string>({ collectionSlug, slug, slugField, locale, draft, config }: {
+		collectionSlug: S;
+		slug: string;
+		slugField?: string;
+		locale: string;
+		draft?: boolean;
+		config: Promise<SanitizedConfig_ee8ogz>;
+	}) => Promise<DataFromCollectionSlug_2e2bqb<S> | null>;
+	queryAllDocs: <S extends string>({ collectionSlug, slugField, locale, config }: {
+		collectionSlug: S;
+		slugField?: string;
+		locale: string;
+		config: Promise<SanitizedConfig_ee8ogz>;
+	}) => Promise<DataFromCollectionSlug_2e2bqb<S>[]>;
+	queryAllLocaleSlugs2: <S extends string>({ collectionSlug, slug, slugField, locale, config }: {
+		collectionSlug: S;
+		slug: string;
+		slugField?: string;
+		locale: string;
+		config: Promise<SanitizedConfig_ee8ogz>;
+	}) => Promise<Record<string, string> | undefined>;
+	getUrlPath: typeof getUrlPath;
+	segmentsToStoredSlug: typeof segmentsToStoredSlug;
+	segmentsToUrlPath: typeof segmentsToUrlPath;
+	storedSlugToSegments: typeof storedSlugToSegments;
+	buildCanonicalUrl: typeof buildCanonicalUrl;
+	getRenderModuleExports: typeof getRenderModuleExports;
+};
+export { storedSlugToSegments, segmentsToUrlPath, segmentsToStoredSlug, queryDocBySlug, queryAllLocaleSlugs2 as queryAllLocaleSlugs, queryAllDocs, getUrlPath, getRenderModuleExports, _default as default, buildOrganizationLd, buildHreflangAlternates, buildCanonicalUrl, buildBreadcrumbsLd, buildArticleLd, BreadcrumbItem, ArticleLdOptions };