alinea 1.7.0 → 2.0.0-preview.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import "./chunks/chunk-NZLE2WMY.js";
+import "./chunks/chunk-CQ52GEHY.js";
 
 // src/index.ts
 import * as Config from "./config.js";

package/dist/next.cjs

@@ -27,18 +27,17 @@ module.exports = __toCommonJS(with_alinea_exports);
 var import_node_fs = require("node:fs");
 var import_node_module = require("node:module");
 var import_node_path = require("node:path");
-var import_Report = require("alinea/cli/util/Report");
 function createCMS() {
   throw new Error(
     'Alinea was loaded in a CJS environment. Please ensure your project is marked as "type": "module" in package.json.'
   );
 }
 function withAlinea(config = {}) {
-  if (!process.env.ALINEA_ADMIN_PATH) {
+  const adminPath = resolveAdminPath();
+  if (!adminPath) {
     console.warn(
-      "ALINEA_ADMIN_PATH environment variable is not set, did you run with the Alinea CLI?"
+      "Alinea dashboard settings could not be loaded; dashboard routing is disabled. Run Next.js through the Alinea CLI and deploy @alinea/generated."
     );
-    return config;
   }
   let nextVersion = 15;
   try {
@@ -61,9 +60,8 @@ function withAlinea(config = {}) {
     ...imagesConfig,
     remotePatterns
   };
-  const adminPath = normalizeBasePath(process.env.ALINEA_ADMIN_PATH);
-  const redirects = createRedirects(config, adminPath);
-  const rewrites = createRewrites(config, adminPath);
+  const redirects = adminPath ? createRedirects(config, adminPath) : config.redirects;
+  const rewrites = adminPath ? createRewrites(config, adminPath) : config.rewrites;
   if (nextVersion < 15)
     return {
       ...config,
@@ -120,8 +118,7 @@ function createRewrites(config, adminPath) {
     const location = origin ? new URL(adminPath, origin).href : adminPath;
     if (isDev && !process.env.__NEXT_PRIVATE_ALINEA_REPORTED) {
       process.env.__NEXT_PRIVATE_ALINEA_REPORTED = "true";
-      console.log(`
-${(0, import_Report.cyan)((0, import_Report.bold)("\u0251 Alinea CMS"))}:    ${location}
+      console.log(`${"- Alinea CMS"}:    ${location}
 `);
     }
     const existing = config.rewrites ? await config.rewrites() : [];
@@ -141,6 +138,7 @@ ${(0, import_Report.cyan)((0, import_Report.bold)("\u0251 Alinea CMS"))}:    ${l
     return {
       ...rewrites,
       afterFiles: [
+        ...rewrites.afterFiles,
         {
           source: adminPath,
           destination: `${adminPath}.html`
@@ -149,6 +147,18 @@ ${(0, import_Report.cyan)((0, import_Report.bold)("\u0251 Alinea CMS"))}:    ${l
     };
   };
 }
+function resolveAdminPath() {
+  try {
+    const require2 = (0, import_node_module.createRequire)((0, import_node_path.resolve)("./index.js"));
+    const location = require2.resolve("@alinea/generated/settings.json");
+    const settings = JSON.parse(
+      (0, import_node_fs.readFileSync)(location, "utf-8")
+    );
+    if (typeof settings.adminPath === "string" && settings.adminPath)
+      return normalizeBasePath(settings.adminPath);
+  } catch {
+  }
+}
 function normalizeBasePath(value) {
   return value.startsWith("/") ? value : `/${value}`;
 }

package/dist/next.edge.js

@@ -1,4 +1,4 @@
-import "./chunks/chunk-NZLE2WMY.js";
+import "./chunks/chunk-CQ52GEHY.js";
 
 // src/next.edge.ts
 import { createCMS } from "alinea/adapter/next/cms";

package/dist/next.js

@@ -1,4 +1,4 @@
-import "./chunks/chunk-NZLE2WMY.js";
+import "./chunks/chunk-CQ52GEHY.js";
 
 // src/next.ts
 import { createCMS } from "alinea/adapter/next/cms";

package/dist/picker/entry/EntryPicker.d.ts

@@ -17,20 +17,25 @@ export interface EditorInfo {
         locale: string | null;
     };
 }
-export interface EditorLocation {
-    parentId?: string;
+export interface EditorLimitLocation {
     workspace: string;
     root: string;
 }
+export interface EditorLocation extends EditorLimitLocation {
+    parentId?: string;
+    locale?: string;
+}
 type DynamicOption<T> = T | ((info: EditorInfo) => T | Promise<T>);
 export interface EntryPickerConditions {
     /** Choose from a flat list of direct children of the currently edited entry */
     pickChildren?: boolean;
     /** Set the initial location in which the entry picker is opened */
     location?: DynamicOption<EditorLocation>;
-    /** Filter entries by a condition, this results in a flat list of options */
+    /** Filter entries by a condition, shown as a flat list across all locations */
     condition?: DynamicOption<Filter<EntryFields>>;
-    /** @internal Enable entry picker navigation */
+    /** Limit the entry picker to an array of workspace and root locations */
+    limitLocations?: Array<EditorLimitLocation>;
+    /** @internal Start the entry picker at its selected location */
     enableNavigation?: boolean;
 }
 export interface EntryPickerOptions<Definition = {}> extends EntryPickerConditions {

package/dist/picker/entry/EntryPicker.js

@@ -1,23 +1,21 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/picker/entry/EntryPicker.ts
+import { Entry } from "alinea/core/Entry";
+import { MediaLocation } from "alinea/core/media/MediaLocation";
+import { MediaFile } from "alinea/core/media/MediaTypes";
 import { Reference } from "alinea/core/Reference";
+import { Root } from "alinea/core/Root";
 import { Type, type } from "alinea/core/Type";
-import { ListRow } from "alinea/core/shape/ListShape";
-import { RecordShape } from "alinea/core/shape/RecordShape";
-import { ScalarShape } from "alinea/core/shape/ScalarShape";
-import { assign, keys } from "alinea/core/util/Objects";
+import { ListRow } from "alinea/core/ListRow";
+import { applyUrlSuffix } from "alinea/core/util/Anchors";
+import { assign, isRecord, keys } from "alinea/core/util/Objects";
+import { selectLocalisedValue } from "alinea/field/localiser";
 import { EntryReference } from "./EntryReference.js";
-var unresolvedEntryMarker = Symbol("unresolvedEntryMarker");
+var unresolvedEntryMarker = /* @__PURE__ */ Symbol("unresolvedEntryMarker");
 function entryPicker(options) {
   const fieldType = Type.isType(options.fields) ? options.fields : options.fields && type("Entry fields", { fields: options.fields });
-  const extra = fieldType && Type.shape(fieldType);
   return {
-    shape: new RecordShape("Entry", {
-      [Reference.id]: new ScalarShape("Id"),
-      [Reference.type]: new ScalarShape("Type"),
-      [EntryReference.entry]: new ScalarShape("Entry")
-    }).concat(extra),
     fields: fieldType,
     label: options.label || "Page link",
     handlesMultiple: true,
@@ -27,6 +25,8 @@ function entryPicker(options) {
         [Reference.id]: id,
         [Reference.type]: type2,
         [EntryReference.entry]: entryId,
+        [EntryReference.anchor]: anchor,
+        [EntryReference.suffix]: suffix,
         [ListRow.index]: index,
         ...fields
       } = row;
@@ -38,21 +38,99 @@ function entryPicker(options) {
       }
       const linkIds = [entryId];
       if (!options.selection) return;
-      const [extra2] = await loader.resolveLinks(options.selection, linkIds);
-      if (!extra2) {
+      const selection = {
+        ...options.selection,
+        _media: {
+          entryUrl: Entry.url,
+          extension: MediaFile.extension,
+          location: MediaFile.location,
+          path: Entry.path,
+          root: Entry.root,
+          workspace: Entry.workspace
+        }
+      };
+      const [extra] = await loader.resolveLinks(selection, linkIds);
+      if (!extra) {
         row[unresolvedEntryMarker] = true;
         return;
       }
-      if (type2 !== "image") return assign(row, extra2);
-      const { src: location, previewUrl, filePath, ...rest } = extra2;
-      if (!previewUrl) return assign(row, extra2, { src: location });
+      const { _media: media, ...selected } = extra;
+      if (type2 === "file") {
+        const {
+          extension: extension2,
+          href: _href,
+          root: _root2,
+          url,
+          workspace: _workspace2,
+          ...rest2
+        } = selected;
+        const mediaUrl2 = MediaLocation.publicUrl(loader.resolver.config, media);
+        assign(row, rest2, { extension: extension2 });
+        row.href = mediaUrl2;
+        if (typeof url === "string") row.url = mediaUrl2;
+        return;
+      }
+      if (type2 !== "image") {
+        assign(row, selected);
+        applyUrlSuffixToRow(row, suffix, anchor);
+        return;
+      }
+      const {
+        extension,
+        src: _location,
+        previewUrl,
+        filePath,
+        alt,
+        root: _root,
+        workspace: _workspace,
+        ...rest
+      } = selected;
+      const mediaUrl = MediaLocation.publicUrl(loader.resolver.config, media);
+      const selectedAlt = selectImageAlt(alt, loader, {
+        root: media.root,
+        workspace: media.workspace
+      });
+      if (!previewUrl) {
+        assign(row, rest, { extension, src: mediaUrl });
+        if (typeof selectedAlt === "string") row.alt = selectedAlt;
+        return;
+      }
       const locationAvailable = loader.includedAtBuild(filePath);
-      const src = locationAvailable ? location : previewUrl;
-      row.src = src;
+      row.src = locationAvailable ? mediaUrl : previewUrl;
+      row.extension = extension;
+      if (typeof selectedAlt === "string") row.alt = selectedAlt;
       assign(row, rest);
     }
   };
 }
+function applyUrlSuffixToRow(row, suffix, anchor) {
+  if (typeof row.url === "string")
+    row.url = applyUrlSuffix(row.url, suffix, anchor);
+  if (typeof row.href === "string")
+    row.href = applyUrlSuffix(row.href, suffix, anchor);
+}
+function selectImageAlt(alt, loader, location) {
+  if (isRecord(alt)) {
+    const localisation = linkedLocalisation(loader, location);
+    return selectLocalisedValue({
+      value: alt,
+      locale: loader.locale,
+      locales: localisation?.locales ?? keys(alt),
+      fallback: localisation?.fallback,
+      defaultValue: ""
+    });
+  }
+  if (typeof alt === "string") return alt;
+  return "";
+}
+function linkedLocalisation(loader, { workspace, root }) {
+  if (typeof workspace !== "string" || typeof root !== "string") return;
+  const workspaceConfig = loader.resolver.config.workspaces[workspace];
+  const rootConfig = workspaceConfig?.[root];
+  if (!rootConfig) return;
+  const rootData = Root.data(rootConfig);
+  return Root.mediaI18n(rootData) ?? rootData.i18n;
+}
 export {
   entryPicker,
   unresolvedEntryMarker

package/dist/picker/entry/EntryReference.d.ts

@@ -2,8 +2,12 @@ import type { Reference } from 'alinea/core/Reference';
 export interface EntryReference extends Reference {
     _type: 'entry' | 'image' | 'file';
     _entry: string;
+    _anchor?: string;
+    _suffix?: string;
 }
 export declare namespace EntryReference {
     const entry = "_entry";
+    const anchor = "_anchor";
+    const suffix = "_suffix";
     function isEntryReference(value: any): value is EntryReference;
 }

package/dist/picker/entry/EntryReference.js

@@ -1,9 +1,11 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/picker/entry/EntryReference.ts
 var EntryReference;
 ((EntryReference2) => {
   EntryReference2.entry = "_entry";
+  EntryReference2.anchor = "_anchor";
+  EntryReference2.suffix = "_suffix";
   function isEntryReference(value) {
     return value && EntryReference2.entry in value;
   }

package/dist/picker/url/UrlPicker.js

@@ -1,11 +1,9 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/picker/url/UrlPicker.ts
 import { Reference } from "alinea/core/Reference";
 import { Type, type } from "alinea/core/Type";
-import { ListRow } from "alinea/core/shape/ListShape";
-import { RecordShape } from "alinea/core/shape/RecordShape";
-import { ScalarShape } from "alinea/core/shape/ScalarShape";
+import { ListRow } from "alinea/core/ListRow";
 import { keys } from "alinea/core/util/Objects";
 var UrlReference;
 ((UrlReference2) => {
@@ -19,15 +17,7 @@ var UrlReference;
 })(UrlReference || (UrlReference = {}));
 function urlPicker(options) {
   const fieldType = Type.isType(options.fields) ? options.fields : options.fields && type("URL fields", { fields: options.fields });
-  const extra = fieldType && Type.shape(fieldType);
   return {
-    shape: new RecordShape("Url", {
-      [Reference.id]: new ScalarShape("Id"),
-      [Reference.type]: new ScalarShape("Type"),
-      [UrlReference.url]: new ScalarShape("Url"),
-      [UrlReference.title]: new ScalarShape("Title"),
-      [UrlReference.target]: new ScalarShape("Target")
-    }).concat(extra),
     label: "External link",
     handlesMultiple: false,
     fields: fieldType,

package/dist/preview/ChunkCookieValue.js

@@ -1,4 +1,4 @@
-import "../chunks/chunk-NZLE2WMY.js";
+import "../chunks/chunk-CQ52GEHY.js";
 
 // src/preview/ChunkCookieValue.ts
 var MAX_COOKIE_LENGTH = 4096;

package/dist/preview/PreviewCookies.js

@@ -1,4 +1,4 @@
-import "../chunks/chunk-NZLE2WMY.js";
+import "../chunks/chunk-CQ52GEHY.js";
 
 // src/preview/PreviewCookies.ts
 import { chunkCookieValue, parseChunkedCookies } from "./ChunkCookieValue.js";

package/dist/preview/PreviewMessage.js

@@ -1,4 +1,4 @@
-import "../chunks/chunk-NZLE2WMY.js";
+import "../chunks/chunk-CQ52GEHY.js";
 
 // src/preview/PreviewMessage.ts
 var PreviewAction = /* @__PURE__ */ ((PreviewAction2) => {

package/dist/preview/PreviewPayload.js

@@ -1,16 +1,243 @@
-import {
-  createDecoder,
-  createEncoder,
-  readVarString,
-  readVarUint8Array,
-  toUint8Array,
-  writeVarString,
-  writeVarUint8Array
-} from "../chunks/chunk-AJJSW27C.js";
-import "../chunks/chunk-NZLE2WMY.js";
+import "../chunks/chunk-CQ52GEHY.js";
 
 // src/preview/PreviewPayload.ts
 import { decode, encode } from "alinea/core/util/BufferToBase64";
+
+// node_modules/lib0/binary.js
+var BIT8 = 128;
+var BIT18 = 1 << 17;
+var BIT19 = 1 << 18;
+var BIT20 = 1 << 19;
+var BIT21 = 1 << 20;
+var BIT22 = 1 << 21;
+var BIT23 = 1 << 22;
+var BIT24 = 1 << 23;
+var BIT25 = 1 << 24;
+var BIT26 = 1 << 25;
+var BIT27 = 1 << 26;
+var BIT28 = 1 << 27;
+var BIT29 = 1 << 28;
+var BIT30 = 1 << 29;
+var BIT31 = 1 << 30;
+var BIT32 = 1 << 31;
+var BITS7 = 127;
+var BITS17 = BIT18 - 1;
+var BITS18 = BIT19 - 1;
+var BITS19 = BIT20 - 1;
+var BITS20 = BIT21 - 1;
+var BITS21 = BIT22 - 1;
+var BITS22 = BIT23 - 1;
+var BITS23 = BIT24 - 1;
+var BITS24 = BIT25 - 1;
+var BITS25 = BIT26 - 1;
+var BITS26 = BIT27 - 1;
+var BITS27 = BIT28 - 1;
+var BITS28 = BIT29 - 1;
+var BITS29 = BIT30 - 1;
+var BITS30 = BIT31 - 1;
+
+// node_modules/lib0/math.js
+var floor = Math.floor;
+var min = (a, b) => a < b ? a : b;
+var max = (a, b) => a > b ? a : b;
+var isNaN = Number.isNaN;
+
+// node_modules/lib0/number.js
+var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
+var MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER;
+var LOWEST_INT32 = 1 << 31;
+var isInteger = Number.isInteger || ((num) => typeof num === "number" && isFinite(num) && floor(num) === num);
+var isNaN2 = Number.isNaN;
+var parseInt = Number.parseInt;
+
+// node_modules/lib0/string.js
+var fromCharCode = String.fromCharCode;
+var fromCodePoint = String.fromCodePoint;
+var MAX_UTF16_CHARACTER = fromCharCode(65535);
+var _encodeUtf8Polyfill = (str) => {
+  const encodedString = unescape(encodeURIComponent(str));
+  const len = encodedString.length;
+  const buf = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    buf[i] = /** @type {number} */
+    encodedString.codePointAt(i);
+  }
+  return buf;
+};
+var utf8TextEncoder = (
+  /** @type {TextEncoder} */
+  typeof TextEncoder !== "undefined" ? new TextEncoder() : null
+);
+var _encodeUtf8Native = (str) => utf8TextEncoder.encode(str);
+var encodeUtf8 = utf8TextEncoder ? _encodeUtf8Native : _encodeUtf8Polyfill;
+var utf8TextDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {
+  utf8TextDecoder = null;
+}
+
+// node_modules/lib0/error.js
+var create = (s) => new Error(s);
+
+// node_modules/lib0/encoding.js
+var Encoder = class {
+  constructor() {
+    this.cpos = 0;
+    this.cbuf = new Uint8Array(100);
+    this.bufs = [];
+  }
+};
+var createEncoder = () => new Encoder();
+var length = (encoder) => {
+  let len = encoder.cpos;
+  for (let i = 0; i < encoder.bufs.length; i++) {
+    len += encoder.bufs[i].length;
+  }
+  return len;
+};
+var toUint8Array = (encoder) => {
+  const uint8arr = new Uint8Array(length(encoder));
+  let curPos = 0;
+  for (let i = 0; i < encoder.bufs.length; i++) {
+    const d = encoder.bufs[i];
+    uint8arr.set(d, curPos);
+    curPos += d.length;
+  }
+  uint8arr.set(new Uint8Array(encoder.cbuf.buffer, 0, encoder.cpos), curPos);
+  return uint8arr;
+};
+var write = (encoder, num) => {
+  const bufferLen = encoder.cbuf.length;
+  if (encoder.cpos === bufferLen) {
+    encoder.bufs.push(encoder.cbuf);
+    encoder.cbuf = new Uint8Array(bufferLen * 2);
+    encoder.cpos = 0;
+  }
+  encoder.cbuf[encoder.cpos++] = num;
+};
+var writeVarUint = (encoder, num) => {
+  while (num > BITS7) {
+    write(encoder, BIT8 | BITS7 & num);
+    num = floor(num / 128);
+  }
+  write(encoder, BITS7 & num);
+};
+var _strBuffer = new Uint8Array(3e4);
+var _maxStrBSize = _strBuffer.length / 3;
+var _writeVarStringNative = (encoder, str) => {
+  if (str.length < _maxStrBSize) {
+    const written = utf8TextEncoder.encodeInto(str, _strBuffer).written || 0;
+    writeVarUint(encoder, written);
+    for (let i = 0; i < written; i++) {
+      write(encoder, _strBuffer[i]);
+    }
+  } else {
+    writeVarUint8Array(encoder, encodeUtf8(str));
+  }
+};
+var _writeVarStringPolyfill = (encoder, str) => {
+  const encodedString = unescape(encodeURIComponent(str));
+  const len = encodedString.length;
+  writeVarUint(encoder, len);
+  for (let i = 0; i < len; i++) {
+    write(
+      encoder,
+      /** @type {number} */
+      encodedString.codePointAt(i)
+    );
+  }
+};
+var writeVarString = utf8TextEncoder && /** @type {any} */
+utf8TextEncoder.encodeInto ? _writeVarStringNative : _writeVarStringPolyfill;
+var writeUint8Array = (encoder, uint8Array) => {
+  const bufferLen = encoder.cbuf.length;
+  const cpos = encoder.cpos;
+  const leftCopyLen = min(bufferLen - cpos, uint8Array.length);
+  const rightCopyLen = uint8Array.length - leftCopyLen;
+  encoder.cbuf.set(uint8Array.subarray(0, leftCopyLen), cpos);
+  encoder.cpos += leftCopyLen;
+  if (rightCopyLen > 0) {
+    encoder.bufs.push(encoder.cbuf);
+    encoder.cbuf = new Uint8Array(max(bufferLen * 2, rightCopyLen));
+    encoder.cbuf.set(uint8Array.subarray(leftCopyLen));
+    encoder.cpos = rightCopyLen;
+  }
+};
+var writeVarUint8Array = (encoder, uint8Array) => {
+  writeVarUint(encoder, uint8Array.byteLength);
+  writeUint8Array(encoder, uint8Array);
+};
+var floatTestBed = new DataView(new ArrayBuffer(4));
+
+// node_modules/lib0/decoding.js
+var errorUnexpectedEndOfArray = create("Unexpected end of array");
+var errorIntegerOutOfRange = create("Integer out of Range");
+var Decoder = class {
+  /**
+   * @param {Uint8Array} uint8Array Binary data to decode
+   */
+  constructor(uint8Array) {
+    this.arr = uint8Array;
+    this.pos = 0;
+  }
+};
+var createDecoder = (uint8Array) => new Decoder(uint8Array);
+var readUint8Array = (decoder, len) => {
+  const view = new Uint8Array(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
+  decoder.pos += len;
+  return view;
+};
+var readVarUint8Array = (decoder) => readUint8Array(decoder, readVarUint(decoder));
+var readUint8 = (decoder) => decoder.arr[decoder.pos++];
+var readVarUint = (decoder) => {
+  let num = 0;
+  let mult = 1;
+  const len = decoder.arr.length;
+  while (decoder.pos < len) {
+    const r = decoder.arr[decoder.pos++];
+    num = num + (r & BITS7) * mult;
+    mult *= 128;
+    if (r < BIT8) {
+      return num;
+    }
+    if (num > MAX_SAFE_INTEGER) {
+      throw errorIntegerOutOfRange;
+    }
+  }
+  throw errorUnexpectedEndOfArray;
+};
+var _readVarStringPolyfill = (decoder) => {
+  let remainingLen = readVarUint(decoder);
+  if (remainingLen === 0) {
+    return "";
+  } else {
+    let encodedString = String.fromCodePoint(readUint8(decoder));
+    if (--remainingLen < 100) {
+      while (remainingLen--) {
+        encodedString += String.fromCodePoint(readUint8(decoder));
+      }
+    } else {
+      while (remainingLen > 0) {
+        const nextLen = remainingLen < 1e4 ? remainingLen : 1e4;
+        const bytes = decoder.arr.subarray(decoder.pos, decoder.pos + nextLen);
+        decoder.pos += nextLen;
+        encodedString += String.fromCodePoint.apply(
+          null,
+          /** @type {any} */
+          bytes
+        );
+        remainingLen -= nextLen;
+      }
+    }
+    return decodeURIComponent(escape(encodedString));
+  }
+};
+var _readVarStringNative = (decoder) => (
+  /** @type any */
+  utf8TextDecoder.decode(readVarUint8Array(decoder))
+);
+var readVarString = utf8TextDecoder ? _readVarStringNative : _readVarStringPolyfill;
+
+// src/preview/PreviewPayload.ts
 function encodePreviewPayload(update) {
   const encoder = createEncoder();
   writeVarString(encoder, update.locale ?? "");

package/dist/preview/RegisterPreview.js

@@ -1,4 +1,4 @@
-import "../chunks/chunk-NZLE2WMY.js";
+import "../chunks/chunk-CQ52GEHY.js";
 
 // src/preview/RegisterPreview.ts
 import { PreviewAction } from "alinea/preview/PreviewMessage";

package/dist/preview/react.js

@@ -1,12 +1,19 @@
-import "../chunks/chunk-NZLE2WMY.js";
+import "../chunks/chunk-CQ52GEHY.js";
 
 // src/preview/react.ts
-import { useEffect, useState } from "react";
+import { useEffect, useRef, useState } from "react";
 import { registerPreview } from "./RegisterPreview.js";
 function usePreview(api) {
   const [isPreviewing, setIsPreviewing] = useState(false);
+  const apiRef = useRef(api);
+  apiRef.current = api;
   useEffect(() => {
-    return registerPreview({ ...api, setIsPreviewing });
+    return registerPreview({
+      preview(update) {
+        return apiRef.current.preview(update);
+      },
+      setIsPreviewing
+    });
   }, []);
   return { isPreviewing };
 }

package/dist/preview/widget.js

@@ -1,4 +1,4 @@
-import "../chunks/chunk-NZLE2WMY.js";
+import "../chunks/chunk-CQ52GEHY.js";
 
 // src/preview/widget.ts
 function registerPreviewWidget() {