@conduit-client/utils 5.67.0-dev1

package/README.md

@@ -0,0 +1,12 @@
+# Utilities
+
+This package contains common utilities that are used in other packages.
+Unlike base commands and services, the utilities here are **not** versioned and
+**must** remain backwards-compatible.
+
+Other packages should not have runtime imports of anything from this package.
+TypeScript compile-time constructs like types & enums should not cause any issues.
+Imports of runtime constructs like functions or classes should be resolved by
+statically bundling this package with the consuming package(s). This will
+typically be done as part of the runtime build. Bundling earlier in the build
+process can result in duplicate copies of utility code.

package/dist/index.js

@@ -0,0 +1,649 @@
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+function bfs(start, predicate, getChildren) {
+  const queue = [...start];
+  const visited = /* @__PURE__ */ new Set([...start]);
+  const matches2 = /* @__PURE__ */ new Set();
+  while (queue.length) {
+    const curr = queue.shift();
+    if (predicate(curr)) {
+      matches2.add(curr);
+    }
+    const children = getChildren(curr);
+    for (const child of children) {
+      if (!visited.has(child)) {
+        visited.add(child);
+        queue.push(child);
+      }
+    }
+  }
+  return matches2;
+}
+function lineFormatter(position, message, filePath) {
+  return `${message} (${filePath}:${position.line}:${position.column})`;
+}
+class DefaultFileParserLogger {
+  constructor(services, filePath) {
+    this.services = services;
+    this.filePath = filePath;
+  }
+  trace(position, message) {
+    this.services.logger.trace(this.format(position, message));
+  }
+  debug(position, message) {
+    this.services.logger.debug(this.format(position, message));
+  }
+  info(position, message) {
+    this.services.logger.info(this.format(position, message));
+  }
+  warn(position, message) {
+    this.services.logger.warn(this.format(position, message));
+  }
+  error(position, message) {
+    this.services.logger.error(this.format(position, message));
+  }
+  format(position, message) {
+    return lineFormatter(position, message, this.filePath);
+  }
+}
+function matches(test, s) {
+  if (test === void 0) {
+    return false;
+  } else if (typeof test === "string") {
+    return s === test;
+  } else if (test instanceof RegExp) {
+    return test.test(s);
+  } else if (typeof test === "function") {
+    return test(s);
+  }
+  return test.some((m) => matches(m, s));
+}
+function includes(incexc, s) {
+  if (matches(incexc.exclude, s)) {
+    return false;
+  }
+  if (matches(incexc.include, s)) {
+    return true;
+  }
+  if (incexc.include) {
+    return false;
+  }
+  return true;
+}
+const { create, freeze, keys, entries } = Object;
+const { hasOwnProperty } = Object.prototype;
+const { isArray } = Array;
+const { push, indexOf, slice } = Array.prototype;
+const { stringify, parse } = JSON;
+const WeakSetConstructor = WeakSet;
+const LogLevelMap = {
+  TRACE: 4,
+  DEBUG: 3,
+  INFO: 2,
+  WARN: 1,
+  ERROR: 0
+};
+class ConsoleLogger {
+  constructor(level = "WARN", printer = console.log, formatter = (level2, message) => `${level2}: ${message}`) {
+    this.level = level;
+    this.printer = printer;
+    this.formatter = formatter;
+    this.messages = [];
+  }
+  trace(message) {
+    this.log("TRACE", message);
+  }
+  debug(message) {
+    this.log("DEBUG", message);
+  }
+  info(message) {
+    this.log("INFO", message);
+  }
+  warn(message) {
+    this.log("WARN", message);
+  }
+  error(message) {
+    this.log("ERROR", message);
+  }
+  log(level, message) {
+    if (LogLevelMap[level] > LogLevelMap[this.level]) {
+      return;
+    }
+    this.printer(this.formatter(level, message));
+  }
+}
+function loggerService(level, printer, formatter) {
+  return new ConsoleLogger(level, printer, formatter);
+}
+class Ok {
+  constructor(value) {
+    this.value = value;
+  }
+  isOk() {
+    return true;
+  }
+  isErr() {
+    return !this.isOk();
+  }
+}
+class Err {
+  constructor(error) {
+    this.error = error;
+  }
+  isOk() {
+    return false;
+  }
+  isErr() {
+    return !this.isOk();
+  }
+}
+const ok = (value) => new Ok(value);
+const err = (err2) => new Err(err2);
+class DataNotFoundError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DataNotFoundError";
+  }
+}
+class DataIncompleteError extends Error {
+  constructor(message, partialData) {
+    super(message);
+    this.partialData = partialData;
+    this.name = "DataIncompleteError";
+  }
+}
+function isDataNotFoundError(error) {
+  return error instanceof DataNotFoundError || error.name === "DataNotFoundError";
+}
+function isDataIncompleteError(error) {
+  return error instanceof DataIncompleteError || error.name === "DataIncompleteError";
+}
+function isCacheHitOrError(value) {
+  if (value.isErr() && (isDataIncompleteError(value.error) || isDataNotFoundError(value.error))) {
+    return false;
+  }
+  return true;
+}
+function isCacheMiss(value) {
+  return !isCacheHitOrError(value);
+}
+function isResult(value) {
+  return value != null && typeof value === "object" && "isOk" in value && "isErr" in value && typeof value.isOk === "function" && typeof value.isErr === "function" && (value.isOk() === true && value.isErr() === false && "value" in value || value.isOk() === false && value.isErr() === true && "error" in value);
+}
+function setOverlaps(setA, setB) {
+  for (const element of setA) {
+    if (setB.has(element)) {
+      return true;
+    }
+  }
+  return false;
+}
+function setDifference(setA, setB) {
+  const differenceSet = /* @__PURE__ */ new Set();
+  for (const element of setA) {
+    if (!setB.has(element)) {
+      differenceSet.add(element);
+    }
+  }
+  return differenceSet;
+}
+function addAllToSet(targetSet, sourceSet) {
+  for (const element of sourceSet) {
+    targetSet.add(element);
+  }
+}
+const toTypeScriptSafeIdentifier = (s) => s.length >= 1 ? s[0].replace(/[^$_\p{ID_Start}]/u, "_") + s.slice(1).replace(/[^$\u200c\u200d\p{ID_Continue}]/gu, "_") : "";
+function isSubscribable(obj) {
+  return typeof obj === "object" && obj !== null && "subscribe" in obj && typeof obj.subscribe === "function" && "refresh" in obj && typeof obj.refresh === "function";
+}
+function isSubscribableResult(x) {
+  if (!isResult(x)) {
+    return false;
+  }
+  return isSubscribable(x.isOk() ? x.value : x.error);
+}
+function buildSubscribableResult(result, subscribe, refresh) {
+  if (result.isOk()) {
+    return ok({ data: result.value, subscribe, refresh });
+  } else {
+    return err({ failure: result.error, subscribe, refresh });
+  }
+}
+function resolvedPromiseLike(result) {
+  if (isPromiseLike(result)) {
+    return result.then((nextResult) => nextResult);
+  }
+  return {
+    then: (onFulfilled, _onRejected) => {
+      try {
+        return resolvedPromiseLike(onFulfilled(result));
+      } catch (e) {
+        if (onFulfilled === void 0) {
+          return resolvedPromiseLike(result);
+        }
+        return rejectedPromiseLike(e);
+      }
+    }
+  };
+}
+function rejectedPromiseLike(reason) {
+  if (isPromiseLike(reason)) {
+    return reason.then((nextResult) => nextResult);
+  }
+  return {
+    then: (_onFulfilled, onRejected) => {
+      if (typeof onRejected === "function") {
+        try {
+          return resolvedPromiseLike(onRejected(reason));
+        } catch (e) {
+          return rejectedPromiseLike(e);
+        }
+      }
+      return rejectedPromiseLike(reason);
+    }
+  };
+}
+function isPromiseLike(x) {
+  return typeof (x == null ? void 0 : x.then) === "function";
+}
+function racesync(values) {
+  for (const value of values) {
+    let settled = void 0;
+    if (isPromiseLike(value)) {
+      value.then(
+        (_) => {
+          settled = value;
+        },
+        (_) => {
+          settled = value;
+        }
+      );
+    } else {
+      settled = resolvedPromiseLike(value);
+    }
+    if (settled !== void 0) {
+      return settled;
+    }
+  }
+  return Promise.race(values);
+}
+function withResolvers() {
+  let resolve, reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+function deepEquals(x, y) {
+  if (x === void 0) {
+    return y === void 0;
+  } else if (x === null) {
+    return y === null;
+  } else if (y === null) {
+    return x === null;
+  } else if (isArray(x)) {
+    if (!isArray(y) || x.length !== y.length) {
+      return false;
+    }
+    for (let i = 0; i < x.length; ++i) {
+      if (!deepEquals(x[i], y[i])) {
+        return false;
+      }
+    }
+    return true;
+  } else if (typeof x === "object") {
+    if (typeof y !== "object") {
+      return false;
+    }
+    const xkeys = Object.keys(x);
+    const ykeys = Object.keys(y);
+    if (xkeys.length !== ykeys.length) {
+      return false;
+    }
+    for (let i = 0; i < xkeys.length; ++i) {
+      const key = xkeys[i];
+      if (!deepEquals(x[key], y[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return x === y;
+}
+function stableJSONStringify(node) {
+  if (node && node.toJSON && typeof node.toJSON === "function") {
+    node = node.toJSON();
+  }
+  if (node === void 0) {
+    return;
+  }
+  if (typeof node === "number") {
+    return isFinite(node) ? "" + node : "null";
+  }
+  if (typeof node !== "object") {
+    return stringify(node);
+  }
+  let i;
+  let out;
+  if (isArray(node)) {
+    out = "[";
+    for (i = 0; i < node.length; i++) {
+      if (i) {
+        out += ",";
+      }
+      out += stableJSONStringify(node[i]) || "null";
+    }
+    return out + "]";
+  }
+  if (node === null) {
+    return "null";
+  }
+  const objKeys = keys(node).sort();
+  out = "";
+  for (i = 0; i < objKeys.length; i++) {
+    const key = objKeys[i];
+    const value = stableJSONStringify(node[key]);
+    if (!value) {
+      continue;
+    }
+    if (out) {
+      out += ",";
+    }
+    out += stringify(key) + ":" + value;
+  }
+  return "{" + out + "}";
+}
+function toError(x) {
+  if (x instanceof Error) {
+    return x;
+  }
+  return new Error(typeof x === "string" ? x : JSON.stringify(x));
+}
+function deepCopy(x) {
+  const stringified = stringify(x);
+  return stringified ? parse(stringified) : void 0;
+}
+function readableStreamToAsyncIterable(stream) {
+  if (stream.locked) {
+    return err(new Error("ReadableStream is already locked"));
+  }
+  if (Symbol.asyncIterator in stream) {
+    return ok(stream);
+  }
+  const reader = stream.getReader();
+  return ok({
+    [Symbol.asyncIterator]: () => ({
+      next: async () => {
+        try {
+          const result = await reader.read();
+          if (result.done) {
+            try {
+              reader.releaseLock();
+            } catch {
+            }
+            return { done: true, value: void 0 };
+          }
+          return {
+            done: false,
+            value: result.value
+          };
+        } catch (e) {
+          try {
+            reader.releaseLock();
+          } catch {
+          }
+          throw e;
+        }
+      },
+      return: async (value) => {
+        try {
+          await reader.cancel();
+        } catch {
+        }
+        try {
+          reader.releaseLock();
+        } catch {
+        }
+        return { done: true, value };
+      },
+      throw: async (exception) => {
+        try {
+          await reader.cancel();
+        } catch {
+        }
+        try {
+          reader.releaseLock();
+        } catch {
+        }
+        throw exception;
+      }
+    })
+  });
+}
+function satisfies(provided, requested) {
+  const providedN = provided.split(".").map((s) => parseInt(s));
+  const requestedN = requested.split(".").map((s) => parseInt(s));
+  return providedN[0] === requestedN[0] && providedN[1] >= requestedN[1];
+}
+function stringIsVersion(s) {
+  const versionParts = s.split(".");
+  return (versionParts.length === 2 || versionParts.length === 3) && versionParts.every((part) => part.match(/^\d+$/));
+}
+var HttpStatusCode = /* @__PURE__ */ ((HttpStatusCode2) => {
+  HttpStatusCode2[HttpStatusCode2["Ok"] = 200] = "Ok";
+  HttpStatusCode2[HttpStatusCode2["Created"] = 201] = "Created";
+  HttpStatusCode2[HttpStatusCode2["NoContent"] = 204] = "NoContent";
+  HttpStatusCode2[HttpStatusCode2["NotModified"] = 304] = "NotModified";
+  HttpStatusCode2[HttpStatusCode2["BadRequest"] = 400] = "BadRequest";
+  HttpStatusCode2[HttpStatusCode2["Unauthorized"] = 401] = "Unauthorized";
+  HttpStatusCode2[HttpStatusCode2["Forbidden"] = 403] = "Forbidden";
+  HttpStatusCode2[HttpStatusCode2["NotFound"] = 404] = "NotFound";
+  HttpStatusCode2[HttpStatusCode2["ServerError"] = 500] = "ServerError";
+  HttpStatusCode2[HttpStatusCode2["GatewayTimeout"] = 504] = "GatewayTimeout";
+  return HttpStatusCode2;
+})(HttpStatusCode || {});
+function getFetchResponseFromAuraError(err2) {
+  if (err2.data !== void 0 && err2.data.statusCode !== void 0) {
+    let data = {};
+    data = err2.data;
+    if (err2.id !== void 0) {
+      data.id = err2.id;
+    }
+    return new FetchResponse(data.statusCode, data);
+  }
+  return new FetchResponse(500, {
+    error: err2.message
+  });
+}
+async function coerceResponseToFetchResponse(response) {
+  const { status } = response;
+  const responseHeaders = {};
+  response.headers.forEach((value, key) => {
+    responseHeaders[key] = value;
+  });
+  let responseBody = null;
+  if (status !== 204) {
+    const contentType = responseHeaders["content-type"];
+    responseBody = contentType && contentType.startsWith("application/json") ? await response.json() : await response.text();
+  }
+  return new FetchResponse(status, responseBody, responseHeaders);
+}
+function getStatusText(status) {
+  switch (status) {
+    case 200:
+      return "OK";
+    case 201:
+      return "Created";
+    case 304:
+      return "Not Modified";
+    case 400:
+      return "Bad Request";
+    case 404:
+      return "Not Found";
+    case 500:
+      return "Server Error";
+    default:
+      return `Unexpected HTTP Status Code: ${status}`;
+  }
+}
+class FetchResponse extends Error {
+  constructor(status, body, headers) {
+    super();
+    this.status = status;
+    this.body = body;
+    this.headers = headers || {};
+    this.ok = status >= 200 && this.status <= 299;
+    this.statusText = getStatusText(status);
+  }
+}
+const deeplyFrozen = new WeakSetConstructor();
+function deepFreeze(value) {
+  if (typeof value !== "object" || value === null || deeplyFrozen.has(value)) {
+    return;
+  }
+  deeplyFrozen.add(value);
+  if (isArray(value)) {
+    for (let i = 0, len = value.length; i < len; i += 1) {
+      deepFreeze(value[i]);
+    }
+  } else {
+    const keys$1 = keys(value);
+    for (let i = 0, len = keys$1.length; i < len; i += 1) {
+      deepFreeze(value[keys$1[i]]);
+    }
+  }
+  freeze(value);
+}
+function isScalar(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null || value === void 0;
+}
+function isScalarObject(value) {
+  return Object.values(value).every((value2) => isScalar(value2));
+}
+function isScalarArray(value) {
+  return value.every((item) => isScalar(item));
+}
+function encodeQueryParam(paramName, value, explode) {
+  switch (typeof value) {
+    case "string":
+      return [`${paramName}=${encodeURIComponent(value)}`];
+    case "number":
+    case "boolean":
+      return [`${paramName}=${value}`];
+    case "object":
+      if (value === null) {
+        return [];
+      }
+      if (isArray(value)) {
+        if (!isScalarArray(value)) {
+          throw new Error(`Unsupported non-scalar array type for ${paramName}`);
+        }
+        if (explode) {
+          return value.map(
+            (item) => `${paramName}=${item ? encodeURIComponent(item) : item}`
+          );
+        }
+        return [
+          `${paramName}=${value.map((item) => item ? encodeURIComponent(item) : item).join(",")}`
+        ];
+      }
+      if (!isScalarObject(value)) {
+        throw new Error(`Unsupported non-scalar object type for ${paramName}`);
+      }
+      if (explode) {
+        return entries(value).map(
+          ([key, value2]) => `${key}=${value2 ? encodeURIComponent(value2) : value2}`
+        );
+      }
+      return [
+        `${paramName}=${entries(value).flat().map((item) => item ? encodeURIComponent(item) : item).join(",")}`
+      ];
+    default:
+      return [];
+  }
+}
+class InternalError extends Error {
+  constructor(data) {
+    super();
+    this.data = data;
+    this.type = "internal";
+  }
+}
+class UserVisibleError extends Error {
+  constructor(data) {
+    super();
+    this.data = data;
+    this.type = "user-visible";
+  }
+}
+function applyDecorators(baseCommand, decorators, options) {
+  if (!decorators || decorators.length === 0) {
+    return baseCommand;
+  }
+  return decorators.reduce((command, decorator) => decorator(command, options), baseCommand);
+}
+export {
+  isArray as ArrayIsArray,
+  indexOf as ArrayPrototypeIndexOf,
+  push as ArrayPrototypePush,
+  slice as ArrayPrototypeSlice,
+  ConsoleLogger,
+  DataIncompleteError,
+  DataNotFoundError,
+  DefaultFileParserLogger,
+  Err,
+  FetchResponse,
+  HttpStatusCode,
+  InternalError,
+  parse as JSONParse,
+  stringify as JSONStringify,
+  LogLevelMap,
+  create as ObjectCreate,
+  entries as ObjectEntries,
+  freeze as ObjectFreeze,
+  keys as ObjectKeys,
+  hasOwnProperty as ObjectPrototypeHasOwnProperty,
+  Ok,
+  UserVisibleError,
+  WeakSetConstructor,
+  addAllToSet,
+  applyDecorators,
+  bfs,
+  buildSubscribableResult,
+  coerceResponseToFetchResponse,
+  deepCopy,
+  deepEquals,
+  deepFreeze,
+  encodeQueryParam,
+  err,
+  getFetchResponseFromAuraError,
+  includes,
+  isCacheHitOrError,
+  isCacheMiss,
+  isDataIncompleteError,
+  isDataNotFoundError,
+  isPromiseLike,
+  isResult,
+  isSubscribable,
+  isSubscribableResult,
+  lineFormatter,
+  loggerService,
+  ok,
+  racesync,
+  readableStreamToAsyncIterable,
+  rejectedPromiseLike,
+  resolvedPromiseLike,
+  satisfies,
+  setDifference,
+  setOverlaps,
+  stableJSONStringify,
+  stringIsVersion,
+  toError,
+  toTypeScriptSafeIdentifier,
+  withResolvers
+};
+//# sourceMappingURL=index.js.map