@fxhash/params 0.0.4 → 0.0.7

package/dist/chunk-2QU65L2O.cjs

@@ -0,0 +1,399 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/utils.ts
+function rgbaToHex(r, g, b, a) {
+  const outParts = [
+    r.toString(16),
+    g.toString(16),
+    b.toString(16),
+    Math.round(a * 255).toString(16).substring(0, 2)
+  ];
+  outParts.forEach(function(part, i) {
+    if (part.length === 1) {
+      outParts[i] = "0" + part;
+    }
+  });
+  return "#" + outParts.join("");
+}
+function completeHexColor(hexCode) {
+  let hex = hexCode.replace("#", "");
+  if (hex.length === 6) {
+    hex = `${hex}ff`;
+  }
+  if (hex.length === 3) {
+    hex = `${hex[0]}${hex[0]}${hex[1]}${hex[1]}${hex[2]}${hex[2]}ff`;
+  }
+  return hex;
+}
+function hexToRgba(hexCode) {
+  const hex = completeHexColor(hexCode);
+  const r = parseInt(hex.substring(0, 2), 16);
+  const g = parseInt(hex.substring(2, 4), 16);
+  const b = parseInt(hex.substring(4, 6), 16);
+  const a = Math.round(
+    (parseInt(hex.substring(6, 8), 16) / 255 + Number.EPSILON) * 100
+  ) / 100;
+  return { r, g, b, a };
+}
+var stringToHex = function(s) {
+  let rtn = "";
+  for (let i = 0; i < s.length; i++) {
+    rtn += s.charCodeAt(i).toString(16).padStart(4, "0");
+  }
+  return rtn;
+};
+var hexToString = function(h) {
+  const hx = h.match(/.{1,4}/g) || [];
+  let rtn = "";
+  for (let i = 0; i < hx.length; i++) {
+    const int = parseInt(hx[i], 16);
+    if (int === 0)
+      break;
+    rtn += String.fromCharCode(int);
+  }
+  return rtn;
+};
+var MIN_SAFE_INT64 = BigInt("-9223372036854775808");
+var MAX_SAFE_INT64 = BigInt("9223372036854775807");
+var ParameterProcessors = {
+  number: {
+    serialize: (input) => {
+      const view = new DataView(new ArrayBuffer(8));
+      view.setFloat64(0, input);
+      return view.getBigUint64(0).toString(16).padStart(16, "0");
+    },
+    deserialize: (input) => {
+      const view = new DataView(new ArrayBuffer(8));
+      for (let i = 0; i < 8; i++) {
+        view.setUint8(i, parseInt(input.substring(i * 2, i * 2 + 2), 16));
+      }
+      return view.getFloat64(0);
+    },
+    bytesLength: () => 8,
+    constrain: (value, definition) => {
+      let min = Number.MIN_SAFE_INTEGER;
+      if (typeof _optionalChain([definition, 'access', _ => _.options, 'optionalAccess', _2 => _2.min]) !== "undefined")
+        min = Number(definition.options.min);
+      let max = Number.MAX_SAFE_INTEGER;
+      if (typeof _optionalChain([definition, 'access', _3 => _3.options, 'optionalAccess', _4 => _4.max]) !== "undefined")
+        max = Number(definition.options.max);
+      max = Math.min(max, Number.MAX_SAFE_INTEGER);
+      min = Math.max(min, Number.MIN_SAFE_INTEGER);
+      const v = Math.min(Math.max(value, min), max);
+      if (_optionalChain([definition, 'optionalAccess', _5 => _5.options, 'optionalAccess', _6 => _6.step])) {
+        const t = 1 / _optionalChain([definition, 'optionalAccess', _7 => _7.options, 'optionalAccess', _8 => _8.step]);
+        return Math.round(v * t) / t;
+      }
+      return v;
+    },
+    random: (definition) => {
+      let min = Number.MIN_SAFE_INTEGER;
+      if (typeof _optionalChain([definition, 'access', _9 => _9.options, 'optionalAccess', _10 => _10.min]) !== "undefined")
+        min = Number(definition.options.min);
+      let max = Number.MAX_SAFE_INTEGER;
+      if (typeof _optionalChain([definition, 'access', _11 => _11.options, 'optionalAccess', _12 => _12.max]) !== "undefined")
+        max = Number(definition.options.max);
+      max = Math.min(max, Number.MAX_SAFE_INTEGER);
+      min = Math.max(min, Number.MIN_SAFE_INTEGER);
+      const v = Math.random() * (max - min) + min;
+      if (_optionalChain([definition, 'optionalAccess', _13 => _13.options, 'optionalAccess', _14 => _14.step])) {
+        const t = 1 / _optionalChain([definition, 'optionalAccess', _15 => _15.options, 'optionalAccess', _16 => _16.step]);
+        return Math.round(v * t) / t;
+      }
+      return v;
+    }
+  },
+  bigint: {
+    serialize: (input) => {
+      const view = new DataView(new ArrayBuffer(8));
+      view.setBigInt64(0, BigInt(input));
+      return view.getBigUint64(0).toString(16).padStart(16, "0");
+    },
+    deserialize: (input) => {
+      const view = new DataView(new ArrayBuffer(8));
+      for (let i = 0; i < 8; i++) {
+        view.setUint8(i, parseInt(input.substring(i * 2, i * 2 + 2), 16));
+      }
+      return view.getBigInt64(0);
+    },
+    bytesLength: () => 8,
+    random: (definition) => {
+      let min = MIN_SAFE_INT64;
+      let max = MAX_SAFE_INT64;
+      if (typeof _optionalChain([definition, 'access', _17 => _17.options, 'optionalAccess', _18 => _18.min]) !== "undefined")
+        min = BigInt(definition.options.min);
+      if (typeof _optionalChain([definition, 'access', _19 => _19.options, 'optionalAccess', _20 => _20.max]) !== "undefined")
+        max = BigInt(definition.options.max);
+      const range = max - min;
+      const bits = range.toString(2).length;
+      let random;
+      do {
+        random = BigInt(
+          "0b" + Array.from(
+            crypto.getRandomValues(new Uint8Array(Math.ceil(bits / 8)))
+          ).map((b) => b.toString(2).padStart(8, "0")).join("")
+        );
+      } while (random > range);
+      return random + min;
+    }
+  },
+  boolean: {
+    serialize: (input) => {
+      return typeof input === "boolean" ? input ? "01" : "00" : typeof input === "string" ? input === "true" ? "01" : "00" : "00";
+    },
+    deserialize: (input) => {
+      return input === "00" ? false : true;
+    },
+    bytesLength: () => 1,
+    random: () => Math.random() < 0.5
+  },
+  color: {
+    serialize: (input) => {
+      return completeHexColor(input);
+    },
+    deserialize: (input) => {
+      return input;
+    },
+    bytesLength: () => 4,
+    transform: (input) => {
+      const color = completeHexColor(input);
+      const r = parseInt(color.slice(0, 2), 16);
+      const g = parseInt(color.slice(2, 4), 16);
+      const b = parseInt(color.slice(4, 6), 16);
+      const a = parseInt(color.slice(6, 8), 16);
+      return {
+        hex: {
+          rgb: "#" + input.slice(0, 6),
+          rgba: "#" + input
+        },
+        obj: {
+          rgb: { r, g, b },
+          rgba: { r, g, b, a }
+        },
+        arr: {
+          rgb: [r, g, b],
+          rgba: [r, g, b, a]
+        }
+      };
+    },
+    constrain: (value) => {
+      const hex = value.replace("#", "");
+      return hex.slice(0, 8).padEnd(8, "f");
+    },
+    random: () => `${[...Array(8)].map(() => Math.floor(Math.random() * 16).toString(16)).join("")}`
+  },
+  string: {
+    serialize: (input, def) => {
+      if (!def.version) {
+        let hex2 = stringToHex(input.substring(0, 64));
+        hex2 = hex2.padEnd(64 * 4, "0");
+        return hex2;
+      }
+      let max = 64;
+      if (typeof _optionalChain([def, 'access', _21 => _21.options, 'optionalAccess', _22 => _22.maxLength]) !== "undefined")
+        max = Number(def.options.maxLength);
+      let hex = stringToHex(input.substring(0, max));
+      hex = hex.padEnd(max * 4, "0");
+      return hex;
+    },
+    deserialize: (input) => {
+      return hexToString(input);
+    },
+    bytesLength: (def) => {
+      if (!def.version) {
+        return 64 * 2;
+      }
+      if (typeof _optionalChain([def, 'access', _23 => _23.options, 'optionalAccess', _24 => _24.maxLength]) !== "undefined")
+        return Number(def.options.maxLength) * 2;
+      return 64 * 2;
+    },
+    random: (definition) => {
+      let min = 0;
+      if (typeof _optionalChain([definition, 'access', _25 => _25.options, 'optionalAccess', _26 => _26.minLength]) !== "undefined")
+        min = definition.options.minLength;
+      let max = 64;
+      if (typeof _optionalChain([definition, 'access', _27 => _27.options, 'optionalAccess', _28 => _28.maxLength]) !== "undefined")
+        max = definition.options.maxLength;
+      const length = Math.round(Math.random() * (max - min) + min);
+      return [...Array(length)].map((i) => (~~(Math.random() * 36)).toString(36)).join("");
+    },
+    constrain: (value, definition) => {
+      let min = 0;
+      if (typeof _optionalChain([definition, 'access', _29 => _29.options, 'optionalAccess', _30 => _30.minLength]) !== "undefined")
+        min = definition.options.minLength;
+      let max = 64;
+      if (typeof _optionalChain([definition, 'access', _31 => _31.options, 'optionalAccess', _32 => _32.maxLength]) !== "undefined")
+        max = definition.options.maxLength;
+      const v = value.slice(0, max);
+      if (v.length < min) {
+        return v.padEnd(min);
+      }
+      return v;
+    }
+  },
+  bytes: {
+    serialize: (input, def) => {
+      return Array.from(input).map((i) => i.toString(16).padStart(2, "0")).join("");
+    },
+    deserialize: (input, def) => {
+      const len = input.length / 2;
+      const uint8 = new Uint8Array(len);
+      let idx;
+      for (let i = 0; i < len; i++) {
+        idx = i * 2;
+        uint8[i] = parseInt(`${input[idx]}${input[idx + 1]}`, 16);
+      }
+      return uint8;
+    },
+    bytesLength: (def) => def.options.length,
+    random: (def) => {
+      const len = _optionalChain([def, 'access', _33 => _33.options, 'optionalAccess', _34 => _34.length]) || 0;
+      const uint8 = new Uint8Array(len);
+      for (let i = 0; i < len; i++) {
+        uint8[i] = Math.random() * 255 | 0;
+      }
+      return uint8;
+    }
+  },
+  select: {
+    serialize: (input, def) => {
+      return Math.min(255, _optionalChain([def, 'access', _35 => _35.options, 'optionalAccess', _36 => _36.options, 'optionalAccess', _37 => _37.indexOf, 'call', _38 => _38(input)]) || 0).toString(16).padStart(2, "0");
+    },
+    deserialize: (input, def) => {
+      const idx = parseInt(input, 16);
+      return _optionalChain([def, 'access', _39 => _39.options, 'optionalAccess', _40 => _40.options, 'optionalAccess', _41 => _41[idx]]) || _optionalChain([def, 'access', _42 => _42.options, 'optionalAccess', _43 => _43.options, 'optionalAccess', _44 => _44[0]]) || "";
+    },
+    bytesLength: () => 1,
+    // index between 0 and 255
+    constrain: (value, definition) => {
+      if (definition.options.options.includes(value)) {
+        return value;
+      }
+      return definition.options.options[0];
+    },
+    random: (definition) => {
+      const index = Math.round(
+        Math.random() * (definition.options.options.length - 1) + 0
+      );
+      return _optionalChain([definition, 'optionalAccess', _45 => _45.options, 'optionalAccess', _46 => _46.options, 'access', _47 => _47[index]]);
+    }
+  }
+};
+function serializeParams(params, definition) {
+  let bytes = "";
+  if (!definition)
+    return bytes;
+  for (const def of definition) {
+    const { id, type } = def;
+    const processor = ParameterProcessors[type];
+    const v = params[id];
+    const val = typeof v !== "undefined" ? v : typeof def.default !== "undefined" ? def.default : processor.random(def);
+    const serialized = processor.serialize(val, def);
+    bytes += serialized;
+  }
+  return bytes;
+}
+function deserializeParams(bytes, definition, options) {
+  const params = {};
+  console.log(bytes, definition, options);
+  for (const def of definition) {
+    const processor = ParameterProcessors[def.type];
+    const transformer = options.withTransform && processor[options.transformType || "transform"];
+    if (!bytes) {
+      let v;
+      if (typeof def.default === "undefined")
+        v = processor.random(def);
+      else
+        v = def.default;
+      params[def.id] = transformer ? transformer(v, def) : v;
+      continue;
+    }
+    const bytesLen = processor.bytesLength(def);
+    const valueBytes = bytes.substring(0, bytesLen * 2);
+    bytes = bytes.substring(bytesLen * 2);
+    const val = processor.deserialize(valueBytes, def);
+    params[def.id] = transformer ? transformer(val, def) : val;
+  }
+  return params;
+}
+function consolidateParams(params, data) {
+  if (!params)
+    return [];
+  const rtn = [...params];
+  for (const p in rtn) {
+    const definition = rtn[p];
+    const { id, type, default: def } = definition;
+    if (data && data.hasOwnProperty(id)) {
+      rtn[p].value = data[id];
+    } else {
+      const processor = ParameterProcessors[type];
+      let v;
+      if (typeof def === "undefined")
+        v = processor.random(definition);
+      else
+        v = def;
+      rtn[p].value = _optionalChain([processor, 'access', _48 => _48.transform, 'optionalCall', _49 => _49(v)]) || v;
+    }
+  }
+  return rtn;
+}
+function getRandomParamValues(params, options) {
+  return params.reduce((acc, definition) => {
+    const processor = ParameterProcessors[definition.type];
+    const v = processor.random(definition);
+    acc[definition.id] = _optionalChain([options, 'optionalAccess', _50 => _50.noTransform]) ? v : _optionalChain([processor, 'access', _51 => _51.transform, 'optionalCall', _52 => _52(v)]) || v;
+    return acc;
+  }, {});
+}
+function sumBytesParams(definitions) {
+  return _optionalChain([definitions, 'optionalAccess', _53 => _53.reduce, 'call', _54 => _54(
+    (acc, def) => acc + ParameterProcessors[def.type].bytesLength(def),
+    0
+  )]) || 0;
+}
+function stringifyParamsData(data) {
+  return JSON.stringify(data, (key, value) => {
+    if (typeof value === "bigint")
+      return value.toString();
+    return value;
+  });
+}
+function jsonStringifyBigint(data) {
+  return JSON.stringify(data, (key, value) => {
+    if (typeof value === "bigint")
+      return value.toString();
+    return value;
+  });
+}
+var processParam = (paramId, value, definitions, transformType) => {
+  const definition = definitions.find((d) => d.id === paramId);
+  const processor = ParameterProcessors[definition.type];
+  const transformer = processor[transformType];
+  return _optionalChain([transformer, 'optionalCall', _55 => _55(value, definition)]) || value;
+};
+var processParams = (values, definitions, transformType) => {
+  const paramValues = {};
+  for (const definition of definitions) {
+    const processor = ParameterProcessors[definition.type];
+    const value = values[definition.id];
+    const transformer = processor[transformType];
+    paramValues[definition.id] = _optionalChain([transformer, 'optionalCall', _56 => _56(value, definition)]) || value;
+  }
+  return paramValues;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.rgbaToHex = rgbaToHex; exports.hexToRgba = hexToRgba; exports.MIN_SAFE_INT64 = MIN_SAFE_INT64; exports.MAX_SAFE_INT64 = MAX_SAFE_INT64; exports.ParameterProcessors = ParameterProcessors; exports.serializeParams = serializeParams; exports.deserializeParams = deserializeParams; exports.consolidateParams = consolidateParams; exports.getRandomParamValues = getRandomParamValues; exports.sumBytesParams = sumBytesParams; exports.stringifyParamsData = stringifyParamsData; exports.jsonStringifyBigint = jsonStringifyBigint; exports.processParam = processParam; exports.processParams = processParams;
+//# sourceMappingURL=chunk-2QU65L2O.cjs.map

package/dist/chunk-2QU65L2O.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils.ts"],"names":["hex"],"mappings":"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","sourcesContent":["import {\n  hexString,\n  FxParamDefinition,\n  FxParamProcessor,\n  FxParamProcessors,\n  FxParamTypeMap,\n  FxParamType,\n  FxParamsData,\n  FxParamValue,\n  FxParamTranformType,\n  FxParamTransformationTypeMap,\n  FxParamProcessorTransformer,\n} from \"./types\"\n\nexport function rgbaToHex(r: number, g: number, b: number, a: number): string {\n  const outParts = [\n    r.toString(16),\n    g.toString(16),\n    b.toString(16),\n    Math.round(a * 255)\n      .toString(16)\n      .substring(0, 2),\n  ]\n\n  // Pad single-digit output values\n  outParts.forEach(function (part, i) {\n    if (part.length === 1) {\n      outParts[i] = \"0\" + part\n    }\n  })\n\n  return \"#\" + outParts.join(\"\")\n}\n\nfunction completeHexColor(hexCode: hexString | string): string {\n  let hex = hexCode.replace(\"#\", \"\")\n  if (hex.length === 6) {\n    hex = `${hex}ff`\n  }\n  if (hex.length === 3) {\n    hex = `${hex[0]}${hex[0]}${hex[1]}${hex[1]}${hex[2]}${hex[2]}ff`\n  }\n  return hex\n}\n\nexport function hexToRgba(hexCode: hexString) {\n  const hex = completeHexColor(hexCode)\n\n  const r = parseInt(hex.substring(0, 2), 16)\n  const g = parseInt(hex.substring(2, 4), 16)\n  const b = parseInt(hex.substring(4, 6), 16)\n  const a =\n    Math.round(\n      (parseInt(hex.substring(6, 8), 16) / 255 + Number.EPSILON) * 100\n    ) / 100\n\n  return { r, g, b, a }\n}\n\nconst stringToHex = function (s: string) {\n  let rtn = \"\"\n  for (let i = 0; i < s.length; i++) {\n    rtn += s.charCodeAt(i).toString(16).padStart(4, \"0\")\n  }\n  return rtn\n}\nconst hexToString = function (h: string) {\n  const hx = h.match(/.{1,4}/g) || []\n  let rtn = \"\"\n  for (let i = 0; i < hx.length; i++) {\n    const int = parseInt(hx[i], 16)\n    if (int === 0) break\n    rtn += String.fromCharCode(int)\n  }\n  return rtn\n}\n\nexport const MIN_SAFE_INT64 = BigInt(\"-9223372036854775808\")\nexport const MAX_SAFE_INT64 = BigInt(\"9223372036854775807\")\n\nexport const ParameterProcessors: FxParamProcessors = {\n  number: {\n    serialize: input => {\n      const view = new DataView(new ArrayBuffer(8))\n      view.setFloat64(0, input)\n      return view.getBigUint64(0).toString(16).padStart(16, \"0\")\n    },\n    deserialize: input => {\n      const view = new DataView(new ArrayBuffer(8))\n      for (let i = 0; i < 8; i++) {\n        view.setUint8(i, parseInt(input.substring(i * 2, i * 2 + 2), 16))\n      }\n      return view.getFloat64(0)\n    },\n    bytesLength: () => 8,\n    constrain: (value, definition) => {\n      let min = Number.MIN_SAFE_INTEGER\n      if (typeof definition.options?.min !== \"undefined\")\n        min = Number(definition.options.min)\n      let max = Number.MAX_SAFE_INTEGER\n      if (typeof definition.options?.max !== \"undefined\")\n        max = Number(definition.options.max)\n      max = Math.min(max, Number.MAX_SAFE_INTEGER)\n      min = Math.max(min, Number.MIN_SAFE_INTEGER)\n      const v = Math.min(Math.max(value, min), max)\n      if (definition?.options?.step) {\n        const t = 1.0 / definition?.options?.step\n        return Math.round(v * t) / t\n      }\n      return v\n    },\n    random: definition => {\n      let min = Number.MIN_SAFE_INTEGER\n      if (typeof definition.options?.min !== \"undefined\")\n        min = Number(definition.options.min)\n      let max = Number.MAX_SAFE_INTEGER\n      if (typeof definition.options?.max !== \"undefined\")\n        max = Number(definition.options.max)\n      max = Math.min(max, Number.MAX_SAFE_INTEGER)\n      min = Math.max(min, Number.MIN_SAFE_INTEGER)\n      const v = Math.random() * (max - min) + min\n      if (definition?.options?.step) {\n        const t = 1.0 / definition?.options?.step\n        return Math.round(v * t) / t\n      }\n      return v\n    },\n  },\n  bigint: {\n    serialize: (input: any) => {\n      const view = new DataView(new ArrayBuffer(8))\n      view.setBigInt64(0, BigInt(input))\n      return view.getBigUint64(0).toString(16).padStart(16, \"0\")\n    },\n    deserialize: (input: any) => {\n      const view = new DataView(new ArrayBuffer(8))\n      for (let i = 0; i < 8; i++) {\n        view.setUint8(i, parseInt(input.substring(i * 2, i * 2 + 2), 16))\n      }\n      return view.getBigInt64(0)\n    },\n    bytesLength: () => 8,\n    random: (definition) => {\n      let min = MIN_SAFE_INT64\n      let max = MAX_SAFE_INT64\n      if (typeof definition.options?.min !== \"undefined\")\n        min = BigInt(definition.options.min)\n      if (typeof definition.options?.max !== \"undefined\")\n        max = BigInt(definition.options.max)\n      const range = max - min\n      const bits = range.toString(2).length\n      let random\n      do {\n        random = BigInt(\n          \"0b\" +\n            Array.from(\n              crypto.getRandomValues(new Uint8Array(Math.ceil(bits / 8)))\n            )\n              .map((b) => b.toString(2).padStart(8, \"0\"))\n              .join(\"\")\n        )\n      } while (random > range)\n      return random + min\n    },\n  },\n  boolean: {\n    serialize: (input) => {\n      return typeof input === \"boolean\"\n        ? input\n          ? \"01\"\n          : \"00\"\n        : typeof input === \"string\"\n        ? input === \"true\"\n          ? \"01\"\n          : \"00\"\n        : \"00\"\n    },\n    deserialize: (input) => {\n      return input === \"00\" ? false : true\n    },\n    bytesLength: () => 1,\n    random: () => Math.random() < 0.5,\n  },\n\n  color: {\n    serialize: (input: string) => {\n      return completeHexColor(input)\n    },\n\n    deserialize: (input): hexString => {\n      return input as hexString\n    },\n    bytesLength: () => 4,\n    transform: (input: string) => {\n      const color = completeHexColor(input)\n      const r = parseInt(color.slice(0, 2), 16)\n      const g = parseInt(color.slice(2, 4), 16)\n      const b = parseInt(color.slice(4, 6), 16)\n      const a = parseInt(color.slice(6, 8), 16)\n      return {\n        hex: {\n          rgb: \"#\" + input.slice(0, 6),\n          rgba: \"#\" + input,\n        },\n        obj: {\n          rgb: { r, g, b },\n          rgba: { r, g, b, a },\n        },\n        arr: {\n          rgb: [r, g, b],\n          rgba: [r, g, b, a],\n        },\n      }\n    },\n    constrain: (value) => {\n      const hex = value.replace(\"#\", \"\")\n      return hex.slice(0, 8).padEnd(8, \"f\")\n    },\n    random: () =>\n      `${[...Array(8)]\n        .map(() => Math.floor(Math.random() * 16).toString(16))\n        .join(\"\")}`,\n  },\n\n  string: {\n    serialize: (input, def) => {\n      if (!def.version) {\n        let hex = stringToHex(input.substring(0, 64))\n        hex = hex.padEnd(64 * 4, \"0\")\n        return hex\n      }\n      let max = 64\n      if (typeof def.options?.maxLength !== \"undefined\")\n        max = Number(def.options.maxLength)\n      let hex = stringToHex(input.substring(0, max))\n      hex = hex.padEnd(max * 4, \"0\")\n      return hex\n    },\n    deserialize: (input) => {\n      return hexToString(input)\n    },\n\n    bytesLength: (def) => {\n      if (!def.version) {\n        return 64 * 2\n      }\n      if (typeof def.options?.maxLength !== \"undefined\")\n        return Number(def.options.maxLength) * 2\n      return 64 * 2\n    },\n    random: (definition) => {\n      let min = 0\n      if (typeof definition.options?.minLength !== \"undefined\")\n        min = definition.options.minLength\n      let max = 64\n      if (typeof definition.options?.maxLength !== \"undefined\")\n        max = definition.options.maxLength\n      const length = Math.round(Math.random() * (max - min) + min)\n      return [...Array(length)]\n        .map((i) => (~~(Math.random() * 36)).toString(36))\n        .join(\"\")\n    },\n    constrain: (value, definition) => {\n      let min = 0\n      if (typeof definition.options?.minLength !== \"undefined\")\n        min = definition.options.minLength\n      let max = 64\n      if (typeof definition.options?.maxLength !== \"undefined\")\n        max = definition.options.maxLength\n      const v = value.slice(0, max)\n      if (v.length < min) {\n        return v.padEnd(min)\n      }\n      return v\n    },\n  },\n\n  bytes: {\n    serialize: (input, def) => {\n      return Array.from(input)\n        .map((i) => i.toString(16).padStart(2, \"0\"))\n        .join(\"\")\n    },\n    deserialize: (input, def) => {\n      const len = input.length / 2\n      const uint8 = new Uint8Array(len)\n      let idx\n      for (let i = 0; i < len; i++) {\n        idx = i * 2\n        uint8[i] = parseInt(`${input[idx]}${input[idx + 1]}`, 16)\n      }\n      return uint8\n    },\n    bytesLength: (def) => def.options.length,\n    random: (def) => {\n      const len = def.options?.length || 0\n      const uint8 = new Uint8Array(len)\n      for (let i = 0; i < len; i++) {\n        uint8[i] = (Math.random() * 255) | 0\n      }\n      return uint8\n    },\n  },\n\n  select: {\n    serialize: (input, def) => {\n      // find the index of the input in the array of options\n      return Math.min(255, def.options?.options?.indexOf(input) || 0)\n        .toString(16)\n        .padStart(2, \"0\")\n    },\n\n    deserialize: (input, def) => {\n      // get the index, which is the input\n      const idx = parseInt(input, 16)\n      return def.options?.options?.[idx] || def.options?.options?.[0] || \"\"\n    },\n\n    bytesLength: () => 1, // index between 0 and 255\n    constrain: (value, definition) => {\n      if (definition.options.options.includes(value)) {\n        return value\n      }\n      return definition.options.options[0]\n    },\n    random: (definition) => {\n      const index = Math.round(\n        Math.random() * (definition.options.options.length - 1) + 0\n      )\n      return definition?.options?.options[index]\n    },\n  },\n}\n\n// params are injected into the piece using the binary representation of the\n// numbers, to keep precision\nexport function serializeParams(\n  params: any,\n  definition: FxParamDefinition<any>[]\n) {\n  // a single hex string will be used for all the params\n  let bytes = \"\"\n  if (!definition) return bytes\n  // loop through each parameter from the definition to find the associated\n  // parameter as set on the UI\n  for (const def of definition) {\n    const { id, type } = def\n    const processor = ParameterProcessors[\n      type as FxParamType\n    ] as FxParamProcessor<any>\n    // if the param is definined in the object\n\n    const v = params[id] as FxParamTypeMap[]\n    const val =\n      typeof v !== \"undefined\"\n        ? v\n        : typeof def.default !== \"undefined\"\n        ? def.default\n        : processor.random(def)\n    const serialized = processor.serialize(val, def)\n    bytes += serialized\n  }\n\n  return bytes\n}\n\n// takes an array of bytes, in hexadecimal format, and a parametric space\n// definition and outputs an array of parameters, mapping the definition and\n// validating input based on the definition constraints\nexport function deserializeParams(\n  bytes: string,\n  definition: FxParamDefinition<FxParamType>[],\n  options: { withTransform?: boolean, transformType?: FxParamTranformType }\n) {\n  const params: Record<string, FxParamValue<FxParamType> | FxParamTransformationTypeMap[FxParamType]> = {}\n  console.log(bytes, definition, options)\n  for (const def of definition) {\n    const processor = ParameterProcessors[\n      def.type as FxParamType\n    ] as FxParamProcessor<FxParamType>\n    const transformer = options.withTransform && processor[options.transformType || \"transform\"] as FxParamProcessorTransformer<FxParamType>\n    if (!bytes) {\n      let v\n      if (typeof def.default === \"undefined\") v = processor.random(def)\n      else v = def.default\n      params[def.id] = transformer ? transformer(v, def) : v\n      continue\n    }\n    // extract the length from the bytes & shift the initial bytes string\n    const bytesLen = processor.bytesLength(def)\n    const valueBytes = bytes.substring(0, bytesLen * 2)\n    bytes = bytes.substring(bytesLen * 2)\n    // deserialize the bytes into the params\n    const val = processor.deserialize(valueBytes, def) as FxParamValue<FxParamType>\n    params[def.id] = transformer ? transformer(val, def) : val\n  }\n  return params\n}\n\n\n// Consolidates parameters from both a params object provided by the token\n// and the dat object of params, which is stored by the controls component.\nexport function consolidateParams(params: any, data: any) {\n  if (!params) return []\n\n  const rtn = [...params]\n\n  for (const p in rtn) {\n    const definition = rtn[p]\n    const { id, type, default: def } = definition\n    if (data && data.hasOwnProperty(id)) {\n      rtn[p].value = data[id]\n    } else {\n      const processor = ParameterProcessors[\n        type as FxParamType\n      ] as FxParamProcessor<any>\n      let v\n      if (typeof def === \"undefined\") v = processor.random(definition)\n      else v = def\n      rtn[p].value = processor.transform?.(v) || v\n    }\n  }\n\n  return rtn\n}\n\nexport function getRandomParamValues(\n  params: FxParamDefinition<FxParamType>[],\n  options?: { noTransform: boolean }\n): any {\n  return params.reduce((acc, definition) => {\n    const processor = ParameterProcessors[\n      definition.type as FxParamType\n    ] as FxParamProcessor<FxParamType>\n    const v = processor.random(definition) as FxParamType\n    acc[definition.id] = options?.noTransform\n      ? v\n      : processor.transform?.(v) || v\n    return acc\n  }, {} as Record<string, any>)\n}\n\nexport function sumBytesParams(\n  definitions: FxParamDefinition<FxParamType>[]\n): number {\n  return (\n    definitions?.reduce(\n      (acc, def) =>\n        acc +\n        (\n          ParameterProcessors[\n            def.type as FxParamType\n          ] as FxParamProcessor<FxParamType>\n        ).bytesLength(def),\n      0\n    ) || 0\n  )\n}\n\nexport function stringifyParamsData(data: FxParamsData) {\n  return JSON.stringify(data, (key, value) => {\n    if (typeof value === \"bigint\") return value.toString()\n    return value\n  })\n}\n\nexport function jsonStringifyBigint(data: any): string {\n  return JSON.stringify(data, (key, value) => {\n    if (typeof value === \"bigint\") return value.toString()\n    return value\n  })\n}\n\n\nexport const processParam = (paramId: string, value: FxParamValue<FxParamType>, definitions: FxParamDefinition<FxParamType>[], transformType: FxParamTranformType): FxParamValue<FxParamType> | FxParamTransformationTypeMap[FxParamType] => {\n    const definition = definitions.find(d => d.id === paramId)\n    const processor = ParameterProcessors[definition.type]\n    const transformer = (processor[transformType] as FxParamProcessorTransformer<FxParamType>)\n    return transformer?.(value, definition) || value\n  }\n\nexport const processParams = (values: FxParamsData, definitions: FxParamDefinition<FxParamType>[], transformType: FxParamTranformType) => {\n    const paramValues = {}\n    for (const definition of definitions) {\n      const processor = ParameterProcessors[definition.type]\n      const value = values[definition.id]\n      // deserialize the bytes into the params\n      const transformer = (processor[transformType] as FxParamProcessorTransformer<FxParamType>)\n      paramValues[definition.id] = transformer?.(value, definition) || value\n\n    }\n    return paramValues\n  }\n\n"]}

package/dist/chunk-4FX3ATAX.js

@@ -0,0 +1,110 @@
+import {
+  NumberController
+} from "./chunk-H5IMTNFG.js";
+import {
+  SelectController
+} from "./chunk-6VMIOQSE.js";
+import {
+  StringController
+} from "./chunk-YYEIYDDF.js";
+import {
+  validateParameterDefinition
+} from "./chunk-MWP7SJWC.js";
+import {
+  BigIntController
+} from "./chunk-ZUITF5XX.js";
+import {
+  BooleanController
+} from "./chunk-YOS2HCIS.js";
+import {
+  BytesController
+} from "./chunk-2QIAF3U7.js";
+import {
+  ColorController
+} from "./chunk-7NOMBXLG.js";
+import {
+  ControllerInvalid
+} from "./chunk-PTXBICTZ.js";
+
+// src/Controller/Param.tsx
+import { useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+var controllerDefinitions = {
+  number: {
+    type: "number",
+    controller: NumberController,
+    handler: (e) => Number(e.target.value)
+  },
+  bigint: {
+    type: "bigint",
+    controller: BigIntController,
+    handler: (e) => BigInt(e.target.value)
+  },
+  string: {
+    type: "string",
+    controller: StringController,
+    handler: (e) => e.target.value
+  },
+  bytes: {
+    type: "bytes",
+    controller: BytesController,
+    handler: (e) => e.target.value
+  },
+  boolean: {
+    type: "boolean",
+    controller: BooleanController,
+    handler: (e) => e.target.checked
+  },
+  color: {
+    type: "color",
+    controller: ColorController,
+    handler: (v) => v
+  },
+  select: {
+    type: "select",
+    controller: SelectController,
+    handler: (e) => e.target.value
+  }
+};
+function ParameterController(props) {
+  const { parameter, onChange, parsed } = props;
+  const parsedDefinition = useMemo(
+    () => parsed || validateParameterDefinition(parameter),
+    [parameter, parsed]
+  );
+  const { controller: Controller, handler } = useMemo(
+    () => controllerDefinitions[parameter.type],
+    [parameter.type]
+  );
+  const handleChangeParam = (e) => {
+    const value = handler(e);
+    onChange(parameter.id, value);
+  };
+  if (parsedDefinition && parsedDefinition.success === false) {
+    return /* @__PURE__ */ jsx(
+      ControllerInvalid,
+      {
+        definition: parameter,
+        error: parsedDefinition.error
+      }
+    );
+  }
+  const isCodeDriven = parameter.update === "code-driven";
+  return /* @__PURE__ */ jsx(
+    Controller,
+    {
+      id: parameter.id,
+      label: parameter.name,
+      value: props.value,
+      onChange: handleChangeParam,
+      options: parameter.options,
+      isCodeDriven
+    }
+  );
+}
+
+export {
+  controllerDefinitions,
+  ParameterController
+};
+//# sourceMappingURL=chunk-4FX3ATAX.js.map

package/dist/chunk-4FX3ATAX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/Controller/Param.tsx"],"sourcesContent":["import { useMemo, ReactElement } from \"react\"\nimport { FxParamDefinition, FxParamType } from \"../types\"\nimport { FxParamInputChangeHandler, FxParamControllerProps } from \"./Controller\"\nimport { BooleanController } from \"./Boolean\"\nimport { ColorController } from \"./Color\"\nimport { NumberController } from \"./Number\"\nimport { BigIntController } from \"./BigInt\"\nimport { SelectController } from \"./Select\"\nimport { StringController } from \"./String\"\nimport {\n  validateParameterDefinition,\n  ControllerDefinitionSchemaType,\n} from \"../validation\"\nimport { SafeParseError, SafeParseSuccess, z } from \"zod\"\nimport { ControllerInvalid } from \"./Invalid\"\nimport { BytesController } from \"./Bytes\"\n\ninterface FxParamControllerDefiniton<Type extends FxParamType> {\n  type: Type\n  controller: (props: FxParamControllerProps<Type>) => ReactElement\n  handler: FxParamInputChangeHandler\n}\n\nexport type FxParamControllerDefinitions = {\n  [T in FxParamType]: FxParamControllerDefiniton<T>\n}\n\nexport const controllerDefinitions: FxParamControllerDefinitions = {\n  number: {\n    type: \"number\",\n    controller: NumberController,\n    handler: (e) => Number(e.target.value),\n  },\n  bigint: {\n    type: \"bigint\",\n    controller: BigIntController,\n    handler: (e) => BigInt(e.target.value),\n  },\n  string: {\n    type: \"string\",\n    controller: StringController,\n    handler: (e) => e.target.value,\n  },\n  bytes: {\n    type: \"bytes\",\n    controller: BytesController,\n    handler: (e) => e.target.value,\n  },\n  boolean: {\n    type: \"boolean\",\n    controller: BooleanController,\n    handler: (e) => (e as React.ChangeEvent<HTMLInputElement>).target.checked,\n  },\n  color: {\n    type: \"color\",\n    controller: ColorController,\n    handler: (v) => v,\n  },\n  select: {\n    type: \"select\",\n    controller: SelectController,\n    handler: (e) => e.target.value,\n  },\n}\n\nexport interface ParameterControllerProps {\n  parameter: FxParamDefinition<FxParamType>\n  value: any\n  onChange: (id: string, value: any) => void\n  parsed?:\n    | SafeParseError<ControllerDefinitionSchemaType>\n    | SafeParseSuccess<ControllerDefinitionSchemaType>\n}\n\nexport function ParameterController(props: ParameterControllerProps) {\n  const { parameter, onChange, parsed } = props\n\n  const parsedDefinition = useMemo(\n    () => parsed || validateParameterDefinition(parameter),\n    [parameter, parsed]\n  )\n  const { controller: Controller, handler } = useMemo(\n    () => controllerDefinitions[parameter.type],\n    [parameter.type]\n  )\n\n  const handleChangeParam = (e: any) => {\n    const value = handler(e)\n    onChange(parameter.id, value)\n  }\n\n  if (parsedDefinition && parsedDefinition.success === false) {\n    return (\n      <ControllerInvalid\n        definition={parameter}\n        error={parsedDefinition.error}\n      />\n    )\n  }\n\n  const isCodeDriven = parameter.update === \"code-driven\"\n\n  return (\n    <Controller\n      id={parameter.id}\n      label={parameter.name}\n      value={props.value}\n      onChange={handleChangeParam}\n      // TODO: This should be properly casted\n      options={parameter.options as any}\n      isCodeDriven={isCodeDriven}\n    />\n  )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,SAAS,eAA6B;AA6FhC;AAlEC,IAAM,wBAAsD;AAAA,EACjE,QAAQ;AAAA,IACN,MAAM;AAAA,IACN,YAAY;AAAA,IACZ,SAAS,CAAC,MAAM,OAAO,EAAE,OAAO,KAAK;AAAA,EACvC;AAAA,EACA,QAAQ;AAAA,IACN,MAAM;AAAA,IACN,YAAY;AAAA,IACZ,SAAS,CAAC,MAAM,OAAO,EAAE,OAAO,KAAK;AAAA,EACvC;AAAA,EACA,QAAQ;AAAA,IACN,MAAM;AAAA,IACN,YAAY;AAAA,IACZ,SAAS,CAAC,MAAM,EAAE,OAAO;AAAA,EAC3B;AAAA,EACA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,YAAY;AAAA,IACZ,SAAS,CAAC,MAAM,EAAE,OAAO;AAAA,EAC3B;AAAA,EACA,SAAS;AAAA,IACP,MAAM;AAAA,IACN,YAAY;AAAA,IACZ,SAAS,CAAC,MAAO,EAA0C,OAAO;AAAA,EACpE;AAAA,EACA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,YAAY;AAAA,IACZ,SAAS,CAAC,MAAM;AAAA,EAClB;AAAA,EACA,QAAQ;AAAA,IACN,MAAM;AAAA,IACN,YAAY;AAAA,IACZ,SAAS,CAAC,MAAM,EAAE,OAAO;AAAA,EAC3B;AACF;AAWO,SAAS,oBAAoB,OAAiC;AACnE,QAAM,EAAE,WAAW,UAAU,OAAO,IAAI;AAExC,QAAM,mBAAmB;AAAA,IACvB,MAAM,UAAU,4BAA4B,SAAS;AAAA,IACrD,CAAC,WAAW,MAAM;AAAA,EACpB;AACA,QAAM,EAAE,YAAY,YAAY,QAAQ,IAAI;AAAA,IAC1C,MAAM,sBAAsB,UAAU,IAAI;AAAA,IAC1C,CAAC,UAAU,IAAI;AAAA,EACjB;AAEA,QAAM,oBAAoB,CAAC,MAAW;AACpC,UAAM,QAAQ,QAAQ,CAAC;AACvB,aAAS,UAAU,IAAI,KAAK;AAAA,EAC9B;AAEA,MAAI,oBAAoB,iBAAiB,YAAY,OAAO;AAC1D,WACE;AAAA,MAAC;AAAA;AAAA,QACC,YAAY;AAAA,QACZ,OAAO,iBAAiB;AAAA;AAAA,IAC1B;AAAA,EAEJ;AAEA,QAAM,eAAe,UAAU,WAAW;AAE1C,SACE;AAAA,IAAC;AAAA;AAAA,MACC,IAAI,UAAU;AAAA,MACd,OAAO,UAAU;AAAA,MACjB,OAAO,MAAM;AAAA,MACb,UAAU;AAAA,MAEV,SAAS,UAAU;AAAA,MACnB;AAAA;AAAA,EACF;AAEJ;","names":[]}

package/dist/chunk-4OV7OX5A.js

@@ -0,0 +1,37 @@
+import {
+  IconButton
+} from "./chunk-2BHABOFI.js";
+
+// src/LockButton/LockButton.tsx
+import { FontAwesomeIcon } from "@fortawesome/react-fontawesome";
+
+// src/LockButton/LockButton.module.scss
+var LockButton_module_default = {
+  "lockButton": "_lockButton_1bbiz_1"
+};
+
+// src/LockButton/LockButton.tsx
+import { faLock, faLockOpen } from "@fortawesome/free-solid-svg-icons";
+import cx from "classnames";
+import { jsx } from "react/jsx-runtime";
+function LockButton(props) {
+  const { isLocked, className, ...rest } = props;
+  return /* @__PURE__ */ jsx(
+    IconButton,
+    {
+      color: "secondary",
+      className: cx(
+        LockButton_module_default.lockButton,
+        { [LockButton_module_default.isOpen]: !isLocked },
+        className
+      ),
+      ...rest,
+      children: /* @__PURE__ */ jsx(FontAwesomeIcon, { icon: isLocked ? faLock : faLockOpen })
+    }
+  );
+}
+
+export {
+  LockButton
+};
+//# sourceMappingURL=chunk-4OV7OX5A.js.map

package/dist/chunk-4OV7OX5A.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/LockButton/LockButton.tsx","../src/LockButton/LockButton.module.scss"],"sourcesContent":["import { FontAwesomeIcon } from \"@fortawesome/react-fontawesome\"\nimport { BaseButtonProps, IconButton } from \"../BaseInput\"\nimport classes from \"./LockButton.module.scss\"\nimport { faLock, faLockOpen } from \"@fortawesome/free-solid-svg-icons\"\nimport cx from \"classnames\"\ninterface LockButtonProps extends BaseButtonProps {\n  isLocked?: boolean\n  className?: string\n}\n\nexport function LockButton(props: LockButtonProps) {\n  const { isLocked, className, ...rest } = props\n  return (\n    <IconButton\n      color=\"secondary\"\n      className={cx(\n        classes.lockButton,\n        { [classes.isOpen]: !isLocked },\n        className\n      )}\n      {...rest}\n    >\n      <FontAwesomeIcon icon={isLocked ? faLock : faLockOpen} />\n    </IconButton>\n  )\n}\n","import 'css-chunk:src/LockButton/LockButton.module.scss';export default {\n  \"lockButton\": \"_lockButton_1bbiz_1\"\n};"],"mappings":";;;;;AAAA,SAAS,uBAAuB;;;ACAyB,IAAO,4BAAQ;AAAA,EACtE,cAAc;AAChB;;;ADCA,SAAS,QAAQ,kBAAkB;AACnC,OAAO,QAAQ;AAkBT;AAZC,SAAS,WAAW,OAAwB;AACjD,QAAM,EAAE,UAAU,WAAW,GAAG,KAAK,IAAI;AACzC,SACE;AAAA,IAAC;AAAA;AAAA,MACC,OAAM;AAAA,MACN,WAAW;AAAA,QACT,0BAAQ;AAAA,QACR,EAAE,CAAC,0BAAQ,MAAM,GAAG,CAAC,SAAS;AAAA,QAC9B;AAAA,MACF;AAAA,MACC,GAAG;AAAA,MAEJ,8BAAC,mBAAgB,MAAM,WAAW,SAAS,YAAY;AAAA;AAAA,EACzD;AAEJ;","names":[]}

package/dist/chunk-6VMIOQSE.js

@@ -0,0 +1,34 @@
+import {
+  Controller
+} from "./chunk-CE3TPOSO.js";
+import {
+  BaseSelect
+} from "./chunk-2BHABOFI.js";
+
+// src/Controller/Select.tsx
+import { jsx } from "react/jsx-runtime";
+function SelectController({
+  id,
+  label,
+  value,
+  onChange,
+  options,
+  isCodeDriven
+}) {
+  return /* @__PURE__ */ jsx(Controller, { id, label, isCodeDriven, children: /* @__PURE__ */ jsx(
+    BaseSelect,
+    {
+      name: id,
+      id,
+      onChange,
+      value,
+      disabled: isCodeDriven,
+      children: options?.options.map((o) => /* @__PURE__ */ jsx("option", { value: o, children: o }, o))
+    }
+  ) });
+}
+
+export {
+  SelectController
+};
+//# sourceMappingURL=chunk-6VMIOQSE.js.map

package/dist/chunk-6VMIOQSE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/Controller/Select.tsx"],"sourcesContent":["import { Controller, FxParamControllerProps } from \"./Controller\"\nimport { BaseSelect } from \"../BaseInput\"\n\nexport function SelectController({\n  id,\n  label,\n  value,\n  onChange,\n  options,\n  isCodeDriven,\n}: FxParamControllerProps<\"select\">) {\n  return (\n    <Controller id={id} label={label} isCodeDriven={isCodeDriven}>\n      <BaseSelect\n        name={id}\n        id={id}\n        onChange={onChange}\n        value={value}\n        disabled={isCodeDriven}\n      >\n        {options?.options.map((o) => (\n          <option key={o} value={o}>\n            {o}\n          </option>\n        ))}\n      </BaseSelect>\n    </Controller>\n  )\n}\n"],"mappings":";;;;;;;;AAqBU;AAlBH,SAAS,iBAAiB;AAAA,EAC/B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAAqC;AACnC,SACE,oBAAC,cAAW,IAAQ,OAAc,cAChC;AAAA,IAAC;AAAA;AAAA,MACC,MAAM;AAAA,MACN;AAAA,MACA;AAAA,MACA;AAAA,MACA,UAAU;AAAA,MAET,mBAAS,QAAQ,IAAI,CAAC,MACrB,oBAAC,YAAe,OAAO,GACpB,eADU,CAEb,CACD;AAAA;AAAA,EACH,GACF;AAEJ;","names":[]}