@design-edito/tools 0.4.3 → 0.4.5

package/agnostic/html/hyper-json/method/index.js

@@ -1,7 +1,14 @@
-import {
-  Method
-} from "../../../../chunks/chunk-RW7VAKJW.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+// src/agnostic/html/hyper-json/method/index.ts
+var Method = class _Method {
+  transformer;
+  static clone(method) {
+    const { transformer } = method;
+    return new _Method(transformer);
+  }
+  constructor(transformer) {
+    this.transformer = transformer;
+  }
+};
 export {
   Method
 };

package/agnostic/html/hyper-json/serialize/index.js

@@ -1,11 +1,225 @@
-import {
-  Serialize
-} from "../../../../chunks/chunk-O32IRXDX.js";
-import "../../../../chunks/chunk-LEBGVBYD.js";
-import "../../../../chunks/chunk-RW7VAKJW.js";
-import "../../../../chunks/chunk-57YKZBJR.js";
-import "../../../../chunks/chunk-LUAYN7VJ.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+// src/agnostic/misc/crossenv/window/index.ts
+function exists() {
+  return typeof globalThis !== "undefined" && "window" in globalThis;
+}
+var _window = exists() ? globalThis.window ?? null : null;
+function get() {
+  if (_window !== null) return _window;
+  const message = "window is undefined. Please call Window.setWindow(windowObj) before using Window.get.";
+  throw new Error(message);
+}
+
+// src/agnostic/misc/outcome/index.ts
+function makeSuccess(payload) {
+  return { success: true, payload };
+}
+function makeFailure(error) {
+  return { success: false, error };
+}
+
+// src/agnostic/html/hyper-json/method/index.ts
+var Method = class _Method {
+  transformer;
+  static clone(method) {
+    const { transformer } = method;
+    return new _Method(transformer);
+  }
+  constructor(transformer) {
+    this.transformer = transformer;
+  }
+};
+
+// src/agnostic/html/hyper-json/transformer/index.ts
+var Transformer = class _Transformer {
+  name;
+  mode;
+  innerValue;
+  typeChecks;
+  func;
+  sourceTree;
+  static clone(transformer) {
+    const { name, mode, innerValue, typeChecks, func, sourceTree } = transformer;
+    return new _Transformer(name, mode, innerValue, typeChecks, func, sourceTree);
+  }
+  constructor(name, mode, innerValue, typeChecks, func, sourceTree) {
+    this.apply = this.apply.bind(this);
+    this.getMainAndArgsValue = this.getMainAndArgsValue.bind(this);
+    this.makeMainValueError = this.makeMainValueError.bind(this);
+    this.makeArgsValueError = this.makeArgsValueError.bind(this);
+    this.makeTransformationError = this.makeTransformationError.bind(this);
+    this.toMethod = this.toMethod.bind(this);
+    this.name = name;
+    this.mode = mode;
+    this.innerValue = innerValue;
+    this.typeChecks = typeChecks;
+    this.func = func;
+    this.sourceTree = sourceTree;
+  }
+  getMainAndArgsValue(outerValue) {
+    const { mode, innerValue } = this;
+    let mainValue;
+    let argsValue;
+    if (mode === "isolation") {
+      if (Array.isArray(innerValue)) {
+        mainValue = innerValue.at(0);
+        argsValue = innerValue.slice(1);
+      } else {
+        mainValue = innerValue;
+        argsValue = [];
+      }
+    } else {
+      mainValue = outerValue;
+      argsValue = Array.isArray(innerValue) ? innerValue : [innerValue];
+    }
+    return { mainValue, argsValue };
+  }
+  makeMainValueError(mainValue, argsValue, expected, found, details) {
+    const { name, sourceTree } = this;
+    return {
+      message: "BAD_MAIN_VALUE",
+      expected,
+      found,
+      details,
+      transformerName: name,
+      path: sourceTree.pathString,
+      mainValue,
+      argsValue
+    };
+  }
+  makeArgsValueError(mainValue, argsValue, expected, found, position, details) {
+    const { name, sourceTree } = this;
+    return {
+      message: "BAD_ARGUMENTS_VALUE",
+      expected,
+      found,
+      position,
+      details,
+      transformerName: name,
+      path: sourceTree.pathString,
+      mainValue,
+      argsValue
+    };
+  }
+  makeTransformationError(mainValue, argsValue, details) {
+    const { name, sourceTree } = this;
+    return {
+      message: "TRANSFORMATION_ERROR",
+      details,
+      transformerName: name,
+      path: sourceTree.pathString,
+      mainValue,
+      argsValue
+    };
+  }
+  apply(outerValue) {
+    const getMainAndArgsValue = this.getMainAndArgsValue.bind(this);
+    const makeMainValueError = this.makeMainValueError.bind(this);
+    const makeArgsValueError = this.makeArgsValueError.bind(this);
+    const makeTransformationError = this.makeTransformationError.bind(this);
+    const func = this.func.bind(this);
+    const { typeChecks } = this;
+    const { mainValue, argsValue } = getMainAndArgsValue(outerValue);
+    const mainChecked = typeChecks.mainValue(mainValue);
+    if (!mainChecked.success) return makeFailure(makeMainValueError(
+      mainValue,
+      argsValue,
+      mainChecked.error.expected,
+      mainChecked.error.found
+    ));
+    const validMainValue = mainChecked.payload;
+    const argsChecked = typeChecks.argsValue(argsValue, validMainValue);
+    if (!argsChecked.success) return makeFailure(makeArgsValueError(
+      mainValue,
+      argsValue,
+      argsChecked.error.expected,
+      argsChecked.error.found,
+      argsChecked.error.position
+    ));
+    const validArgsValue = argsChecked.payload;
+    const called = func(
+      validMainValue,
+      validArgsValue,
+      {
+        name: this.name,
+        sourceTree: this.sourceTree
+      }
+    );
+    if (!called.success) return makeFailure(makeTransformationError(
+      mainValue,
+      argsValue,
+      called.error
+    ));
+    return makeSuccess(called.payload);
+  }
+  toMethod() {
+    return new Method(this);
+  }
+};
+
+// src/agnostic/html/hyper-json/serialize/index.ts
+var Serialize;
+((Serialize2) => {
+  function serialize(value) {
+    const { Text, Element, NodeList } = get();
+    if (value === null) return { type: "null", value: null };
+    if (typeof value === "boolean" || typeof value === "number" || typeof value === "string") return { type: typeof value, value };
+    if (value instanceof Text) return { type: "text", value: value.textContent ?? "" };
+    if (value instanceof Element) return { type: "element", value: value.outerHTML };
+    if (value instanceof NodeList) return {
+      type: "nodelist",
+      value: Array.from(value).map(serialize)
+    };
+    if (Array.isArray(value)) return { type: "array", value: value.map(serialize) };
+    if (value instanceof Transformer) return { type: "transformer", value: Transformer.clone(value) };
+    if (value instanceof Method) return { type: "method", value: Method.clone(value) };
+    return {
+      type: "record",
+      value: Object.entries(value).reduce((reduced, [key, val]) => ({
+        ...reduced,
+        [key]: serialize(val)
+      }), {})
+    };
+  }
+  Serialize2.serialize = serialize;
+  function deserialize(serialized) {
+    const { document } = get();
+    if (serialized.type === "null") return null;
+    if (serialized.type === "boolean") return serialized.value;
+    if (serialized.type === "number") return serialized.value;
+    if (serialized.type === "string") return serialized.value;
+    if (serialized.type === "text") return document.createTextNode(serialized.value);
+    if (serialized.type === "element") {
+      const elt = document.createElement("div");
+      elt.innerHTML = serialized.value;
+      const firstChild = elt.firstElementChild;
+      return firstChild ?? document.createElement("div");
+    }
+    if (serialized.type === "nodelist") {
+      const frag = document.createDocumentFragment();
+      const deserialized = serialized.value.filter((e) => e.type === "text" || e.type === "element").map(deserialize);
+      deserialized.forEach((elt) => frag.append(elt.cloneNode(true)));
+      return frag.childNodes;
+    }
+    if (serialized.type === "array") {
+      const toRet = [];
+      for (const val of serialized.value) {
+        const deserialized = deserialize(val);
+        if (deserialized instanceof Transformer) continue;
+        toRet.push(deserialized);
+      }
+      return toRet;
+    }
+    if (serialized.type === "transformer") return Transformer.clone(serialized.value);
+    if (serialized.type === "method") return Method.clone(serialized.value);
+    return Object.entries(serialized.value).reduce((reduced, [key, serialized2]) => {
+      return {
+        ...reduced,
+        [key]: deserialize(serialized2)
+      };
+    }, {});
+  }
+  Serialize2.deserialize = deserialize;
+})(Serialize || (Serialize = {}));
 export {
   Serialize
 };