@sanity/client 6.7.1 → 6.8.0-pink-lizard.1

package/dist/stega.browser.js

@@ -0,0 +1,598 @@
+import { ObservableSanityClient, defaultConfig, SanityClient, defineCreateClientExports, envMiddleware } from './_chunks/browserMiddleware-Oa7zKwEN.js';
+export { BasePatch, BaseTransaction, ClientError, ObservablePatch, ObservableTransaction, Patch, ServerError, Transaction } from './_chunks/browserMiddleware-Oa7zKwEN.js';
+import { map } from 'rxjs/operators';
+import { vercelStegaCombine } from '@vercel/stega';
+export { adapter as unstable__adapter, environment as unstable__environment } from 'get-it';
+const defaultStegaConfig = {
+  enabled: false,
+  filter: props => props.filterDefault(props),
+  vercelStegaCombineSkip: "auto"
+};
+function splitConfig(config) {
+  const {
+    stega = {},
+    ...clientConfig
+  } = config;
+  return {
+    clientConfig,
+    stegaConfig: stega
+  };
+}
+const initStegaConfig = (config, prevConfig) => {
+  const specifiedConfig = Object.assign({}, prevConfig, config);
+  const newConfig = Object.assign({}, defaultStegaConfig, specifiedConfig);
+  if ("encodeSourceMap" in newConfig) {
+    throw new Error("It looks like you're using options meant for '@sanity/preview-kit/client'. 'encodeSourceMap' is not supported in '@sanity/client/stega'. Did you mean 'enabled'?");
+  }
+  if ("encodeSourceMapAtPath" in newConfig) {
+    throw new Error("It looks like you're using options meant for '@sanity/preview-kit/client'. 'encodeSourceMapAtPath' is not supported in '@sanity/client/stega'. Did you mean 'filter'?");
+  }
+  if (typeof newConfig.enabled !== "boolean") {
+    throw new Error("config.enabled must be a boolean, received ".concat(newConfig.enabled));
+  }
+  if (newConfig.enabled && newConfig.studioUrl === void 0) {
+    throw new Error("config.studioUrl must be defined when config.enabled is true");
+  }
+  if (newConfig.enabled && typeof newConfig.studioUrl !== "string" && typeof newConfig.studioUrl !== "function") {
+    throw new Error("config.studioUrl must be a string or a function, received ".concat(newConfig.studioUrl));
+  }
+  return newConfig;
+};
+const DRAFTS_PREFIX = "drafts.";
+function getPublishedId(id) {
+  if (id.startsWith(DRAFTS_PREFIX)) {
+    return id.slice(DRAFTS_PREFIX.length);
+  }
+  return id;
+}
+const ESCAPE = {
+  "\f": "\\f",
+  "\n": "\\n",
+  "\r": "\\r",
+  "	": "\\t",
+  "'": "\\'",
+  "\\": "\\\\"
+};
+const UNESCAPE = {
+  "\\f": "\f",
+  "\\n": "\n",
+  "\\r": "\r",
+  "\\t": "	",
+  "\\'": "'",
+  "\\\\": "\\"
+};
+function jsonPath(path, opts) {
+  return "$".concat(path.map(segment => {
+    if (typeof segment === "string") {
+      const escapedKey = segment.replace(/[\f\n\r\t'\\]/g, match => {
+        return ESCAPE[match];
+      });
+      return "['".concat(escapedKey, "']");
+    }
+    if (typeof segment === "number") {
+      return "[".concat(segment, "]");
+    }
+    if ((opts == null ? void 0 : opts.keyArraySelectors) && segment.key !== "") {
+      const escapedKey = segment.key.replace(/['\\]/g, match => {
+        return ESCAPE[match];
+      });
+      return "[?(@._key=='".concat(escapedKey, "')]");
+    }
+    return "[".concat(segment.index, "]");
+  }).join(""));
+}
+function parseJsonPath(path) {
+  const parsed = [];
+  const parseRe = /\['(.*?)'\]|\[(\d+)\]|\[\?\(@\._key=='(.*?)'\)\]/g;
+  let match;
+  while ((match = parseRe.exec(path)) !== null) {
+    if (match[1] !== void 0) {
+      const key = match[1].replace(/\\(\\|f|n|r|t|')/g, m => {
+        return UNESCAPE[m];
+      });
+      parsed.push(key);
+      continue;
+    }
+    if (match[2] !== void 0) {
+      parsed.push(parseInt(match[2], 10));
+      continue;
+    }
+    if (match[3] !== void 0) {
+      const key = match[3].replace(/\\(\\')/g, m => {
+        return UNESCAPE[m];
+      });
+      parsed.push({
+        key,
+        index: -1
+      });
+      continue;
+    }
+  }
+  return parsed;
+}
+function resolvedKeyedSourcePath(options) {
+  const {
+    keyedResultPath,
+    pathSuffix,
+    sourceBasePath
+  } = options;
+  const inferredResultPath = pathSuffix === void 0 ? [] : parseJsonPath(pathSuffix);
+  const inferredPath = keyedResultPath.slice(keyedResultPath.length - inferredResultPath.length);
+  const inferredPathSuffix = inferredPath.length ? jsonPath(inferredPath, {
+    keyArraySelectors: true
+  }).slice(1) : "";
+  return parseJsonPath(sourceBasePath + inferredPathSuffix);
+}
+function resolveMapping(resultPath, csm) {
+  if (!(csm == null ? void 0 : csm.mappings)) {
+    return void 0;
+  }
+  const resultJsonPath = jsonPath(resultPath);
+  if (csm.mappings[resultJsonPath] !== void 0) {
+    return {
+      mapping: csm.mappings[resultJsonPath],
+      matchedPath: resultJsonPath,
+      pathSuffix: ""
+    };
+  }
+  const mappings = Object.entries(csm.mappings).filter(_ref => {
+    let [key] = _ref;
+    return resultJsonPath.startsWith(key);
+  }).sort((_ref2, _ref3) => {
+    let [key1] = _ref2;
+    let [key2] = _ref3;
+    return key2.length - key1.length;
+  });
+  if (mappings.length == 0) {
+    return void 0;
+  }
+  const [matchedPath, mapping] = mappings[0];
+  const pathSuffix = resultJsonPath.substring(matchedPath.length);
+  return {
+    mapping,
+    matchedPath,
+    pathSuffix
+  };
+}
+function simplifyPath(path) {
+  return path.map((segment, index) => {
+    if (typeof segment === "number") {
+      return "[".concat(segment, "]");
+    }
+    if (typeof segment === "string") {
+      return index === 0 ? segment : ".".concat(segment);
+    }
+    return '[_key=="'.concat(segment.key, '"]');
+  }).join("");
+}
+function createEditLink(options) {
+  const {
+    studioUrl: resolveStudioUrl,
+    resultSourceMap: csm,
+    resultPath
+  } = options;
+  const {
+    mapping,
+    pathSuffix
+  } = resolveMapping(resultPath, csm) || {};
+  if (!mapping) {
+    return void 0;
+  }
+  if (mapping.source.type === "literal") {
+    return void 0;
+  }
+  if (mapping.source.type === "unknown") {
+    return void 0;
+  }
+  const sourceDoc = csm.documents[mapping.source.document];
+  const sourceBasePath = csm.paths[mapping.source.path];
+  if (sourceDoc && sourceBasePath) {
+    const studioUrl = typeof resolveStudioUrl === "function" ? resolveStudioUrl(sourceDoc, parseJsonPath(sourceBasePath)) : resolveStudioUrl;
+    if (!studioUrl) return void 0;
+    const _studioUrl = studioUrl.replace(/\/$/, "");
+    const _path = encodeURIComponent(simplifyPath(resolvedKeyedSourcePath({
+      keyedResultPath: parseJsonPath(sourceBasePath),
+      pathSuffix,
+      sourceBasePath
+    })));
+    const {
+      _id,
+      _type
+    } = sourceDoc;
+    const params = new URLSearchParams();
+    if (sourceDoc._projectId) {
+      params.set("projectId", sourceDoc._projectId);
+    }
+    if (sourceDoc._dataset) {
+      params.set("dataset", sourceDoc._dataset);
+    }
+    params.set("id", getPublishedId(sourceDoc._id));
+    params.set("type", sourceDoc._type);
+    params.set("path", decodeURIComponent(_path));
+    params.set("baseUrl", _studioUrl);
+    return "".concat(_studioUrl, "/intent/edit/id=").concat(getPublishedId(_id), ";type=").concat(_type, ";path=").concat(_path, "?").concat(params);
+  }
+  return void 0;
+}
+function isArray(value) {
+  return value !== null && Array.isArray(value);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function walkMap(value, mappingFn) {
+  let path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  if (isArray(value)) {
+    return value.map((v, idx) => {
+      if (isRecord(v)) {
+        const key = v["_key"];
+        if (typeof key === "string") {
+          return walkMap(v, mappingFn, path.concat({
+            key,
+            index: idx
+          }));
+        }
+      }
+      return walkMap(v, mappingFn, path.concat(idx));
+    });
+  }
+  if (isRecord(value)) {
+    return Object.fromEntries(Object.entries(value).map(_ref4 => {
+      let [k, v] = _ref4;
+      return [k, walkMap(v, mappingFn, path.concat(k))];
+    }));
+  }
+  return mappingFn(value, path);
+}
+function encodeIntoResult(result, csm, encoder, options) {
+  return walkMap(result, (value, path) => {
+    if (typeof value !== "string") {
+      return value;
+    }
+    const resolveMappingResult = resolveMapping(path, csm);
+    if (!resolveMappingResult) {
+      return value;
+    }
+    const {
+      mapping,
+      matchedPath,
+      pathSuffix
+    } = resolveMappingResult;
+    if (mapping.type !== "value") {
+      return value;
+    }
+    if (mapping.source.type !== "documentValue") {
+      return value;
+    }
+    const sourceDocument = csm.documents[mapping.source.document];
+    const sourcePath = csm.paths[mapping.source.path];
+    if (options == null ? void 0 : options.keyArraySelectors) {
+      const matchPathSegments = parseJsonPath(matchedPath);
+      const sourcePathSegments = parseJsonPath(sourcePath);
+      const fullSourceSegments = sourcePathSegments.concat(path.slice(matchPathSegments.length));
+      return encoder({
+        sourcePath: fullSourceSegments,
+        sourceDocument,
+        resultPath: path,
+        value
+      });
+    }
+    return encoder({
+      sourcePath: parseJsonPath(sourcePath + pathSuffix),
+      sourceDocument,
+      resultPath: path,
+      value
+    });
+  });
+}
+const filterDefault = _ref5 => {
+  let {
+    sourcePath
+  } = _ref5;
+  const endPath = sourcePath.at(-1);
+  if (sourcePath.at(-2) === "slug" && endPath === "current") {
+    return false;
+  }
+  if (typeof endPath === "string" && endPath.startsWith("_")) {
+    return false;
+  }
+  if (typeof endPath === "number" && sourcePath.at(-2) === "marks" && typeof sourcePath.at(-3) === "number" && sourcePath.at(-4) === "children" && typeof sourcePath.at(-5) === "number") {
+    return false;
+  }
+  if (endPath === "href" && typeof sourcePath.at(-2) === "number" && sourcePath.at(-3) === "markDefs" && typeof sourcePath.at(-4) === "number") {
+    return false;
+  }
+  if (typeof endPath === "string" && typeof sourcePath.at(-2) === "number") {
+    if (endPath === "style" || endPath === "listItem") {
+      return false;
+    }
+  }
+  return true;
+};
+const TRUNCATE_LENGTH = 20;
+function stegaEncodeSourceMap(result, resultSourceMap, config) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  const {
+    filter,
+    vercelStegaCombineSkip,
+    logger,
+    studioUrl,
+    enabled
+  } = config;
+  if (!enabled) {
+    const msg = "config.enabled must be true, don't call this function otherwise";
+    (_a = logger == null ? void 0 : logger.error) == null ? void 0 : _a.call(logger, "[@sanity/client/stega]: ".concat(msg), {
+      result,
+      resultSourceMap,
+      config
+    });
+    throw new TypeError(msg);
+  }
+  if (!resultSourceMap) {
+    (_b = logger == null ? void 0 : logger.error) == null ? void 0 : _b.call(logger, "[@sanity/client/stega]: Missing Content Source Map from response body", {
+      result,
+      resultSourceMap,
+      config
+    });
+    return result;
+  }
+  if (!studioUrl) {
+    const msg = "config.studioUrl must be defined";
+    (_c = logger == null ? void 0 : logger.error) == null ? void 0 : _c.call(logger, "[@sanity/client/stega]: ".concat(msg), {
+      result,
+      resultSourceMap,
+      config
+    });
+    throw new TypeError(msg);
+  }
+  const report = {
+    encoded: [],
+    skipped: []
+  };
+  const resultWithStega = encodeIntoResult(result, resultSourceMap, _ref6 => {
+    let {
+      sourcePath,
+      sourceDocument,
+      resultPath,
+      value
+    } = _ref6;
+    if ((typeof filter === "function" ? filter({
+      sourcePath,
+      resultPath,
+      filterDefault,
+      sourceDocument,
+      value
+    }) : filterDefault({
+      sourcePath,
+      resultPath,
+      filterDefault,
+      sourceDocument,
+      value
+    })) === false) {
+      if (logger) {
+        report.skipped.push({
+          path: prettyPathForLogging(sourcePath),
+          value: "".concat(value.slice(0, TRUNCATE_LENGTH)).concat(value.length > TRUNCATE_LENGTH ? "..." : ""),
+          length: value.length
+        });
+      }
+      return value;
+    }
+    if (logger) {
+      report.encoded.push({
+        path: prettyPathForLogging(sourcePath),
+        value: "".concat(value.slice(0, TRUNCATE_LENGTH)).concat(value.length > TRUNCATE_LENGTH ? "..." : ""),
+        length: value.length
+      });
+    }
+    return vercelStegaCombine(value, {
+      origin: "sanity.io",
+      href: createEditLink({
+        studioUrl,
+        resultSourceMap,
+        resultPath
+      })
+    }, vercelStegaCombineSkip);
+  }, {
+    keyArraySelectors: true
+  });
+  if (logger) {
+    const isSkipping = report.skipped.length;
+    const isEncoding = report.encoded.length;
+    if (isSkipping || isEncoding) {
+      (_d = (logger == null ? void 0 : logger.groupCollapsed) || logger.log) == null ? void 0 : _d("[@sanity/client/stega]: Encoding source map into result");
+      (_e = logger.log) == null ? void 0 : _e.call(logger, "[@sanity/client/stega]: Paths encoded: ".concat(report.encoded.length, ", skipped: ").concat(report.skipped.length));
+    }
+    if (report.encoded.length > 0) {
+      (_f = logger == null ? void 0 : logger.log) == null ? void 0 : _f.call(logger, "[@sanity/client/stega]: Table of encoded paths");
+      (_g = (logger == null ? void 0 : logger.table) || logger.log) == null ? void 0 : _g(report.encoded);
+    }
+    if (report.skipped.length > 0) {
+      const skipped = /* @__PURE__ */new Set();
+      for (const {
+        path
+      } of report.skipped) {
+        skipped.add(path.replace(/\[\d+\]/g, "[]"));
+      }
+      (_h = logger == null ? void 0 : logger.log) == null ? void 0 : _h.call(logger, "[@sanity/client/stega]: List of skipped paths", [...skipped.values()]);
+    }
+    if (isSkipping || isEncoding) {
+      (_i = logger == null ? void 0 : logger.groupEnd) == null ? void 0 : _i.call(logger);
+    }
+  }
+  return resultWithStega;
+}
+function prettyPathForLogging(path) {
+  return path.map((segment, index) => typeof segment === "number" ? "[".concat(segment, "]") : index > 0 ? ".".concat(segment) : segment).join("");
+}
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj)) throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj)) throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _httpRequest, _httpRequest2;
+const _ObservableSanityStegaClient = class _ObservableSanityStegaClient extends ObservableSanityClient {
+  constructor(httpRequest) {
+    let config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultConfig;
+    const {
+      clientConfig,
+      stegaConfig
+    } = splitConfig(config);
+    super(httpRequest, clientConfig);
+    /**
+     * Private properties
+     */
+    __privateAdd(this, _httpRequest, void 0);
+    __privateSet(this, _httpRequest, httpRequest);
+    this.stegaConfig = initStegaConfig(stegaConfig, defaultStegaConfig);
+  }
+  /**
+   * Clone the client - returns a new instance
+   */
+  clone() {
+    return new _ObservableSanityStegaClient(__privateGet(this, _httpRequest), this.config());
+  }
+  config(newConfig) {
+    if (newConfig === void 0) {
+      return {
+        ...super.config(),
+        stega: {
+          ...this.stegaConfig
+        }
+      };
+    }
+    super.config(newConfig);
+    const {
+      stegaConfig
+    } = splitConfig(newConfig);
+    this.stegaConfig = initStegaConfig(stegaConfig, this.stegaConfig || {});
+    return this;
+  }
+  /**
+   * Clone the client with a new (partial) configuration.
+   *
+   * @param newConfig - New client configuration properties, shallowly merged with existing configuration
+   */
+  withConfig(newConfig) {
+    return new _ObservableSanityStegaClient(__privateGet(this, _httpRequest), {
+      ...this.config(),
+      ...newConfig
+    });
+  }
+  fetch(query, params) {
+    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    const {
+      filterResponse: originalFilterResponse = true
+    } = options;
+    return super.fetch(query, params, Object.assign({}, options, {
+      filterResponse: false
+    })).pipe(map(res => {
+      const {
+        result: _result,
+        resultSourceMap
+      } = res;
+      let result = _result;
+      if (this.stegaConfig.enabled) {
+        result = stegaEncodeSourceMap(_result, resultSourceMap, this.stegaConfig);
+      }
+      return originalFilterResponse ? result : {
+        ...res,
+        result
+      };
+    }));
+  }
+};
+_httpRequest = new WeakMap();
+let ObservableSanityStegaClient = _ObservableSanityStegaClient;
+const _SanityStegaClient = class _SanityStegaClient extends SanityClient {
+  constructor(httpRequest) {
+    let config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultConfig;
+    const {
+      clientConfig,
+      stegaConfig
+    } = splitConfig(config);
+    super(httpRequest, clientConfig);
+    /**
+     * Private properties
+     */
+    __privateAdd(this, _httpRequest2, void 0);
+    __privateSet(this, _httpRequest2, httpRequest);
+    this.stegaConfig = initStegaConfig(stegaConfig, defaultStegaConfig);
+    this.observable = new ObservableSanityStegaClient(httpRequest, config);
+  }
+  /**
+   * Clone the client - returns a new instance
+   */
+  clone() {
+    return new _SanityStegaClient(__privateGet(this, _httpRequest2), this.config());
+  }
+  config(newConfig) {
+    if (newConfig === void 0) {
+      return {
+        ...super.config(),
+        stega: {
+          ...this.stegaConfig
+        }
+      };
+    }
+    super.config(newConfig);
+    const {
+      stegaConfig
+    } = splitConfig(newConfig);
+    this.stegaConfig = initStegaConfig(stegaConfig, {
+      ...(this.stegaConfig || {})
+    });
+    return this;
+  }
+  /**
+   * Clone the client with a new (partial) configuration.
+   *
+   * @param newConfig - New client configuration properties, shallowly merged with existing configuration
+   */
+  withConfig(newConfig) {
+    return new _SanityStegaClient(__privateGet(this, _httpRequest2), {
+      ...this.config(),
+      ...newConfig
+    });
+  }
+  fetch(query, params) {
+    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    const {
+      filterResponse: originalFilterResponse = true
+    } = options;
+    return super.fetch(query, params, Object.assign({}, options, {
+      filterResponse: false
+    })).then(res => {
+      const {
+        result: _result,
+        resultSourceMap
+      } = res;
+      let result = _result;
+      if (this.stegaConfig.enabled) {
+        result = stegaEncodeSourceMap(_result, resultSourceMap, this.stegaConfig);
+      }
+      return originalFilterResponse ? result : {
+        ...res,
+        result
+      };
+    });
+  }
+};
+_httpRequest2 = new WeakMap();
+let SanityStegaClient = _SanityStegaClient;
+const exp = defineCreateClientExports(envMiddleware, SanityStegaClient);
+const requester = exp.requester;
+const createClient = exp.createClient;
+export { ObservableSanityClient, ObservableSanityStegaClient, SanityClient, SanityStegaClient, createClient, encodeIntoResult, requester, stegaEncodeSourceMap };
+//# sourceMappingURL=stega.browser.js.map