@lynkow/next 0.1.0

package/dist/client/index.js

@@ -0,0 +1,170 @@
+'use client'
+
+// src/visual-editor/provider.tsx
+import { useState, useEffect, useRef } from "react";
+import { initVisualEditor } from "lynkow/visual-editor";
+
+// src/visual-editor/context.ts
+import { createContext } from "react";
+var LynkowVisualEditorContext = createContext({
+  instance: null,
+  isPreviewMode: false,
+  blocksData: {}
+});
+
+// src/visual-editor/provider.tsx
+import { jsx } from "react/jsx-runtime";
+function LynkowVisualEditor({ children, ...config }) {
+  const [blocksData, setBlocksData] = useState({});
+  const [isPreviewMode, setIsPreviewMode] = useState(false);
+  const instanceRef = useRef(null);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const instance = initVisualEditor(config);
+    instanceRef.current = instance;
+    if (instance.isPreviewMode()) {
+      setIsPreviewMode(true);
+      const unsubscribe = instance.onDataChange(
+        (blockSlug, _fieldKey, _fieldPath, _value, allData) => {
+          setBlocksData((prev) => ({
+            ...prev,
+            [blockSlug]: allData
+          }));
+        }
+      );
+      return () => {
+        unsubscribe();
+        instance.destroy();
+        instanceRef.current = null;
+      };
+    }
+    return () => {
+      instance.destroy();
+      instanceRef.current = null;
+    };
+  }, [config.cmsOrigin]);
+  const contextValue = {
+    instance: instanceRef.current,
+    isPreviewMode,
+    blocksData
+  };
+  return /* @__PURE__ */ jsx(LynkowVisualEditorContext.Provider, { value: contextValue, children });
+}
+
+// src/visual-editor/hooks.ts
+import { useContext, useMemo } from "react";
+function useBlockData(blockSlug, initialData) {
+  const { isPreviewMode, blocksData } = useContext(LynkowVisualEditorContext);
+  return useMemo(() => {
+    if (!isPreviewMode) {
+      return initialData;
+    }
+    const previewData = blocksData[blockSlug];
+    if (!previewData) {
+      return initialData;
+    }
+    return { ...initialData, ...previewData };
+  }, [isPreviewMode, blocksData, blockSlug, initialData]);
+}
+function useLynkowField(blockSlug, fieldKey, initialValue) {
+  const { isPreviewMode, blocksData } = useContext(LynkowVisualEditorContext);
+  return useMemo(() => {
+    if (!isPreviewMode) {
+      return initialValue;
+    }
+    const blockData = blocksData[blockSlug];
+    if (!blockData || !(fieldKey in blockData)) {
+      return initialValue;
+    }
+    return blockData[fieldKey];
+  }, [isPreviewMode, blocksData, blockSlug, fieldKey, initialValue]);
+}
+function useIsPreviewMode() {
+  const { isPreviewMode } = useContext(LynkowVisualEditorContext);
+  return isPreviewMode;
+}
+
+// src/visual-editor/editable.tsx
+import { createContext as createContext2, useContext as useContext2 } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var BlockSlugContext = createContext2(null);
+function EditableBlock({
+  slug,
+  as: As = "div",
+  className,
+  children
+}) {
+  return /* @__PURE__ */ jsx2(BlockSlugContext.Provider, { value: slug, children: /* @__PURE__ */ jsx2(As, { "data-lynkow-block": slug, className, children }) });
+}
+function Editable({
+  field,
+  label,
+  type = "text",
+  as: As = "span",
+  className,
+  children,
+  html
+}) {
+  const slug = useContext2(BlockSlugContext);
+  if (slug === null && process.env.NODE_ENV !== "production") {
+    console.error(
+      `[lynkow] <Editable field="${field}"> has no <EditableBlock> ancestor, so the editor's scanner will skip it.`
+    );
+  }
+  const initial = html !== void 0 ? html : children;
+  const value = useLynkowField(slug ?? "", field, initial);
+  const markers = {
+    "data-lynkow-field": field,
+    "data-lynkow-type": type,
+    "data-lynkow-label": label ?? field
+  };
+  if (html !== void 0) {
+    return /* @__PURE__ */ jsx2(As, { ...markers, className, dangerouslySetInnerHTML: { __html: value } });
+  }
+  return /* @__PURE__ */ jsx2(As, { ...markers, className, children: value });
+}
+
+// src/analytics/tracker.tsx
+import { useEffect as useEffect2 } from "react";
+var TRACKER_ID = "lynkow-tracker";
+function trackerAllowed(consent) {
+  switch (consent.mode) {
+    case null:
+    case "notice-only":
+      return true;
+    case "opt-out":
+      return consent.state !== "denied";
+    case "opt-in":
+      return consent.state === "granted";
+    default:
+      return false;
+  }
+}
+function LynkowTracker({ config, consent }) {
+  const allowed = trackerAllowed(consent);
+  const { mode } = consent;
+  const { siteId, apiUrl } = config;
+  useEffect2(() => {
+    if (!allowed || document.getElementById(TRACKER_ID)) return;
+    const script = document.createElement("script");
+    script.id = TRACKER_ID;
+    script.src = `${apiUrl}/analytics/tracker.js`;
+    script.async = true;
+    script.dataset["siteId"] = siteId;
+    script.dataset["apiUrl"] = apiUrl;
+    if (mode) script.dataset["consentMode"] = mode;
+    document.body.appendChild(script);
+  }, [allowed, mode, siteId, apiUrl]);
+  return null;
+}
+export {
+  Editable,
+  EditableBlock,
+  LynkowTracker,
+  LynkowVisualEditor,
+  trackerAllowed,
+  useBlockData,
+  useIsPreviewMode,
+  useLynkowField
+};
+//# sourceMappingURL=index.js.map

package/dist/client/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/visual-editor/provider.tsx","../../src/visual-editor/context.ts","../../src/visual-editor/hooks.ts","../../src/visual-editor/editable.tsx","../../src/analytics/tracker.tsx"],"sourcesContent":["import React, { useState, useEffect, useRef } from 'react'\nimport { initVisualEditor, type VisualEditorConfig, type VisualEditorInstance } from 'lynkow/visual-editor'\nimport { LynkowVisualEditorContext } from './context.js'\n\n/**\n * Props of {@link LynkowVisualEditor}.\n *\n * Extends {@link VisualEditorConfig}, so `cmsOrigin` is documented once, on the\n * config the core reads, and means the same thing here.\n */\nexport interface LynkowVisualEditorProps extends VisualEditorConfig {\n  /** Your application. Rendered unchanged; the provider adds no wrapper element. */\n  children: React.ReactNode\n}\n\nexport function LynkowVisualEditor({ children, ...config }: LynkowVisualEditorProps) {\n  const [blocksData, setBlocksData] = useState<Record<string, Record<string, any>>>({})\n  const [isPreviewMode, setIsPreviewMode] = useState(false)\n  const instanceRef = useRef<VisualEditorInstance | null>(null)\n\n  useEffect(() => {\n    if (typeof window === 'undefined') return\n\n    const instance = initVisualEditor(config)\n    instanceRef.current = instance\n\n    if (instance.isPreviewMode()) {\n      setIsPreviewMode(true)\n\n      const unsubscribe = instance.onDataChange(\n        (blockSlug, _fieldKey, _fieldPath, _value, allData) => {\n          setBlocksData((prev) => ({\n            ...prev,\n            [blockSlug]: allData,\n          }))\n        }\n      )\n\n      return () => {\n        unsubscribe()\n        instance.destroy()\n        instanceRef.current = null\n      }\n    }\n\n    return () => {\n      instance.destroy()\n      instanceRef.current = null\n    }\n    // Keyed on the field, never on `config`: the rest object is a fresh identity\n    // every render, which would tear the editor down and rebuild it each time.\n  }, [config.cmsOrigin])\n\n  const contextValue = {\n    instance: instanceRef.current,\n    isPreviewMode,\n    blocksData,\n  }\n\n  return (\n    <LynkowVisualEditorContext.Provider value={contextValue}>\n      {children}\n    </LynkowVisualEditorContext.Provider>\n  )\n}\n","import { createContext } from 'react'\nimport type { VisualEditorInstance } from 'lynkow/visual-editor'\n\nexport interface LynkowVisualEditorContextValue {\n  instance: VisualEditorInstance | null\n  isPreviewMode: boolean\n  blocksData: Record<string, Record<string, any>>\n}\n\nexport const LynkowVisualEditorContext = createContext<LynkowVisualEditorContextValue>({\n  instance: null,\n  isPreviewMode: false,\n  blocksData: {},\n})\n","import { useContext, useMemo } from 'react'\nimport { LynkowVisualEditorContext } from './context.js'\n\nexport function useBlockData<T extends Record<string, any>>(\n  blockSlug: string,\n  initialData: T\n): T {\n  const { isPreviewMode, blocksData } = useContext(LynkowVisualEditorContext)\n\n  return useMemo(() => {\n    if (!isPreviewMode) {\n      return initialData\n    }\n\n    const previewData = blocksData[blockSlug]\n    if (!previewData) {\n      return initialData\n    }\n\n    return { ...initialData, ...previewData } as T\n  }, [isPreviewMode, blocksData, blockSlug, initialData])\n}\n\nexport function useLynkowField<T>(blockSlug: string, fieldKey: string, initialValue: T): T {\n  const { isPreviewMode, blocksData } = useContext(LynkowVisualEditorContext)\n\n  return useMemo(() => {\n    if (!isPreviewMode) {\n      return initialValue\n    }\n\n    const blockData = blocksData[blockSlug]\n    if (!blockData || !(fieldKey in blockData)) {\n      return initialValue\n    }\n\n    return blockData[fieldKey] as T\n  }, [isPreviewMode, blocksData, blockSlug, fieldKey, initialValue])\n}\n\nexport function useIsPreviewMode(): boolean {\n  const { isPreviewMode } = useContext(LynkowVisualEditorContext)\n  return isPreviewMode\n}\n","import { createContext, useContext, type ElementType, type ReactNode } from 'react'\nimport { useLynkowField } from './hooks.js'\n\n/**\n * The two markers the SDK's DOM scanner looks for, and the contract between\n * them.\n *\n * On activation the editor runs `document.querySelectorAll('[data-lynkow-block]')`\n * and, inside each match, `querySelectorAll('[data-lynkow-field]')`. A field\n * that is not a DESCENDANT of a block is invisible to it, which is why the slug\n * travels through context rather than being repeated on every field: the two\n * cannot drift apart if only one of them names it.\n *\n * Three consequences of that scan being a ONE-OFF at activation:\n *\n *   - **An empty field cannot be discovered from the page.** A site that hides\n *     a section whose text is blank leaves no element carrying the marker in\n *     the DOM, so the editor never learns the field exists. It is still\n *     editable from the dashboard's own field list; only the click-on-the-page\n *     path is missing.\n *   - **The CMS has the last word.** Hovering is gated on\n *     `getEditableFields(slug).includes(key)`, sent by the admin at handshake.\n *     A field marked here that the site's block schema does not declare is\n *     ignored rather than broken.\n *   - **Inline editing reads `textContent`.** The editor sets `contentEditable`\n *     on the marked element, so mark the element that holds the text and\n *     nothing else. Wrapping a whole section would make the editor overwrite\n *     the section with a flat string on the first keystroke.\n */\nconst BlockSlugContext = createContext<string | null>(null)\n\n/**\n * Names the site block this subtree renders.\n *\n * `as` exists so this adds no DOM node: pass the element the block already had\n * (`as=\"header\"`, `as=\"section\"`) rather than nesting a div inside it.\n */\nexport function EditableBlock({\n  slug,\n  as: As = 'div',\n  className,\n  children,\n}: {\n  slug: string\n  as?: ElementType\n  className?: string\n  children: ReactNode\n}) {\n  return (\n    <BlockSlugContext.Provider value={slug}>\n      <As data-lynkow-block={slug} className={className}>\n        {children}\n      </As>\n    </BlockSlugContext.Provider>\n  )\n}\n\ntype EditableCommon = {\n  /** The field key, exactly as the site block schema spells it. */\n  field: string\n  /** What the editor's badge shows. Defaults to the field key. */\n  label?: string\n  /** Picks the badge icon and tells the admin which control to open. */\n  type?: 'text' | 'richtext' | 'url' | 'image' | 'number' | 'date' | 'select' | 'boolean'\n  as?: ElementType\n  className?: string\n}\n\n/**\n * `children` for a plain text field, `html` for a richtext one. Never both:\n * a richtext field is injected rather than rendered, so the two cannot share a\n * code path without also sharing the injection.\n */\ntype EditableProps =\n  | (EditableCommon & { children: string; html?: never })\n  | (EditableCommon & { html: string; children?: never })\n\n/**\n * One editable field.\n *\n * The value passed in is the SERVER-rendered one and stays the value in\n * production: `useLynkowField` returns its third argument whenever the page is\n * not inside the editor. Inside it, the hook returns whatever the admin has\n * typed, so a change made in the dashboard's side panel appears here without a\n * reload.\n *\n * FLAT KEYS ONLY. The hook indexes the block data with `key in data`, so a\n * repeater row (`services[0].title`) has no addressable key and cannot be\n * marked. Those fields stay editable from the dashboard; they are simply not\n * clickable on the page. Marking the repeater's container would be worse than\n * not marking it, because inline editing would flatten the whole list to text.\n */\nexport function Editable({\n  field,\n  label,\n  type = 'text',\n  as: As = 'span',\n  className,\n  children,\n  html,\n}: EditableProps) {\n  const slug = useContext(BlockSlugContext)\n\n  // Dot access on purpose: bundlers replace `process.env.NODE_ENV` as text.\n  if (slug === null && (process.env as { NODE_ENV?: string }).NODE_ENV !== 'production') {\n    console.error(\n      `[lynkow] <Editable field=\"${field}\"> has no <EditableBlock> ancestor, so the editor's scanner will skip it.`\n    )\n  }\n\n  const initial = html !== undefined ? html : children\n  const value = useLynkowField<string>(slug ?? '', field, initial)\n\n  const markers = {\n    'data-lynkow-field': field,\n    'data-lynkow-type': type,\n    'data-lynkow-label': label ?? field,\n  }\n\n  if (html !== undefined) {\n    // Same trust boundary as an article body: richtext arrives as HTML the API\n    // sanitized server side. In preview the string comes from the admin over\n    // PostMessage instead, which is the same author through a different pipe.\n    return <As {...markers} className={className} dangerouslySetInnerHTML={{ __html: value }} />\n  }\n\n  return (\n    <As {...markers} className={className}>\n      {value}\n    </As>\n  )\n}\n","import { useEffect } from 'react'\nimport type { LynkowNextConfig } from '../config.js'\n\n/**\n * What the site's consent state lets the analytics tracker do.\n *\n * - `mode: null`: the site has no consent gate, because the banner is off in\n *   the admin or the consent code was removed. Loading the tracker is not this\n *   component's decision to refuse.\n * - `notice-only`: the banner informs rather than asks, so the tracker loads.\n * - `opt-out`: the tracker loads unless the visitor refused.\n * - `opt-in`: the tracker loads only once the visitor granted analytics.\n *   `unavailable` means the consent configuration could not be read, so there\n *   is no choice to read against: the tracker never loads from here then.\n *\n * A mode outside these four never loads it: a value this package does not know\n * cannot be read as consent.\n *\n * This decides whether the script is ADDED. Once it runs, the tracker follows\n * later answers through Lynkow's own consent banner, which it listens to; a\n * refusal given through another banner reaches it on the next full page load.\n */\nexport type TrackerConsent =\n  | { mode: null; state: 'not-required' }\n  | { mode: 'opt-out' | 'notice-only'; state: 'pending' | 'granted' | 'denied' }\n  | { mode: 'opt-in'; state: 'pending' | 'granted' | 'denied' | 'unavailable' }\n\n/** Props of {@link LynkowTracker}. */\nexport interface LynkowTrackerProps {\n  config: Pick<LynkowNextConfig, 'siteId' | 'apiUrl'>\n  consent: TrackerConsent\n}\n\n/** The id the SDK's loader gives the tracker and looks for before adding one. */\nconst TRACKER_ID = 'lynkow-tracker'\n\n/** Whether the tracker may load under this consent state. */\nexport function trackerAllowed(consent: TrackerConsent): boolean {\n  switch (consent.mode) {\n    case null:\n    case 'notice-only':\n      return true\n    case 'opt-out':\n      return consent.state !== 'denied'\n    case 'opt-in':\n      return consent.state === 'granted'\n    default:\n      return false\n  }\n}\n\n/**\n * Loads Lynkow's analytics tracker when the consent state allows it, unless a\n * copy is already on the page.\n *\n * The tracker is a self-contained script the API serves. It records pageviews,\n * client-side navigations included, scroll depth, engaged time, outbound and\n * file links, rage and dead clicks, form events, Core Web Vitals and click\n * heatmaps on its own.\n *\n * ONE TRACKER, NEVER TWO. A browser client of the SDK loads `tracker.js` on its\n * own, under the id `lynkow-tracker`, and two copies each send every event.\n * This component therefore injects the script only when no copy exists, under\n * that same id, which the SDK's loader checks and waits on instead of adding\n * its own.\n *\n * The consent mode is passed to the script as `data-consent-mode`. Without it\n * the tracker works the mode out from the page, and on a site whose banner is\n * not the SDK's own it finds none and tracks before the visitor answers.\n *\n * Renders nothing.\n */\nexport function LynkowTracker({ config, consent }: LynkowTrackerProps): null {\n  const allowed = trackerAllowed(consent)\n  const { mode } = consent\n  const { siteId, apiUrl } = config\n\n  useEffect(() => {\n    if (!allowed || document.getElementById(TRACKER_ID)) return\n\n    const script = document.createElement('script')\n    script.id = TRACKER_ID\n    script.src = `${apiUrl}/analytics/tracker.js`\n    script.async = true\n    script.dataset['siteId'] = siteId\n    script.dataset['apiUrl'] = apiUrl\n    if (mode) script.dataset['consentMode'] = mode\n    document.body.appendChild(script)\n  }, [allowed, mode, siteId, apiUrl])\n\n  return null\n}\n"],"mappings":"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","names":["createContext","useContext","jsx","createContext","useContext","useEffect"]}

package/dist/config-CwDV7jFS.d.ts

@@ -0,0 +1,80 @@
+/**
+ * The configuration a Lynkow site hands this adapter, and the one function
+ * that validates it.
+ *
+ * Nothing in this package reads `process.env`. Next inlines `NEXT_PUBLIC_*`
+ * variables at build time by textual substitution, so only a literal
+ * `process.env.NEXT_PUBLIC_X` written in the application's own source reaches
+ * the browser bundle, and a library cannot spell out names an application
+ * chose. The application reads its environment and passes the values here.
+ *
+ * Everything in the resolved configuration is public, because it reaches
+ * client bundles. A server secret, such as the webhook signing secret, never
+ * belongs in it.
+ */
+/** What an application passes to {@link resolveConfig}, typically straight from its environment. */
+interface LynkowNextConfigInput {
+    /** The site's UUID, shown in the Lynkow admin and returned by the MCP `list_sites` tool. */
+    siteId: string | undefined;
+    /** The public origin of the site, such as `https://www.example.com`. No path, query or fragment. */
+    siteUrl: string | undefined;
+    /**
+     * The locales the site serves, as an array or a comma-separated list, in the
+     * order they should be advertised. Must mirror the site's enabled locales.
+     */
+    locales: string | readonly string[] | undefined;
+    /** The default locale. Defaults to the first of `locales`. */
+    defaultLocale?: string | undefined;
+    /**
+     * Whether the default locale carries its prefix in public URLs. `true`, the
+     * default, serves `/en/about` and `/fr/a-propos`; `false` serves `/about` and
+     * `/fr/a-propos`. The strings `"true"` and `"false"` are accepted too, so an
+     * environment variable can be passed as it is.
+     */
+    prefixDefaultLocale?: boolean | string | undefined;
+    /** The Lynkow API origin. Defaults to `https://api.lynkow.com`. */
+    apiUrl?: string | undefined;
+    /** The site's publishable key (`lkw_pk_...`), which storefront reads need. */
+    publishableKey?: string | undefined;
+}
+/** A validated configuration, frozen. Every field is safe to ship to the browser. */
+interface LynkowNextConfig {
+    readonly siteId: string;
+    /** The site's origin, with no trailing slash, so `${siteUrl}${path}` is always well formed. */
+    readonly siteUrl: string;
+    /** The API origin, with no trailing slash. */
+    readonly apiUrl: string;
+    readonly publishableKey: string | undefined;
+    /** The locales as configured, in their configured case. URLs carry them lowercased. */
+    readonly locales: readonly string[];
+    /** One of `locales`, in its configured case. */
+    readonly defaultLocale: string;
+    readonly prefixDefaultLocale: boolean;
+}
+/**
+ * Names to use for each field in error messages, such as the environment
+ * variable the application reads it from.
+ */
+type LynkowNextConfigLabels = Partial<Record<keyof LynkowNextConfigInput, string>>;
+/**
+ * Validates a configuration and fills in its defaults.
+ *
+ * It throws from a call the application made, never while this module is
+ * imported, so a site owner gets an error they can read rather than a stack
+ * trace out of a dependency's import graph.
+ *
+ * @param input - The values, typically read from the application's environment
+ * @param labels - Optional names for the fields in error messages, such as
+ *   `{ siteId: 'NEXT_PUBLIC_LYNKOW_SITE_ID' }`
+ * @throws {TypeError} Listing every problem found, one per line
+ *
+ * @example
+ * export const config = resolveConfig({
+ *   siteId: process.env.NEXT_PUBLIC_LYNKOW_SITE_ID,
+ *   siteUrl: process.env.NEXT_PUBLIC_SITE_URL,
+ *   locales: process.env.NEXT_PUBLIC_LOCALES,
+ * })
+ */
+declare function resolveConfig(input: LynkowNextConfigInput, labels?: LynkowNextConfigLabels): LynkowNextConfig;
+
+export { type LynkowNextConfig as L, type LynkowNextConfigInput as a, type LynkowNextConfigLabels as b, resolveConfig as r };

package/dist/image-loader.d.ts

@@ -0,0 +1,34 @@
+/** What `next/image` passes to a custom loader. */
+interface ImageLoaderParams {
+    src: string;
+    width: number;
+    quality?: number;
+}
+/**
+ * A `next/image` loader that resizes Lynkow media on the Lynkow CDN.
+ *
+ * Next's own optimizer downloads the original, resizes it on the app server
+ * and caches the result on that server's disk. Lynkow already resizes at the
+ * CDN edge, close to the visitor and cached there, so with this loader the app
+ * server never touches an image. Everything else about `next/image` stays:
+ * lazy loading, `priority`, reserved space, and the srcset Next builds by
+ * calling the loader once per candidate width.
+ *
+ * A relative URL, a file in `/public`, comes back unchanged: Lynkow media is
+ * always absolute, and the SDK recognises it by its path alone, so a local
+ * `/sites/logo.png` would otherwise be sent to a resizing endpoint this server
+ * does not have. An absolute URL whose path is not Lynkow media comes back
+ * unchanged too.
+ *
+ * Next wants a FILE for a custom loader, so re-export it from one:
+ *
+ * @example
+ * // src/image-loader.ts
+ * export { default } from '@lynkow/next/image-loader'
+ *
+ * // next.config.ts
+ * images: { loader: 'custom', loaderFile: './src/image-loader.ts' }
+ */
+declare function lynkowImageLoader({ src, width, quality }: ImageLoaderParams): string;
+
+export { type ImageLoaderParams, lynkowImageLoader as default, lynkowImageLoader };

package/dist/image-loader.js

@@ -0,0 +1,21 @@
+import { MediaHelperService } from 'lynkow';
+
+// src/image-loader.ts
+var media = new MediaHelperService();
+function lynkowImageLoader({ src, width, quality }) {
+  if (!/^https?:\/\//i.test(src)) return src;
+  return media.transform(src, {
+    w: width,
+    // `scale-down` never upscales, so a small original stays small rather than
+    // being blown up to the layout's widest candidate.
+    fit: "scale-down",
+    // The CDN negotiates the format from `Accept`, so a modern browser gets
+    // WebP or AVIF without the application knowing which.
+    format: "auto",
+    quality: quality ?? 80
+  }) || src;
+}
+
+export { lynkowImageLoader as default, lynkowImageLoader };
+//# sourceMappingURL=image-loader.js.map
+//# sourceMappingURL=image-loader.js.map

package/dist/image-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/image-loader.ts"],"names":[],"mappings":";;;AAGA,IAAM,KAAA,GAAQ,IAAI,kBAAA,EAAmB;AAkCtB,SAAR,iBAAA,CAAmC,EAAE,GAAA,EAAK,KAAA,EAAO,SAAQ,EAA8B;AAC5F,EAAA,IAAI,CAAC,eAAA,CAAgB,IAAA,CAAK,GAAG,GAAG,OAAO,GAAA;AACvC,EAAA,OACE,KAAA,CAAM,UAAU,GAAA,EAAK;AAAA,IACnB,CAAA,EAAG,KAAA;AAAA;AAAA;AAAA,IAGH,GAAA,EAAK,YAAA;AAAA;AAAA;AAAA,IAGL,MAAA,EAAQ,MAAA;AAAA,IACR,SAAS,OAAA,IAAW;AAAA,GACrB,CAAA,IAAK,GAAA;AAEV","file":"image-loader.js","sourcesContent":["import { MediaHelperService } from 'lynkow'\n\n/** Stateless and pure: it only rewrites a URL, so one instance serves every call. */\nconst media = new MediaHelperService()\n\n/** What `next/image` passes to a custom loader. */\nexport interface ImageLoaderParams {\n  src: string\n  width: number\n  quality?: number\n}\n\n/**\n * A `next/image` loader that resizes Lynkow media on the Lynkow CDN.\n *\n * Next's own optimizer downloads the original, resizes it on the app server\n * and caches the result on that server's disk. Lynkow already resizes at the\n * CDN edge, close to the visitor and cached there, so with this loader the app\n * server never touches an image. Everything else about `next/image` stays:\n * lazy loading, `priority`, reserved space, and the srcset Next builds by\n * calling the loader once per candidate width.\n *\n * A relative URL, a file in `/public`, comes back unchanged: Lynkow media is\n * always absolute, and the SDK recognises it by its path alone, so a local\n * `/sites/logo.png` would otherwise be sent to a resizing endpoint this server\n * does not have. An absolute URL whose path is not Lynkow media comes back\n * unchanged too.\n *\n * Next wants a FILE for a custom loader, so re-export it from one:\n *\n * @example\n * // src/image-loader.ts\n * export { default } from '@lynkow/next/image-loader'\n *\n * // next.config.ts\n * images: { loader: 'custom', loaderFile: './src/image-loader.ts' }\n */\nexport default function lynkowImageLoader({ src, width, quality }: ImageLoaderParams): string {\n  if (!/^https?:\\/\\//i.test(src)) return src\n  return (\n    media.transform(src, {\n      w: width,\n      // `scale-down` never upscales, so a small original stays small rather than\n      // being blown up to the layout's widest candidate.\n      fit: 'scale-down',\n      // The CDN negotiates the format from `Accept`, so a modern browser gets\n      // WebP or AVIF without the application knowing which.\n      format: 'auto',\n      quality: quality ?? 80,\n    }) || src\n  )\n}\n\nexport { lynkowImageLoader }\n"]}

package/dist/index.d.ts

@@ -0,0 +1,216 @@
+import { L as LynkowNextConfig } from './config-CwDV7jFS.js';
+export { a as LynkowNextConfigInput, b as LynkowNextConfigLabels, r as resolveConfig } from './config-CwDV7jFS.js';
+import { BaseRequestOptions, Client, AnalyticsEventType } from 'lynkow';
+export { AnalyticsEventType } from 'lynkow';
+
+/** An href that names its own scheme (`https:`, `mailto:`), or a protocol-relative one. */
+declare const ABSOLUTE_HREF: RegExp;
+/**
+ * The one place a public path gets its locale, bound to a configuration.
+ *
+ * Every localized path of a site goes through {@link LocalePaths.localePath}
+ * or {@link LocalePaths.fromApiPath}. That is what makes `prefixDefaultLocale`
+ * hold everywhere: a path built by hand as `/${locale}/...` is right with the
+ * flag on and wrong with it off.
+ */
+interface LocalePaths {
+    readonly locales: readonly string[];
+    readonly defaultLocale: string;
+    readonly prefixDefaultLocale: boolean;
+    /** The configured spelling of a locale, matched case-insensitively, or null. */
+    toLocale(value: string | null | undefined): string | null;
+    /** Whether a value names a configured locale, in any case. */
+    isLocale(value: string | null | undefined): value is string;
+    /**
+     * The locale a path belongs to. A path whose first segment names a locale
+     * belongs to it. Any other path belongs to the default locale when the
+     * default locale is served unprefixed, and to none otherwise. That includes
+     * paths that are not pages at all, such as `/_next/...`, so a caller that
+     * routes requests filters those first.
+     */
+    localeFromPath(pathname: string): string | null;
+    /**
+     * The public path of `path` in `locale`: `/fr/blog`, or `/blog` for the
+     * default locale when it is served unprefixed. The locale segment is written
+     * lowercased, as the API writes it. A query or fragment is kept. A leading
+     * run of slashes or backslashes collapses to one, so `//evil.example` stays a
+     * path once a default locale is stripped. Dot segments are left as written:
+     * `/.//evil.example` resolves to `//evil.example` in `new URL()`, so a caller
+     * that resolves the result checks the resolved path, as the proxy does.
+     *
+     * @throws {RangeError} When `locale` is not a configured locale.
+     */
+    localePath(locale: string, path?: string): string;
+    /**
+     * The public path of a path the API returned.
+     *
+     * On a multilingual site the API prefixes every path with its row's locale,
+     * the default one included, so `/en/blog/post` is mapped to `/blog/post`
+     * when the default locale is served unprefixed. A path with no locale
+     * segment, as on a single-locale site, belongs to `locale`. Anything that is
+     * not a root-relative path is returned unchanged.
+     */
+    fromApiPath(path: string, locale: string): string;
+    /**
+     * An href from CMS content, made to lead to `locale`.
+     *
+     * Navigation blocks store locale-agnostic hrefs (`/blog`, `/contact`), which
+     * is right for an editor, so the locale is added at render: without it every
+     * internal link goes through a redirect. An href that already names a locale
+     * keeps it, normalized like {@link fromApiPath}. Absolute URLs, `mailto:` and
+     * `tel:` links, anchors, query-only and relative hrefs are left untouched.
+     */
+    localizeHref(href: string, locale: string): string;
+    /**
+     * The locale a link leads to on this site, or null when it leads elsewhere:
+     * another origin, a `mailto:`, an anchor, a relative path. An absolute URL
+     * on the site's own origin counts as this site, which catches an editor's
+     * pasted `https://<site>/fr/...`.
+     */
+    hrefLocale(href: string): string | null;
+    /**
+     * The best match between an `Accept-Language` header and the configured
+     * locales, falling back to the default locale rather than to a 404.
+     */
+    negotiateLocale(acceptLanguage: string | null | undefined): string;
+    /** `path` on the site's origin. */
+    absoluteUrl(path: string): string;
+}
+/** Binds the locale path helpers to a configuration from {@link resolveConfig}. */
+declare function createLocalePaths(config: LynkowNextConfig): LocalePaths;
+
+/**
+ * The caching strategy of a Lynkow site on Next, in one file.
+ *
+ * Next 15 changed `fetch()` to be uncached by default, so nothing here is
+ * inherited: a read that does not pass one of these option bags hits the Lynkow
+ * API on every single request. Every data read in this app therefore goes
+ * through `cached()`. The durations are defaults tuned for a content site; a
+ * site that wants others passes its own number to `cached()`.
+ *
+ * Two mechanisms, deliberately combined:
+ *
+ *   - `revalidate` is the ceiling. Even with no webhook wired, content is never
+ *     more than this many seconds stale.
+ *   - `tags` are the floor. The revalidation webhook calls `revalidateTag()` so
+ *     an edit in the admin appears in seconds rather than minutes.
+ *
+ * A tag is only useful if the webhook actually sends the matching event, so the
+ * names here and the ones the revalidation handler maps MUST stay in step.
+ */
+
+/** Seconds. Tuned for a content site: rarely-changing structure lives longer. */
+declare const REVALIDATE: {
+    /** Site config and global blocks: header, footer, branding. */
+    readonly site: 3600;
+    /** Structural pages driven by site blocks. */
+    readonly page: 300;
+    /** Blog articles, categories, tags. */
+    readonly blog: 300;
+    /** Approved reviews. */
+    readonly reviews: 900;
+    /** Form schemas. */
+    readonly forms: 3600;
+    /** The cookie consent banner configuration. */
+    readonly consent: 3600;
+    /** sitemap.xml, robots.txt, llms.txt. */
+    readonly seo: 3600;
+    /** The path table used for static generation and redirect matching. */
+    readonly paths: 600;
+    /**
+     * One search result page.
+     *
+     * Short on purpose. Next keys its fetch cache on the full URL, so every
+     * distinct query is its own entry and a long ceiling would pin a large,
+     * unbounded set of them. The tag is what actually keeps results honest: a
+     * publish evicts every cached query at once.
+     */
+    readonly search: 60;
+};
+declare const TAGS: {
+    readonly site: "lynkow:site";
+    readonly pages: "lynkow:pages";
+    readonly page: (slug: string) => string;
+    readonly contents: "lynkow:contents";
+    readonly content: (slug: string) => string;
+    readonly categories: "lynkow:categories";
+    readonly tags: "lynkow:tags";
+    readonly reviews: "lynkow:reviews";
+    readonly forms: "lynkow:forms";
+    readonly form: (slug: string) => string;
+    readonly consent: "lynkow:consent";
+    readonly seo: "lynkow:seo";
+    readonly paths: "lynkow:paths";
+    readonly search: "lynkow:search";
+};
+/**
+ * Build the per-request options that put one Lynkow read into the Next cache.
+ *
+ * @example
+ * const page = await lynkow(locale).pages.getBySlug('home', cached([TAGS.page('home')], REVALIDATE.page))
+ */
+declare function cached(tags: string[], revalidate: number): BaseRequestOptions;
+/**
+ * For a read that must never be served from cache: a preview render, or a
+ * form schema fetched at submit time.
+ */
+declare function uncached(): BaseRequestOptions;
+
+/** Options of the client {@link LynkowClients} returns. */
+interface ClientOptions {
+    /**
+     * `false` returns a client that sends each read once instead of retrying a
+     * 429 or a 503. Defaults to `true`.
+     */
+    retry?: boolean;
+}
+/** Returns the Lynkow client of a locale, the default one when none is given. */
+type LynkowClients = (locale?: string, options?: ClientOptions) => Client;
+/**
+ * One Lynkow client per locale, reused across requests.
+ *
+ * The SDK's own cache stays OFF. On the server it is a process-global
+ * unbounded `Map`, which would duplicate and outlive Next's data cache without
+ * any of its invalidation. Caching is Next's job, expressed per read with
+ * `cached()`.
+ *
+ * `{ retry: false }` gives a second client for the locale, because the SDK's
+ * retry is a client setting rather than a per-read one. Only a read that
+ * already knows what to do when it fails should ask for it.
+ *
+ * FOR READS THAT ARE THE SAME FOR EVERY VISITOR. The clients are shared by
+ * every request the process serves, and the SDK keeps a buyer's state on the
+ * client instance: the guest cart token and the signed-in customer session.
+ * Calling `cart` or `customers` on one of these from server code would hand
+ * one visitor's cart or session to the next. Buyer flows run in the browser,
+ * or on a client created for that one request.
+ *
+ * A locale outside the configuration throws a `RangeError` instead of creating
+ * a client. The clients live as long as the process, so a locale taken from a
+ * URL and passed through unchecked would grow that set without bound. The
+ * locale is matched case-insensitively and the client gets its configured
+ * spelling.
+ */
+declare function createClients(config: LynkowNextConfig): LynkowClients;
+
+/**
+ * Sends one custom event through the tracker already on the page.
+ *
+ * `type` is a CLOSED enum of mechanical interactions, the SDK's
+ * `AnalyticsEventType`: there is no free-form event name. A value outside it is
+ * a compile error rather than a silently dropped row, since the collector
+ * answers `204` to a payload it rejects.
+ *
+ * Returns `false` when no tracker has loaded, which is never an error: on an
+ * `opt-in` site none loads before the visitor accepts analytics. `true` means
+ * the event was handed to the tracker, which adds the session id, the visitor
+ * id and the timestamp, and drops the event itself when the visitor refused on
+ * an `opt-in` or `opt-out` site.
+ *
+ * The tracker already records pageviews, scroll, clicks, form events and Core
+ * Web Vitals. Reach for this only for an interaction that escapes it, such as a
+ * form submitted through `fetch` without a real `submit` event.
+ */
+declare function trackEvent(type: AnalyticsEventType, data?: Record<string, unknown>): boolean;
+
+export { ABSOLUTE_HREF, type ClientOptions, type LocalePaths, type LynkowClients, LynkowNextConfig, REVALIDATE, TAGS, cached, createClients, createLocalePaths, trackEvent, uncached };