@buoy-gg/shared-ui 1.7.2

package/lib/commonjs/utils/loadOptionalModule.js

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCachedOptionalModule = getCachedOptionalModule;
+exports.loadOptionalModule = loadOptionalModule;
+// Minimal logger interface so callers can plug in their own logging or rely on console.
+
+const defaultLogger = {
+  log: () => {},
+  // Debug logging removed for production
+  warn: () => {},
+  // Warnings disabled in production
+  error: (...args) => {
+    console.error("[optional-module]", ...args);
+  }
+};
+const resolvedModules = new Map();
+const pendingLoads = new Map();
+const warnedKeys = new Set();
+
+/**
+ * Dynamically loads an optional dependency and caches the result. Returns `null`
+ * when the module cannot be imported.
+ */
+async function loadOptionalModule(moduleName, options = {}) {
+  if (resolvedModules.has(moduleName)) {
+    return resolvedModules.get(moduleName);
+  }
+  const logger = {
+    ...defaultLogger,
+    ...(options.logger ?? {})
+  };
+  if (!pendingLoads.has(moduleName)) {
+    pendingLoads.set(moduleName, (async () => {
+      try {
+        const mod = await loadModuleWithFallback(moduleName, options);
+        const resolved = mod?.default ?? mod;
+        resolvedModules.set(moduleName, resolved);
+        logger.log("Loaded optional module", moduleName);
+        return resolved;
+      } catch (error) {
+        logger.log("Optional module unavailable", moduleName, error);
+        resolvedModules.set(moduleName, null);
+        return null;
+      }
+    })());
+  }
+  const loaded = await pendingLoads.get(moduleName);
+  pendingLoads.delete(moduleName);
+  if (!loaded && options.warnOnceKey && !warnedKeys.has(options.warnOnceKey)) {
+    warnedKeys.add(options.warnOnceKey);
+    logger.warn(options.warningMessage ?? `Module '${moduleName}' not found.`);
+  }
+  return loaded;
+}
+const dynamicImportLoader = (() => {
+  try {
+    return new Function("moduleName", "return import(moduleName);");
+  } catch {
+    return null;
+  }
+})();
+const dynamicRequire = (() => {
+  try {
+    return new Function("return typeof require === 'function' ? require : undefined;")();
+  } catch {
+    return undefined;
+  }
+})();
+async function loadModuleWithFallback(moduleName, options) {
+  if (options.loader) {
+    return await Promise.resolve(options.loader());
+  }
+  if (dynamicImportLoader) {
+    return dynamicImportLoader(moduleName);
+  }
+  if (dynamicRequire) {
+    return dynamicRequire(moduleName);
+  }
+  throw new Error(`No dynamic loader available for optional module '${moduleName}'.`);
+}
+
+/**
+ * Synchronous getter that returns a previously loaded optional module, or `null`
+ * if it has either not been loaded yet or failed to load.
+ */
+function getCachedOptionalModule(moduleName) {
+  if (!resolvedModules.has(moduleName)) {
+    return null;
+  }
+  return resolvedModules.get(moduleName);
+}

package/lib/commonjs/utils/minimalSuperJSON.js

@@ -0,0 +1,337 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deserialize = deserialize;
+exports.serialize = serialize;
+/**
+ * Minimal SuperJSON implementation for DevTools
+ * Handles serialization/deserialization of special JavaScript types
+ * Zero dependencies, ~250 LOC
+ *
+ * Supports: Date, RegExp, Set, Map, Error, BigInt, undefined, NaN, Infinity, -0, URL, TypedArrays
+ */
+
+// ============================================================================
+// Type Guards
+// ============================================================================
+
+const isUndefined = payload => typeof payload === 'undefined';
+const isPlainObject = payload => {
+  if (typeof payload !== 'object' || payload === null) return false;
+  if (payload === Object.prototype) return false;
+  if (Object.getPrototypeOf(payload) === null) return true;
+  return Object.getPrototypeOf(payload) === Object.prototype;
+};
+const isArray = payload => Array.isArray(payload);
+const isPrimitive = payload => typeof payload === 'boolean' || payload === null || typeof payload === 'undefined' || typeof payload === 'number' || typeof payload === 'string' || typeof payload === 'symbol';
+const isDate = payload => payload instanceof Date && !isNaN(payload.valueOf());
+const isError = payload => payload instanceof Error;
+const isRegExp = payload => payload instanceof RegExp;
+const isSet = payload => payload instanceof Set;
+const isMap = payload => payload instanceof Map;
+const isBigint = payload => typeof payload === 'bigint';
+const isNaNValue = payload => typeof payload === 'number' && isNaN(payload);
+const isInfinite = payload => payload === Infinity || payload === -Infinity;
+const isMinusZero = payload => payload === 0 && 1 / payload === -Infinity;
+const isURL = payload => payload instanceof URL;
+const isTypedArray = payload => ArrayBuffer.isView(payload) && !(payload instanceof DataView);
+
+// ============================================================================
+// Type Transformations
+// ============================================================================
+
+const TYPED_ARRAY_CONSTRUCTORS = {
+  Int8Array,
+  Uint8Array,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array,
+  Uint8ClampedArray
+};
+const transformRules = [{
+  isApplicable: isUndefined,
+  annotation: 'undefined',
+  transform: () => null,
+  untransform: () => undefined
+}, {
+  isApplicable: isBigint,
+  annotation: 'bigint',
+  transform: v => v.toString(),
+  untransform: v => {
+    if (typeof BigInt !== 'undefined') {
+      return BigInt(v);
+    }
+    console.error('BigInt is not supported in this environment');
+    return v;
+  }
+}, {
+  isApplicable: isDate,
+  annotation: 'Date',
+  transform: v => v.toISOString(),
+  untransform: v => new Date(v)
+}, {
+  isApplicable: isError,
+  annotation: 'Error',
+  transform: v => ({
+    name: v.name,
+    message: v.message,
+    stack: v.stack,
+    cause: 'cause' in v ? v.cause : undefined
+  }),
+  untransform: v => {
+    const e = new Error(v.message);
+    e.name = v.name;
+    e.stack = v.stack;
+    if (v.cause !== undefined) {
+      e.cause = v.cause;
+    }
+    return e;
+  }
+}, {
+  isApplicable: isRegExp,
+  annotation: 'regexp',
+  transform: v => '' + v,
+  untransform: v => {
+    const body = v.slice(1, v.lastIndexOf('/'));
+    const flags = v.slice(v.lastIndexOf('/') + 1);
+    return new RegExp(body, flags);
+  }
+}, {
+  isApplicable: isSet,
+  annotation: 'set',
+  transform: v => [...v.values()],
+  untransform: v => new Set(v)
+}, {
+  isApplicable: isMap,
+  annotation: 'map',
+  transform: v => [...v.entries()],
+  untransform: v => new Map(v)
+}, {
+  isApplicable: v => isNaNValue(v) || isInfinite(v),
+  annotation: 'number',
+  transform: v => {
+    if (isNaNValue(v)) return 'NaN';
+    return v > 0 ? 'Infinity' : '-Infinity';
+  },
+  untransform: v => Number(v)
+}, {
+  isApplicable: isMinusZero,
+  annotation: 'number',
+  transform: () => '-0',
+  untransform: () => -0
+}, {
+  isApplicable: isURL,
+  annotation: 'URL',
+  transform: v => v.toString(),
+  untransform: v => new URL(v)
+}, {
+  isApplicable: isTypedArray,
+  annotation: v => ['typed-array', v.constructor.name],
+  transform: v => [...v],
+  untransform: (v, annotation) => {
+    const typeName = Array.isArray(annotation) ? annotation[1] : 'Uint8Array';
+    const ctor = TYPED_ARRAY_CONSTRUCTORS[typeName];
+    if (!ctor) {
+      throw new Error(`Unknown typed array: ${typeName}`);
+    }
+    return new ctor(v);
+  }
+}];
+
+// ============================================================================
+// Serialization Walker
+// ============================================================================
+
+function transformValue(value) {
+  for (const rule of transformRules) {
+    if (rule.isApplicable(value)) {
+      const annotation = typeof rule.annotation === 'function' ? rule.annotation(value) : rule.annotation;
+      return {
+        value: rule.transform(value),
+        type: annotation
+      };
+    }
+  }
+  return undefined;
+}
+function untransformValue(json, type) {
+  for (const rule of transformRules) {
+    const ruleAnnotation = typeof rule.annotation === 'function' ? Array.isArray(type) ? type[0] : type : rule.annotation;
+    const matches = Array.isArray(type) && Array.isArray(ruleAnnotation) ? type[0] === ruleAnnotation[0] : ruleAnnotation === type;
+    if (matches) {
+      return rule.untransform(json, type);
+    }
+  }
+  throw new Error(`Unknown transformation: ${type}`);
+}
+const isDeep = object => isPlainObject(object) || isArray(object) || isMap(object) || isSet(object) || isError(object);
+function escapeKey(key) {
+  return key.replace(/\\/g, '\\\\').replace(/\./g, '\\.');
+}
+function walker(object, path = [], objectsInThisPath = []) {
+  const primitive = isPrimitive(object);
+
+  // Check for circular references
+  if (!primitive && !isDeep(object)) {
+    const transformed = transformValue(object);
+    return transformed ? {
+      transformedValue: transformed.value,
+      annotations: {
+        [path.map(String).map(escapeKey).join('.')]: transformed.type
+      }
+    } : {
+      transformedValue: object
+    };
+  }
+  if (!primitive && objectsInThisPath.indexOf(object) !== -1) {
+    // Circular reference detected
+    return {
+      transformedValue: null
+    };
+  }
+  if (!isDeep(object)) {
+    const transformed = transformValue(object);
+    return transformed ? {
+      transformedValue: transformed.value,
+      annotations: path.length > 0 ? {
+        [path.map(String).map(escapeKey).join('.')]: transformed.type
+      } : {
+        '': transformed.type
+      }
+    } : {
+      transformedValue: object
+    };
+  }
+  const transformationResult = transformValue(object);
+  const transformed = transformationResult?.value ?? object;
+  const transformedValue = isArray(transformed) ? [] : {};
+  const allAnnotations = {};
+
+  // Add annotation for the object itself if it was transformed
+  if (transformationResult) {
+    const key = path.length > 0 ? path.map(String).map(escapeKey).join('.') : '';
+    allAnnotations[key] = transformationResult.type;
+  }
+
+  // Iterate over object/array properties
+  const entries = isArray(transformed) ? transformed.map((v, i) => [i, v]) : Object.entries(transformed);
+  for (const [index, value] of entries) {
+    const indexStr = String(index);
+
+    // Prototype pollution prevention
+    if (indexStr === '__proto__' || indexStr === 'constructor' || indexStr === 'prototype') {
+      throw new Error(`Detected property ${indexStr}. This is a prototype pollution risk, please remove it from your object.`);
+    }
+    const recursiveResult = walker(value, [...path, index], [...objectsInThisPath, object]);
+    transformedValue[index] = recursiveResult.transformedValue;
+    if (recursiveResult.annotations) {
+      Object.assign(allAnnotations, recursiveResult.annotations);
+    }
+  }
+  return {
+    transformedValue,
+    annotations: Object.keys(allAnnotations).length > 0 ? allAnnotations : undefined
+  };
+}
+
+// ============================================================================
+// Deep Access Utilities
+// ============================================================================
+
+function parsePath(pathString) {
+  if (pathString === '') return [];
+  const result = [];
+  let segment = '';
+  for (let i = 0; i < pathString.length; i++) {
+    const char = pathString.charAt(i);
+    if (char === '\\') {
+      const nextChar = pathString.charAt(i + 1);
+      if (nextChar === '\\') {
+        segment += '\\';
+        i++;
+        continue;
+      } else if (nextChar === '.') {
+        segment += '.';
+        i++;
+        continue;
+      }
+    }
+    if (char === '.') {
+      result.push(segment);
+      segment = '';
+      continue;
+    }
+    segment += char;
+  }
+  if (segment) {
+    result.push(segment);
+  }
+  return result;
+}
+function setDeep(object, path, value) {
+  if (path.length === 0) {
+    return;
+  }
+  let current = object;
+  for (let i = 0; i < path.length - 1; i++) {
+    current = current[path[i]];
+  }
+  current[path[path.length - 1]] = value;
+}
+function getDeep(object, path) {
+  let current = object;
+  for (const key of path) {
+    current = current[key];
+  }
+  return current;
+}
+
+// ============================================================================
+// Public API
+// ============================================================================
+
+function serialize(object) {
+  const result = walker(object);
+  const res = {
+    json: result.transformedValue
+  };
+  if (result.annotations) {
+    res.meta = {
+      values: result.annotations
+    };
+  }
+  return res;
+}
+function deserialize(payload) {
+  const {
+    json,
+    meta
+  } = payload;
+  if (!meta?.values) {
+    return json;
+  }
+
+  // Create a shallow copy to avoid mutating the input
+  let result = isArray(json) ? [...json] : {
+    ...json
+  };
+
+  // Apply transformations
+  for (const [pathString, type] of Object.entries(meta.values)) {
+    const path = parsePath(pathString);
+    if (path.length === 0) {
+      // Root level transformation
+      result = untransformValue(result, type);
+    } else {
+      const value = getDeep(result, path);
+      const transformed = untransformValue(value, type);
+      setDeep(result, path, transformed);
+    }
+  }
+  return result;
+}