@xyo-network/sdk-protocol 7.0.4

package/dist/_pkg/hash/browser/hasEmptyFields.d.ts

@@ -0,0 +1,3 @@
+import type { EmptyObject } from '@xylabs/sdk';
+export declare const hasEmptyFields: <T extends EmptyObject>(obj: T) => boolean;
+//# sourceMappingURL=hasEmptyFields.d.ts.map

package/dist/_pkg/hash/browser/index-browser.d.ts

@@ -0,0 +1,4 @@
+export { BrowserObjectHasher as ObjectHasher } from './BrowserObjectHasher.ts';
+export * from './removeEmptyFields.ts';
+export * from './sortFields.ts';
+//# sourceMappingURL=index-browser.d.ts.map

package/dist/_pkg/hash/browser/index-browser.mjs

@@ -0,0 +1,289 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/createBrowserWorker.ts
+import { Worker } from "@xylabs/threads/master";
+var createBrowserWorker = (url) => {
+  try {
+    return new Worker(url);
+  } catch {
+    throw new Error("Unable to create worker");
+  }
+};
+
+// src/createNodeWorker.ts
+import { Worker as Worker2 } from "@xylabs/threads/master";
+var createNodeWorker = (func) => {
+  try {
+    const code = func?.toString().slice(6) ?? "";
+    return new Worker2(
+      code,
+      { fromSource: true }
+    );
+  } catch {
+    throw new Error("Unable to create worker");
+  }
+};
+
+// src/ObjectHasher.ts
+import {
+  asHash,
+  assertEx,
+  hexFromArrayBuffer,
+  ObjectWrapper,
+  omitBy
+} from "@xylabs/sdk";
+import { Pool, spawn } from "@xylabs/threads/master";
+import { WasmSupport } from "../../wasm/neutral/index.mjs";
+import { sha256 } from "hash-wasm";
+
+// src/removeEmptyFields.ts
+import { typeOf } from "@xylabs/sdk";
+var removeEmptyFields = (obj) => {
+  if (obj == null) return obj;
+  if (Array.isArray(obj)) {
+    const arr = obj;
+    return arr.map((value) => typeof value === "object" ? removeEmptyFields(value) : value);
+  }
+  const newObject = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (typeOf(value) === "object") {
+      newObject[key] = removeEmptyFields(value);
+    } else if (value !== void 0) {
+      newObject[key] = value;
+    }
+  }
+  return newObject;
+};
+
+// src/sortFields.ts
+import { isObject } from "@xylabs/sdk";
+var subSort = (value) => {
+  return isObject(value) ? sortFields(value) : value;
+};
+var sortFields = (obj) => {
+  const result = {};
+  const keys = Object.keys(obj);
+  for (const key of keys.toSorted()) {
+    result[key] = subSort(obj[key]);
+  }
+  return result;
+};
+
+// src/worker/subtleHashNode.ts
+var subtleHashFunc = () => {
+  const { subtle } = __require("@xylabs/platform");
+  const { expose } = __require("@xylabs/threads/worker");
+  expose({ hash: async (data) => await subtle.digest("SHA-256", data) });
+};
+
+// src/worker/wasmHashNode.ts
+var wasmHashFunc = () => {
+  const { sha256: sha2562 } = __require("hash-wasm");
+  const { asHash: asHash2 } = __require("@xylabs/hex");
+  const { expose } = __require("@xylabs/threads/worker");
+  expose({ hash: async (data) => asHash2(await sha2562(data), true) });
+};
+
+// src/ObjectHasher.ts
+var wasmSupportStatic = new WasmSupport(["bigInt"]);
+var omitByPredicate = (prefix) => (_, key) => {
+  assertEx(typeof key === "string", () => `Invalid key type [${String(key)}, ${typeof key}]`);
+  return String(key).startsWith(prefix);
+};
+var ObjectHasher = class _ObjectHasher extends ObjectWrapper {
+  static allowHashPooling = true;
+  static allowSubtle = true;
+  static createBrowserWorker;
+  static createNodeWorker;
+  static subtleHashWorkerUrl;
+  static warnIfUsingJsHash = true;
+  static wasmHashWorkerUrl;
+  static wasmInitialized = wasmSupportStatic.initialize();
+  static wasmSupport = wasmSupportStatic;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static _subtleHashPool;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static _wasmHashPool;
+  static get subtleHashPool() {
+    if (!this.allowHashPooling || this._subtleHashPool === null) {
+      return null;
+    }
+    try {
+      return this._subtleHashPool = this._subtleHashPool ?? (this.subtleHashWorkerUrl ? this.createWorkerPool(this.subtleHashWorkerUrl, subtleHashFunc) : null);
+    } catch {
+      console.warn("Creating subtle hash worker failed");
+      this._subtleHashPool = null;
+      return null;
+    }
+  }
+  static get wasmHashPool() {
+    if (!this.allowHashPooling || this._wasmHashPool === null) {
+      return null;
+    }
+    try {
+      return this._wasmHashPool = this._wasmHashPool ?? (this.wasmHashWorkerUrl ? this.createWorkerPool(this.wasmHashWorkerUrl, wasmHashFunc) : null);
+    } catch {
+      console.warn("Creating wasm hash worker failed");
+      this._wasmHashPool = null;
+      return null;
+    }
+  }
+  static createWorker(url, func) {
+    if (url) console.debug(`createWorker: ${url.href}`);
+    return assertEx(this.createBrowserWorker?.(url) ?? this.createNodeWorker?.(func), () => "Unable to create worker");
+  }
+  static async filterExcludeByHash(objs = [], hash) {
+    const hashes = Array.isArray(hash) ? hash : [hash];
+    const pairs = await this.hashPairs(objs);
+    return pairs.filter(([_, objHash]) => !hashes.includes(objHash))?.map((pair) => pair[0]);
+  }
+  static async filterIncludeByHash(objs = [], hash) {
+    const hashes = Array.isArray(hash) ? hash : [hash];
+    const pairs = await this.hashPairs(objs);
+    return pairs.filter(([_, objHash]) => hashes.includes(objHash))?.map((pair) => pair[0]);
+  }
+  static async findByHash(objs = [], hash) {
+    const pairs = await this.hashPairs(objs);
+    return pairs.find(([_, objHash]) => objHash === hash)?.[0];
+  }
+  /**
+   * Asynchronously hashes a payload
+   * @param obj A payload
+   * @returns The payload hash
+   */
+  static async hash(obj) {
+    const stringToHash = this.stringifyHashFields(obj);
+    const enc = new TextEncoder();
+    const data = enc.encode(stringToHash);
+    if (_ObjectHasher.allowSubtle) {
+      try {
+        const hashArray = await this.subtleHash(data);
+        return hexFromArrayBuffer(hashArray, { bitLength: 256 });
+      } catch {
+        _ObjectHasher.allowSubtle = false;
+      }
+    }
+    await this.wasmInitialized;
+    if (_ObjectHasher.wasmSupport.canUseWasm) {
+      try {
+        return await this.wasmHash(data);
+      } catch {
+        _ObjectHasher.wasmSupport.allowWasm = false;
+      }
+    }
+    throw new Error("No subtle or wasm hashing available");
+  }
+  static async hashBytes(bytes) {
+    const bytesArray = new Uint8Array(bytes);
+    if (_ObjectHasher.allowSubtle) {
+      const hashArray = await this.subtleHash(bytesArray);
+      return hexFromArrayBuffer(hashArray, { bitLength: 256 });
+    }
+    await this.wasmInitialized;
+    if (_ObjectHasher.wasmSupport.canUseWasm) {
+      return await this.wasmHash(bytesArray);
+    }
+    throw new Error("No subtle or wasm hashing available");
+  }
+  static hashFields(obj) {
+    const filtered = omitBy(obj, omitByPredicate("_"));
+    const cleaned = removeEmptyFields(filtered);
+    return sortFields(cleaned);
+  }
+  /**
+   * Creates an array of payload/hash tuples based on the payloads passed in
+   * @param objs Any array of payloads
+   * @returns An array of payload/hash tuples
+   */
+  static async hashPairs(objs) {
+    return await Promise.all(objs.map(async (obj) => [obj, await this.hash(obj)]));
+  }
+  /**
+   * Creates an array of payload hashes based on the payloads passed in
+   * @param objs Any array of payloads
+   * @returns An array of payload hashes
+   */
+  static async hashes(objs) {
+    return objs ? await Promise.all(objs.map((obj) => this.hash(obj))) : void 0;
+  }
+  /**
+   * Returns a clone of the payload that is JSON safe
+   * @param obj A payload
+   * @param meta Keeps underscore (meta) fields if set to true
+   * @returns Returns a clone of the payload that is JSON safe
+   */
+  static json(payload, meta = false) {
+    const source = meta ? payload : omitBy(payload, omitByPredicate("_"));
+    const cleaned = removeEmptyFields(source);
+    return sortFields(cleaned);
+  }
+  /** @deprecated us JSON instead */
+  static jsonPayload(payload, meta = false) {
+    return this.json(payload, meta);
+  }
+  static stringifyHashFields(obj) {
+    return JSON.stringify(this.hashFields(obj));
+  }
+  static async subtleHash(data) {
+    const pool = this.subtleHashPool;
+    if (pool === null) return await globalThis.crypto.subtle.digest("SHA-256", data);
+    const result = await pool.queue(async (thread) => await thread.hash(data));
+    return result;
+  }
+  static async wasmHash(data) {
+    const pool = this.wasmHashPool;
+    if (pool === null) return asHash(await sha256(data), true);
+    const result = await pool.queue(async (thread) => await thread.hash(data));
+    return result;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static createWorkerPool(url, func, size = 8) {
+    if (url) console.debug(`createWorkerPool: ${url.href}`);
+    const createFunc = () => spawn(this.createWorker(url, func));
+    return Pool(createFunc, size);
+  }
+  async hash() {
+    return await _ObjectHasher.hash(this.obj);
+  }
+  /**
+   * Returns a clone of the payload that is JSON safe
+   * @param meta Keeps underscore (meta) fields if set to true
+   * @returns Returns a clone of the payload that is JSON safe
+   */
+  json(meta = false) {
+    return _ObjectHasher.json(this.obj, meta);
+  }
+};
+
+// src/BrowserObjectHasher.ts
+ObjectHasher.createBrowserWorker = createBrowserWorker;
+ObjectHasher.createNodeWorker = createNodeWorker;
+var BrowserObjectHasher = class extends ObjectHasher {
+  static createBrowserWorker = createBrowserWorker;
+  static createNodeWorker = createNodeWorker;
+  static subtleHashWorkerUrl = (() => {
+    try {
+      return new URL("worker/subtleHash-bundle.mjs", import.meta.url);
+    } catch {
+      return;
+    }
+  })();
+  static wasmHashWorkerUrl = (() => {
+    try {
+      return new URL("worker/wasmHash-bundle.mjs", import.meta.url);
+    } catch {
+      return;
+    }
+  })();
+};
+export {
+  BrowserObjectHasher as ObjectHasher,
+  removeEmptyFields,
+  sortFields
+};
+//# sourceMappingURL=index-browser.mjs.map

package/dist/_pkg/hash/browser/index.d.ts

@@ -0,0 +1,5 @@
+export * from './hasEmptyFields.ts';
+export { NodeObjectHasher as ObjectHasher } from './NodeObjectHasher.ts';
+export * from './removeEmptyFields.ts';
+export * from './sortFields.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/hash/browser/removeEmptyFields.d.ts

@@ -0,0 +1,3 @@
+import type { EmptyObject } from '@xylabs/sdk';
+export declare const removeEmptyFields: <T extends EmptyObject>(obj: T) => T;
+//# sourceMappingURL=removeEmptyFields.d.ts.map

package/dist/_pkg/hash/browser/sortFields.d.ts

@@ -0,0 +1,3 @@
+import type { EmptyObject } from '@xylabs/sdk';
+export declare const sortFields: <T extends EmptyObject>(obj: T) => T;
+//# sourceMappingURL=sortFields.d.ts.map

package/dist/_pkg/hash/browser/worker/index.d.ts

@@ -0,0 +1,3 @@
+export * from './subtleHashNode.ts';
+export * from './wasmHashNode.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/hash/browser/worker/subtleHash-bundle.mjs

@@ -0,0 +1,257 @@
+"use strict";
+(() => {
+  // ../../../../../../node_modules/.pnpm/@xylabs+threads@7.0.1_debug@4.4.3_observable-fns@0.6.1/node_modules/@xylabs/threads/dist/browser/worker/worker.browser.mjs
+  var DefaultErrorSerializer = {
+    deserialize: (message) => {
+      const error = Object.create(Error.prototype);
+      error.message = message.message;
+      error.name = message.name;
+      error.stack = message.stack;
+      return error;
+    },
+    serialize: (error) => ({
+      __error_marker: "$$error",
+      message: error.message,
+      name: error.name,
+      stack: error.stack
+    })
+  };
+  var isSerializedError = (thing) => thing != null && typeof thing === "object" && "__error_marker" in thing && thing.__error_marker === "$$error";
+  var DefaultSerializer = {
+    deserialize: (message) => isSerializedError(message) ? DefaultErrorSerializer.deserialize(message) : message,
+    serialize: (input) => input instanceof Error ? DefaultErrorSerializer.serialize(input) : input
+  };
+  globalThis.registeredSerializer = globalThis.registeredSerializer ?? DefaultSerializer;
+  function deserialize(message) {
+    return globalThis.registeredSerializer.deserialize(message);
+  }
+  function serialize(input) {
+    return globalThis.registeredSerializer.serialize(input);
+  }
+  var isSomeObservable = (value) => {
+    if (value == null) {
+      return false;
+    }
+    if (typeof Symbol.observable === "symbol" && typeof value[Symbol.observable] === "function") {
+      return value === value[Symbol.observable]();
+    }
+    if (typeof value["@@observable"] === "function") {
+      return value === value["@@observable"]();
+    }
+    return false;
+  };
+  var $transferable = /* @__PURE__ */ Symbol("thread.transferable");
+  function isTransferDescriptor(thing) {
+    return thing != null && typeof thing === "object" && Reflect.get(thing, $transferable) === true;
+  }
+  var isErrorEvent = (value) => value !== void 0 && value.error !== void 0;
+  function createExpose(implementation, self2) {
+    let exposeCalled = false;
+    const activeSubscriptions = /* @__PURE__ */ new Map();
+    const isMasterJobCancelMessage = (thing) => thing?.type === "cancel";
+    const isMasterJobRunMessage = (thing) => thing?.type === "run";
+    const isObservable = (thing) => isSomeObservable(thing) || isZenObservable(thing);
+    function isZenObservable(thing) {
+      return thing != null && typeof thing === "object" && typeof thing.subscribe === "function";
+    }
+    function deconstructTransfer(thing) {
+      return isTransferDescriptor(thing) ? { payload: thing.send, transferables: thing.transferables } : { payload: thing, transferables: void 0 };
+    }
+    function postFunctionInitMessage() {
+      const initMessage = {
+        exposed: { type: "function" },
+        type: "init"
+        /* init */
+      };
+      implementation.postMessageToMaster(initMessage);
+    }
+    function postModuleInitMessage(methodNames) {
+      const initMessage = {
+        exposed: {
+          methods: methodNames,
+          type: "module"
+        },
+        type: "init"
+        /* init */
+      };
+      implementation.postMessageToMaster(initMessage);
+    }
+    function postJobErrorMessage(uid, rawError) {
+      const { payload: error, transferables } = deconstructTransfer(rawError);
+      const errorMessage = {
+        error: serialize(error),
+        type: "error",
+        uid
+      };
+      implementation.postMessageToMaster(errorMessage, transferables);
+    }
+    function postJobResultMessage(uid, completed, resultValue) {
+      const { payload, transferables } = deconstructTransfer(resultValue);
+      const resultMessage = {
+        complete: completed ? true : void 0,
+        payload,
+        type: "result",
+        uid
+      };
+      implementation.postMessageToMaster(resultMessage, transferables);
+    }
+    function postJobStartMessage(uid, resultType) {
+      const startMessage = {
+        resultType,
+        type: "running",
+        uid
+      };
+      implementation.postMessageToMaster(startMessage);
+    }
+    function postUncaughtErrorMessage(error) {
+      try {
+        const errorMessage = {
+          error: serialize(error),
+          type: "uncaughtError"
+          /* uncaughtError */
+        };
+        implementation.postMessageToMaster(errorMessage);
+      } catch (subError) {
+        console.error(
+          "Not reporting uncaught error back to master thread as it occured while reporting an uncaught error already.\nLatest error:",
+          subError,
+          "\nOriginal error:",
+          error
+        );
+      }
+    }
+    async function runFunction(jobUID, fn, args) {
+      let syncResult;
+      try {
+        syncResult = fn(...args);
+      } catch (ex) {
+        const error = ex;
+        return postJobErrorMessage(jobUID, error);
+      }
+      const resultType = isObservable(syncResult) ? "observable" : "promise";
+      postJobStartMessage(jobUID, resultType);
+      if (isObservable(syncResult)) {
+        const subscription = syncResult.subscribe(
+          (value) => postJobResultMessage(jobUID, false, serialize(value)),
+          (error) => {
+            postJobErrorMessage(jobUID, serialize(error));
+            activeSubscriptions.delete(jobUID);
+          },
+          () => {
+            postJobResultMessage(jobUID, true);
+            activeSubscriptions.delete(jobUID);
+          }
+        );
+        activeSubscriptions.set(jobUID, subscription);
+      } else {
+        try {
+          const result = await syncResult;
+          postJobResultMessage(jobUID, true, serialize(result));
+        } catch (error) {
+          postJobErrorMessage(jobUID, serialize(error));
+        }
+      }
+    }
+    const expose2 = (exposed) => {
+      if (!implementation.isWorkerRuntime()) {
+        throw new Error("expose() called in the master thread.");
+      }
+      if (exposeCalled) {
+        throw new Error("expose() called more than once. This is not possible. Pass an object to expose() if you want to expose multiple functions.");
+      }
+      exposeCalled = true;
+      if (typeof exposed === "function") {
+        implementation.subscribeToMasterMessages((messageData) => {
+          if (isMasterJobRunMessage(messageData) && messageData.method === void 0) {
+            runFunction(messageData.uid, exposed, messageData.args.map(deserialize));
+          }
+        });
+        postFunctionInitMessage();
+      } else if (typeof exposed === "object" && exposed !== null) {
+        implementation.subscribeToMasterMessages((messageData) => {
+          if (isMasterJobRunMessage(messageData) && messageData.method !== void 0) {
+            runFunction(messageData.uid, exposed[messageData.method], messageData.args.map(deserialize));
+          }
+        });
+        const methodNames = Object.keys(exposed).filter((key) => typeof exposed[key] === "function");
+        postModuleInitMessage(methodNames);
+      } else {
+        throw new Error(`Invalid argument passed to expose(). Expected a function or an object, got: ${exposed}`);
+      }
+      implementation.subscribeToMasterMessages((messageData) => {
+        if (!isMasterJobCancelMessage(messageData)) {
+          return;
+        }
+        const jobUID = messageData.uid;
+        const subscription = activeSubscriptions.get(jobUID);
+        if (subscription) {
+          subscription.unsubscribe();
+          activeSubscriptions.delete(jobUID);
+        }
+      });
+    };
+    const subscribeToBrowserUncaughtErrors = () => {
+      if (typeof globalThis === "undefined" || typeof self2.addEventListener !== "function" || !implementation.isWorkerRuntime()) {
+        return;
+      }
+      self2.addEventListener("error", (event) => {
+        setTimeout(() => postUncaughtErrorMessage(isErrorEvent(event) ? event.error : event), 250);
+      });
+      self2.addEventListener("unhandledrejection", (event) => {
+        const error = event.reason;
+        if (error != null && typeof error === "object" && typeof error.message === "string") {
+          setTimeout(() => postUncaughtErrorMessage(error), 250);
+        }
+      });
+    };
+    const subscribeToNodeUncaughtErrors = () => {
+      const nodeProcess = globalThis.process;
+      if (nodeProcess === void 0 || typeof nodeProcess.on !== "function" || !implementation.isWorkerRuntime()) {
+        return;
+      }
+      nodeProcess.on("uncaughtException", (error) => {
+        setTimeout(() => postUncaughtErrorMessage(error), 250);
+      });
+      nodeProcess.on("unhandledRejection", (error) => {
+        if (error != null && typeof error === "object" && typeof error.message === "string") {
+          setTimeout(() => postUncaughtErrorMessage(error), 250);
+        }
+      });
+    };
+    subscribeToBrowserUncaughtErrors();
+    subscribeToNodeUncaughtErrors();
+    return expose2;
+  }
+  var isWorkerRuntime = function isWorkerRuntime2() {
+    const isWindowContext = self !== void 0 && typeof Window !== "undefined" && self instanceof Window;
+    return self?.postMessage !== void 0 && !isWindowContext;
+  };
+  var postMessageToMaster = function postMessageToMaster2(data, transferList) {
+    self.postMessage(data, transferList);
+  };
+  var subscribeToMasterMessages = function subscribeToMasterMessages2(onMessage) {
+    const messageHandler = (messageEvent) => {
+      onMessage(messageEvent.data);
+    };
+    const unsubscribe = () => {
+      self.removeEventListener("message", messageHandler);
+    };
+    self.addEventListener("message", messageHandler);
+    return unsubscribe;
+  };
+  var addEventListener = self.addEventListener.bind(void 0);
+  var postMessage = self.postMessage.bind(void 0);
+  var removeEventListener = self.removeEventListener.bind(void 0);
+  var expose = createExpose({
+    isWorkerRuntime,
+    postMessageToMaster,
+    subscribeToMasterMessages
+  }, {
+    addEventListener,
+    postMessage,
+    removeEventListener
+  });
+
+  // src/worker/subtleHash.ts
+  expose({ hash: async (data) => await globalThis.crypto.subtle.digest("SHA-256", data) });
+})();

package/dist/_pkg/hash/browser/worker/subtleHash.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=subtleHash.d.ts.map

package/dist/_pkg/hash/browser/worker/subtleHashNode.d.ts

@@ -0,0 +1,2 @@
+export declare const subtleHashFunc: () => void;
+//# sourceMappingURL=subtleHashNode.d.ts.map