@sanity/sdk 2.0.0 → 2.0.2

package/README.md

@@ -1,6 +1,6 @@
 <p align="center">
   <a href="https://sanity.io">
-    <img src="https://cdn.sanity.io/images/3do82whm/next/1dfce9dde7a62ccaa8e8377254a1e919f6c07ad3-128x128.svg" />
+    <img src="https://cdn.sanity.io/images/3do82whm/next/d6cf401d52c33b7a5a354a14ab7de94dea2f0c02-192x192.svg" />
   </a>
   <h1 align="center">Sanity App SDK (Core)</h1>
 </p>

package/dist/index.d.ts

@@ -1207,6 +1207,16 @@ export declare const getFavoritesState: BoundStoreAction<
   StateSource_2<FavoriteStatusResponse | undefined>
 >
 
+/**
+ * Returns a state source indicating if the SDK is running within a dashboard context.
+ * @public
+ */
+export declare const getIsInDashboardState: BoundStoreAction<
+  AuthStoreState,
+  [],
+  StateSource_2<boolean>
+>
+
 /**
  * @public
  */
@@ -1248,6 +1258,18 @@ export declare const getOrCreateController: BoundStoreAction_2<
   Controller
 >
 
+/**
+ * Retrieve or create a node to be used for communication between
+ * an application and the controller -- specifically, a node should
+ * be created within a frame / window to communicate with the controller.
+ * @public
+ */
+export declare const getOrCreateNode: BoundStoreAction_2<
+  ComlinkNodeState,
+  [options: NodeInput],
+  Node_2<Message, Message>
+>
+
 /** @beta */
 export declare const getPermissionsState: BoundStoreAction<
   DocumentStoreState,
@@ -1632,6 +1654,18 @@ declare interface NegNode extends BaseNode {
   base: ExprNode
 }
 
+/**
+ * Message from Parent (dashboard) to SDK (iframe) with the new token
+ * @internal
+ */
+export declare type NewTokenResponseMessage = {
+  type: 'dashboard/v1/auth/tokens/create'
+  payload: {
+    token: string | null
+    error?: string
+  }
+}
+
 /**
  * Individual node with its relevant options
  * @public
@@ -2011,6 +2045,12 @@ export declare type ReleaseDocument = SanityDocument & {
   }
 }
 
+/**
+ * Signals to the store that the consumer has stopped using the node
+ * @public
+ */
+export declare const releaseNode: BoundStoreAction_2<ComlinkNodeState, [name: string], void>
+
 /**
  * @public
  */
@@ -2024,6 +2064,15 @@ declare interface ReleasesStoreState {
   error?: unknown
 }
 
+/**
+ * Message from SDK (iframe) to Parent (dashboard) to request a new token
+ * @internal
+ */
+export declare type RequestNewTokenMessage = {
+  type: 'dashboard/v1/auth/tokens/create'
+  payload?: undefined
+}
+
 /** @public */
 export declare const resolveDatasets: BoundStoreAction<
   FetcherStoreState_2<[options?: ProjectHandle<string> | undefined], DatasetsResponse>,
@@ -2353,6 +2402,13 @@ declare interface SelectorNode extends BaseNode {
   type: 'Selector'
 }
 
+/**
+ * Action to explicitly set the authentication token.
+ * Used internally by the Comlink token refresh.
+ * @internal
+ */
+export declare const setAuthToken: BoundStoreAction<AuthStoreState, [token: string | null], void>
+
 declare interface SharedListener {
   events: Observable<ListenEvent<SanityDocument_3>>
   dispose: () => void

package/dist/index.js

@@ -8,7 +8,8 @@ import { createController, createNode } from "@sanity/comlink";
 import { createSelector } from "reselect";
 import { SanityEncoder } from "@sanity/mutate";
 import { getPublishedId as getPublishedId$1 } from "@sanity/client/csm";
-import { applyPatches, parsePatch, makePatches, stringifyPatches } from "@sanity/diff-match-patch";
+import { diffValue } from "@sanity/diff-patch";
+import { applyPatches, parsePatch } from "@sanity/diff-match-patch";
 import { isKeySegment, isKeyedObject } from "@sanity/types";
 import { createDocumentLoaderFromClient } from "@sanity/mutate/_unstable_store";
 import { SDK_CHANNEL_NAME, SDK_NODE_NAME } from "@sanity/message-protocol";
@@ -487,7 +488,28 @@ const authStore = {
 ), getDashboardOrganizationId$1 = bindActionGlobally(
   authStore,
   createStateSourceAction(({ state: { dashboardContext } }) => dashboardContext?.orgId)
-);
+), getIsInDashboardState = bindActionGlobally(
+  authStore,
+  createStateSourceAction(
+    ({ state: { dashboardContext } }) => (
+      // Check if dashboardContext exists and is not empty
+      !!dashboardContext && Object.keys(dashboardContext).length > 0
+    )
+  )
+), setAuthToken = bindActionGlobally(authStore, ({ state }, token) => {
+  const currentAuthState = state.get().authState;
+  token ? (currentAuthState.type !== AuthStateType.LOGGED_IN || currentAuthState.token !== token) && state.set("setToken", {
+    authState: {
+      type: AuthStateType.LOGGED_IN,
+      token,
+      // Keep existing user or set to null? Setting to null forces refetch.
+      // Keep existing user to avoid unnecessary refetches if user data is still valid.
+      currentUser: currentAuthState.type === AuthStateType.LOGGED_IN ? currentAuthState.currentUser : null
+    }
+  }) : currentAuthState.type !== AuthStateType.LOGGED_OUT && state.set("setToken", {
+    authState: { type: AuthStateType.LOGGED_OUT, isDestroyingSession: !1 }
+  });
+});
 function compareProjectOrganization(projectId, projectOrganizationId, currentDashboardOrgId) {
   return projectOrganizationId !== currentDashboardOrgId ? {
     error: `Project ${projectId} belongs to Organization ${projectOrganizationId ?? "unknown"}, but the Dashboard has Organization ${currentDashboardOrgId} selected`
@@ -1127,16 +1149,13 @@ function matchRecursive(value, path, currentPath) {
     if (!Array.isArray(value))
       return [];
     const [start, end] = head, startIndex = start === "" ? 0 : start, endIndex = end === "" ? value.length : end;
-    let results = [];
-    for (let i2 = startIndex; i2 < endIndex; i2++)
-      results = results.concat(matchRecursive(value[i2], rest, [...currentPath, i2]));
-    return results;
+    return value.slice(startIndex, endIndex).flatMap((item, i2) => matchRecursive(item, rest, [...currentPath, i2 + startIndex]));
   }
-  const arrIndex = getIndexForKey(value, head._key);
+  const keyed = head, arrIndex = getIndexForKey(value, keyed._key);
   if (arrIndex === void 0 || !Array.isArray(value))
     return [];
   const nextVal = value[arrIndex];
-  return matchRecursive(nextVal, rest, [...currentPath, arrIndex]);
+  return matchRecursive(nextVal, rest, [...currentPath, { _key: keyed._key }]);
 }
 function generateArrayKey(length = 12) {
   const numBytes = Math.ceil(length / 2), bytes = crypto.getRandomValues(new Uint8Array(numBytes));
@@ -1176,69 +1195,65 @@ function setIfMissing(input, pathExpressionValues) {
   return ensureArrayKeysDeep(result);
 }
 function unset(input, pathExpressions) {
-  const result = pathExpressions.flatMap((pathExpression) => jsonMatch(input, pathExpression)).reduce((acc, { path }) => unsetDeep(acc, path), input);
+  const result = pathExpressions.flatMap((pathExpression) => jsonMatch(input, pathExpression)).reverse().reduce((acc, { path }) => unsetDeep(acc, path), input);
   return ensureArrayKeysDeep(result);
 }
-const operations = ["before", "after", "replace"];
-function insert(input, insertPatch) {
-  const operation = operations.find((op) => op in insertPatch);
-  if (!operation) return input;
-  const { items } = insertPatch, pathExpression = insertPatch[operation];
-  if (typeof pathExpression != "string") return input;
-  function normalizeIndex(index, parentLength) {
-    switch (operation) {
-      case "before":
-        return index < 0 ? parentLength : index;
-      case "after":
-        return index < 0 ? -1 : index;
-      default:
-        return index < 0 ? parentLength + index : index;
-    }
-  }
-  const grouped = /* @__PURE__ */ new Map();
-  jsonMatch(input, pathExpression).map(({ path }) => {
-    const segment = path[path.length - 1];
-    let index;
-    if (isKeySegment(segment) ? index = getIndexForKey(input, segment._key) : typeof segment == "number" && (index = segment), typeof index != "number") return null;
-    const parentPath = path.slice(0, path.length - 1), parent = getDeep(input, parentPath);
-    if (!Array.isArray(parent)) return null;
-    const normalizedIndex = normalizeIndex(index, parent.length);
-    return { parent, parentPath, normalizedIndex };
-  }).filter(isNonNullable).forEach(({ parent, parentPath, normalizedIndex }) => {
-    grouped.has(parent) ? grouped.get(parent).indexes.push(normalizedIndex) : grouped.set(parent, { array: parent, pathToArray: parentPath, indexes: [normalizedIndex] });
-  });
-  const result = Array.from(grouped.values()).map((entry) => ({
-    ...entry,
-    indexes: entry.indexes.sort((a2, b2) => a2 - b2)
-  })).reduce((acc, { array, indexes, pathToArray }) => {
+function insert(input, { items, ...insertPatch }) {
+  let operation, pathExpression;
+  if ("before" in insertPatch ? (operation = "before", pathExpression = insertPatch.before) : "after" in insertPatch ? (operation = "after", pathExpression = insertPatch.after) : "replace" in insertPatch && (operation = "replace", pathExpression = insertPatch.replace), !operation || typeof pathExpression != "string") return input;
+  const parsedPath = parsePath(pathExpression);
+  if (!parsedPath.length) return input;
+  const arrayPath = stringifyPath(parsedPath.slice(0, -1)), positionPath = stringifyPath(parsedPath.slice(-1)), arrayMatches = jsonMatch(input, arrayPath);
+  let result = input;
+  for (const { path, value } of arrayMatches) {
+    if (!Array.isArray(value)) continue;
+    let arr = value;
     switch (operation) {
+      case "replace": {
+        const indexesToRemove = /* @__PURE__ */ new Set();
+        let position = 1 / 0;
+        for (const itemMatch of jsonMatch(arr, positionPath)) {
+          if (itemMatch.path.length !== 1) continue;
+          const [segment] = itemMatch.path;
+          if (typeof segment == "string") continue;
+          let index;
+          typeof segment == "number" && (index = segment), typeof index == "number" && index < 0 && (index = arr.length + index), isKeySegment(segment) && (index = getIndexForKey(arr, segment._key)), typeof index == "number" && (index < 0 && (index = arr.length + index), indexesToRemove.add(index), index < position && (position = index));
+        }
+        if (position === 1 / 0) continue;
+        arr = arr.map((item, index) => ({ item, index })).filter(({ index }) => !indexesToRemove.has(index)).map(({ item }) => item), arr = [...arr.slice(0, position), ...items, ...arr.slice(position, arr.length)];
+        break;
+      }
       case "before": {
-        const firstIndex = indexes[0];
-        return setDeep(acc, pathToArray, [
-          ...array.slice(0, firstIndex),
-          ...items,
-          ...array.slice(firstIndex)
-        ]);
+        let position = 1 / 0;
+        for (const itemMatch of jsonMatch(arr, positionPath)) {
+          if (itemMatch.path.length !== 1) continue;
+          const [segment] = itemMatch.path;
+          if (typeof segment == "string") continue;
+          let index;
+          typeof segment == "number" && (index = segment), typeof index == "number" && index < 0 && (index = arr.length + index), isKeySegment(segment) && (index = getIndexForKey(arr, segment._key)), typeof index == "number" && (index < 0 && (index = arr.length - index), index < position && (position = index));
+        }
+        if (position === 1 / 0) continue;
+        arr = [...arr.slice(0, position), ...items, ...arr.slice(position, arr.length)];
+        break;
       }
       case "after": {
-        const lastIndex = indexes[indexes.length - 1] + 1;
-        return setDeep(acc, pathToArray, [
-          ...array.slice(0, lastIndex),
-          ...items,
-          ...array.slice(lastIndex)
-        ]);
-      }
-      // default to 'replace' behavior
-      default: {
-        const firstIndex = indexes[0], indexSet = new Set(indexes);
-        return setDeep(acc, pathToArray, [
-          ...array.slice(0, firstIndex),
-          ...items,
-          ...array.slice(firstIndex).filter((_2, idx) => !indexSet.has(idx + firstIndex))
-        ]);
+        let position = -1 / 0;
+        for (const itemMatch of jsonMatch(arr, positionPath)) {
+          if (itemMatch.path.length !== 1) continue;
+          const [segment] = itemMatch.path;
+          if (typeof segment == "string") continue;
+          let index;
+          typeof segment == "number" && (index = segment), typeof index == "number" && index < 0 && (index = arr.length + index), isKeySegment(segment) && (index = getIndexForKey(arr, segment._key)), typeof index == "number" && index > position && (position = index);
+        }
+        if (position === -1 / 0) continue;
+        arr = [...arr.slice(0, position + 1), ...items, ...arr.slice(position + 1, arr.length)];
+        break;
       }
+      default:
+        continue;
     }
-  }, input);
+    result = setDeep(result, path, arr);
+  }
   return ensureArrayKeysDeep(result);
 }
 function inc(input, pathExpressionValues) {
@@ -1282,9 +1297,6 @@ function ifRevisionID(input, revisionId) {
     );
   return input;
 }
-function isNonNullable(t2) {
-  return t2 != null;
-}
 const indexCache = /* @__PURE__ */ new WeakMap();
 function getIndexForKey(input, key) {
   if (!Array.isArray(input)) return;
@@ -1293,15 +1305,6 @@ function getIndexForKey(input, key) {
   const lookup = input.reduce((acc, next, index) => (typeof next?._key == "string" && (acc[next._key] = index), acc), {});
   return indexCache.set(input, lookup), lookup[key];
 }
-function getDeep(input, path) {
-  const [currentSegment, ...restOfPath] = path;
-  if (currentSegment === void 0) return input;
-  if (typeof input != "object" || input === null) return;
-  let key;
-  if (isKeySegment(currentSegment) ? key = getIndexForKey(input, currentSegment._key) : (typeof currentSegment == "string" || typeof currentSegment == "number") && (key = currentSegment), key === void 0) return;
-  const nestedInput = typeof key == "number" && Array.isArray(input) ? input.at(key) : input[key];
-  return getDeep(nestedInput, restOfPath);
-}
 function setDeep(input, path, value) {
   const [currentSegment, ...restOfPath] = path;
   if (currentSegment === void 0) return value;
@@ -3262,125 +3265,6 @@ function Ae(e3, t2 = {}) {
   if (r2.type === "error") throw new _e(r2.position);
   return new K(e3, r2.marks, t2).process(me);
 }
-const isRecord = (value) => typeof value == "object" && !!value && !Array.isArray(value), ignoredKeys = ["_id", "_type", "_createdAt", "_updatedAt", "_rev"];
-function diffPatch(before, after) {
-  return diffRecursive(before, after, []);
-}
-function diffRecursive(before, after, path) {
-  if (before === after) return [];
-  const patches = [], pathStr = stringifyPath(path);
-  if (before === null || after === null)
-    return before !== after && patches.push({ set: { [pathStr]: after } }), patches;
-  if (typeof before != typeof after || Array.isArray(before) !== Array.isArray(after))
-    return patches.push({ set: { [pathStr]: after } }), patches;
-  if (typeof before == "string" && typeof after == "string") {
-    const dmpPatches = makePatches(before, after), patchStr = stringifyPatches(dmpPatches);
-    return patches.push({ diffMatchPatch: { [pathStr]: patchStr } }), patches;
-  }
-  if (typeof before == "number" && typeof after == "number")
-    return patches.push({ set: { [pathStr]: after } }), patches;
-  if (typeof before != "object")
-    return before !== after && patches.push({ set: { [pathStr]: after } }), patches;
-  if (Array.isArray(before) && Array.isArray(after))
-    return patches.push(...diffArray(before, after, path)), patches;
-  if (!isRecord(after) || !isRecord(before)) return patches;
-  const beforeKeys = Object.keys(before).filter((k2) => !ignoredKeys.includes(k2)), afterKeys = Object.keys(after).filter((k2) => !ignoredKeys.includes(k2)), allKeys = /* @__PURE__ */ new Set([...beforeKeys, ...afterKeys]);
-  for (const key of allKeys) {
-    const subPath = [...path, key];
-    key in after ? key in before ? patches.push(...diffRecursive(before[key], after[key], subPath)) : patches.push({ set: { [stringifyPath(subPath)]: after[key] } }) : patches.push({ unset: [stringifyPath(subPath)] });
-  }
-  return patches;
-}
-function diffArray(beforeArr, afterArr, path) {
-  const pathStr = stringifyPath(path), isKeyedArray = (arr) => arr.every((item) => isKeyedObject(item));
-  if (isKeyedArray(beforeArr) && isKeyedArray(afterArr)) {
-    if (beforeArr.length === 0 && afterArr.length > 0)
-      return [
-        {
-          insert: {
-            before: stringifyPath([...path, 0]),
-            items: afterArr
-          }
-        }
-      ];
-    const unsetPatches = [], diffPatches = [], insertPatches = [], beforeMap = /* @__PURE__ */ new Map();
-    beforeArr.forEach((item, index) => {
-      beforeMap.set(item._key, { item, index });
-    });
-    const afterMap = /* @__PURE__ */ new Map();
-    afterArr.forEach((item, index) => {
-      afterMap.set(item._key, { item, index });
-    });
-    for (const [key] of beforeMap.entries())
-      afterMap.has(key) || unsetPatches.push({ unset: [stringifyPath([...path, { _key: key }])] });
-    for (const [key, { item: afterItem }] of afterMap.entries())
-      beforeMap.has(key) && diffPatches.push(
-        ...diffRecursive(beforeMap.get(key).item, afterItem, [...path, { _key: key }])
-      );
-    let newItemsGroup = [], insertPosition = null;
-    for (let i2 = 0; i2 < afterArr.length; i2++) {
-      const item = afterArr[i2];
-      if (beforeMap.has(item._key))
-        newItemsGroup.length > 0 && insertPosition && (insertPosition.op === "before" ? insertPatches.push({
-          insert: {
-            before: stringifyPath([...path, { _key: insertPosition.refKey }]),
-            items: newItemsGroup
-          }
-        }) : insertPatches.push({
-          insert: {
-            after: stringifyPath([...path, { _key: insertPosition.refKey }]),
-            items: newItemsGroup
-          }
-        }), newItemsGroup = [], insertPosition = null);
-      else {
-        if (newItemsGroup.length === 0)
-          if (i2 === 0) {
-            let j2 = i2;
-            for (; j2 < afterArr.length && !beforeMap.has(afterArr[j2]._key); )
-              j2++;
-            j2 < afterArr.length ? insertPosition = { op: "before", refKey: afterArr[j2]._key } : beforeArr.length > 0 && (insertPosition = { op: "after", refKey: beforeArr[beforeArr.length - 1]._key });
-          } else {
-            let j2 = i2 - 1;
-            for (; j2 >= 0 && !beforeMap.has(afterArr[j2]._key); )
-              j2--;
-            if (j2 >= 0)
-              insertPosition = { op: "after", refKey: afterArr[j2]._key };
-            else {
-              let k2 = i2;
-              for (; k2 < afterArr.length && !beforeMap.has(afterArr[k2]._key); )
-                k2++;
-              k2 < afterArr.length && (insertPosition = { op: "before", refKey: afterArr[k2]._key });
-            }
-          }
-        newItemsGroup.push(item);
-      }
-    }
-    return newItemsGroup.length > 0 && insertPosition && (insertPosition.op === "after" ? insertPatches.push({
-      insert: {
-        after: stringifyPath([...path, { _key: insertPosition.refKey }]),
-        items: newItemsGroup
-      }
-    }) : insertPatches.push({
-      insert: {
-        before: stringifyPath([...path, { _key: insertPosition.refKey }]),
-        items: newItemsGroup
-      }
-    })), afterArr.every((item) => !beforeMap.has(item._key)) ? [...insertPatches, ...unsetPatches, ...diffPatches] : [...unsetPatches, ...diffPatches, ...insertPatches];
-  } else {
-    const patches = [], minLength = Math.min(beforeArr.length, afterArr.length);
-    for (let i2 = 0; i2 < minLength; i2++)
-      patches.push(...diffRecursive(beforeArr[i2], afterArr[i2], [...path, i2]));
-    for (let i2 = afterArr.length; i2 < beforeArr.length; i2++)
-      patches.push({ unset: [stringifyPath([...path, i2])] });
-    if (afterArr.length > beforeArr.length) {
-      const newItems = afterArr.slice(beforeArr.length);
-      beforeArr.length > 0 ? patches.push({
-        insert: { after: stringifyPath([...path, beforeArr.length - 1]), items: newItems }
-      }) : patches.push({ set: { [pathStr]: afterArr } });
-    }
-    return patches;
-  }
-}
 class MultiKeyWeakMap {
   // The root of our nested WeakMap structure.
   #rootMap = /* @__PURE__ */ new WeakMap();
@@ -3677,7 +3561,7 @@ function processActions({
           mutations: baseMutations,
           timestamp
         });
-        const baseAfter = base[draftId], patches = diffPatch(baseBefore, baseAfter), workingMutations = [];
+        const baseAfter = base[draftId], patches = diffValue(baseBefore, baseAfter), workingMutations = [];
         if (!working[draftId] && working[publishedId]) {
           const newDraftFromPublished = { ...working[publishedId], _id: draftId };
           if (!checkGrant(grants.create, newDraftFromPublished))
@@ -4220,9 +4104,10 @@ const _getDocumentState = bindActionByDataset(
     selector: ({ state: { error, documentStates } }, options) => {
       const { documentId, path } = options;
       if (error) throw error;
-      const draftId = getDraftId(documentId), publishedId = getPublishedId$1(documentId), draft = documentStates[draftId]?.local, published = documentStates[publishedId]?.local, document = draft ?? published;
-      if (document !== void 0)
-        return path ? jsonMatch(document, path).at(0)?.value : document;
+      const draftId = getDraftId(documentId), publishedId = getPublishedId$1(documentId), draft = documentStates[draftId]?.local, published = documentStates[publishedId]?.local;
+      if (draft === void 0 || published === void 0) return;
+      const document = draft ?? published;
+      return path ? jsonMatch(document, path).at(0)?.value : document;
     },
     onSubscribe: (context, options) => manageSubscriberIds(context, options.documentId)
   })
@@ -5407,7 +5292,7 @@ function createGroqSearchFilter(query) {
     `${finalIncrementalToken}${WILDCARD_TOKEN}`
   ), `[@] match text::query("${processedTokens.join(" ").replace(/"/g, '\\"')}")`;
 }
-var version = "2.0.0";
+var version = "2.0.2";
 const CORE_SDK_VERSION = getEnv("PKG_VERSION") || `${version}-development`;
 export {
   AuthStateType,
@@ -5434,10 +5319,12 @@ export {
   getDocumentState,
   getDocumentSyncStatus,
   getFavoritesState,
+  getIsInDashboardState,
   getLoginUrlState,
   getNodeState,
   getOrCreateChannel,
   getOrCreateController,
+  getOrCreateNode,
   getPermissionsState,
   getPerspectiveState,
   getPreviewState,
@@ -5458,6 +5345,7 @@ export {
   parseUsersKey,
   publishDocument,
   releaseChannel,
+  releaseNode,
   resolveDatasets,
   resolveDocument,
   resolveFavoritesState,
@@ -5468,6 +5356,7 @@ export {
   resolveProjects,
   resolveQuery,
   resolveUsers,
+  setAuthToken,
   subscribeDocumentEvents,
   unpublishDocument
 };