@design-edito/tools 0.4.3 → 0.4.5

package/agnostic/html/hyper-json/smart-tags/index.js

@@ -1,10 +1,184 @@
-import {
-  SmartTags
-} from "../../../../chunks/chunk-MSU7JU63.js";
-import "../../../../chunks/chunk-LEBGVBYD.js";
-import "../../../../chunks/chunk-RW7VAKJW.js";
-import "../../../../chunks/chunk-LUAYN7VJ.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+// 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/smart-tags/index.ts
+var SmartTags;
+((SmartTags2) => {
+  function makeSmartTag(descriptor) {
+    return [descriptor.name, {
+      defaultMode: descriptor.defaultMode,
+      isolationInitType: descriptor.isolationInitType,
+      generator: (innerValue, mode, sourceTree) => {
+        const transformer = new Transformer(
+          descriptor.name,
+          mode,
+          innerValue,
+          {
+            mainValue: descriptor.mainValueCheck,
+            argsValue: descriptor.argsValueCheck
+          },
+          descriptor.func,
+          sourceTree
+        );
+        const method = new Method(transformer);
+        return { transformer, method };
+      }
+    }];
+  }
+  SmartTags2.makeSmartTag = makeSmartTag;
+  const isNotUndefined = (value) => value !== void 0;
+  SmartTags2.expectNotUndef = (value) => {
+    if (isNotUndefined(value)) return makeSuccess(value);
+    return makeFailure({
+      expected: "value",
+      found: "undefined"
+    });
+  };
+})(SmartTags || (SmartTags = {}));
 export {
   SmartTags
 };

package/agnostic/html/hyper-json/smart-tags/isolated/any/index.js

@@ -1,11 +1,197 @@
-import {
-  any
-} from "../../../../../../chunks/chunk-RJRNYRPM.js";
-import "../../../../../../chunks/chunk-MSU7JU63.js";
-import "../../../../../../chunks/chunk-LEBGVBYD.js";
-import "../../../../../../chunks/chunk-RW7VAKJW.js";
-import "../../../../../../chunks/chunk-LUAYN7VJ.js";
-import "../../../../../../chunks/chunk-WSFCRVEQ.js";
+// 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/smart-tags/index.ts
+var SmartTags;
+((SmartTags2) => {
+  function makeSmartTag(descriptor) {
+    return [descriptor.name, {
+      defaultMode: descriptor.defaultMode,
+      isolationInitType: descriptor.isolationInitType,
+      generator: (innerValue, mode, sourceTree) => {
+        const transformer = new Transformer(
+          descriptor.name,
+          mode,
+          innerValue,
+          {
+            mainValue: descriptor.mainValueCheck,
+            argsValue: descriptor.argsValueCheck
+          },
+          descriptor.func,
+          sourceTree
+        );
+        const method = new Method(transformer);
+        return { transformer, method };
+      }
+    }];
+  }
+  SmartTags2.makeSmartTag = makeSmartTag;
+  const isNotUndefined = (value) => value !== void 0;
+  SmartTags2.expectNotUndef = (value) => {
+    if (isNotUndefined(value)) return makeSuccess(value);
+    return makeFailure({
+      expected: "value",
+      found: "undefined"
+    });
+  };
+})(SmartTags || (SmartTags = {}));
+
+// src/agnostic/html/hyper-json/smart-tags/isolated/any/index.ts
+var any = SmartTags.makeSmartTag({
+  name: "any",
+  defaultMode: "isolation",
+  isolationInitType: "array",
+  mainValueCheck: (m) => makeSuccess(m),
+  argsValueCheck: (a) => makeSuccess(a),
+  func: (main, args) => {
+    if (main === void 0) return makeSuccess([...args]);
+    return makeSuccess([main, ...args]);
+  }
+});
 export {
   any
 };

package/agnostic/html/hyper-json/smart-tags/isolated/array/index.js

@@ -1,11 +1,197 @@
-import {
-  array
-} from "../../../../../../chunks/chunk-HYGUIF2O.js";
-import "../../../../../../chunks/chunk-MSU7JU63.js";
-import "../../../../../../chunks/chunk-LEBGVBYD.js";
-import "../../../../../../chunks/chunk-RW7VAKJW.js";
-import "../../../../../../chunks/chunk-LUAYN7VJ.js";
-import "../../../../../../chunks/chunk-WSFCRVEQ.js";
+// 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/smart-tags/index.ts
+var SmartTags;
+((SmartTags2) => {
+  function makeSmartTag(descriptor) {
+    return [descriptor.name, {
+      defaultMode: descriptor.defaultMode,
+      isolationInitType: descriptor.isolationInitType,
+      generator: (innerValue, mode, sourceTree) => {
+        const transformer = new Transformer(
+          descriptor.name,
+          mode,
+          innerValue,
+          {
+            mainValue: descriptor.mainValueCheck,
+            argsValue: descriptor.argsValueCheck
+          },
+          descriptor.func,
+          sourceTree
+        );
+        const method = new Method(transformer);
+        return { transformer, method };
+      }
+    }];
+  }
+  SmartTags2.makeSmartTag = makeSmartTag;
+  const isNotUndefined = (value) => value !== void 0;
+  SmartTags2.expectNotUndef = (value) => {
+    if (isNotUndefined(value)) return makeSuccess(value);
+    return makeFailure({
+      expected: "value",
+      found: "undefined"
+    });
+  };
+})(SmartTags || (SmartTags = {}));
+
+// src/agnostic/html/hyper-json/smart-tags/isolated/array/index.ts
+var array = SmartTags.makeSmartTag({
+  name: "array",
+  defaultMode: "isolation",
+  isolationInitType: "array",
+  mainValueCheck: (m) => makeSuccess(m),
+  argsValueCheck: (a) => makeSuccess(a),
+  func: (main, args) => {
+    if (main === void 0) return makeSuccess([...args]);
+    return makeSuccess([main, ...args]);
+  }
+});
 export {
   array
 };