@design-edito/tools 0.4.5 → 0.4.6

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

@@ -1,194 +1,10 @@
-// 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/null/index.ts
-var nullFunc = SmartTags.makeSmartTag({
-  name: "null",
-  defaultMode: "isolation",
-  isolationInitType: "null",
-  mainValueCheck: (i) => makeSuccess(i),
-  argsValueCheck: (a) => makeSuccess(a),
-  func: () => makeSuccess(null)
+import * as Outcome from '../../../../../misc/outcome/index.js';
+import { SmartTags } from '../../index.js';
+export const nullFunc = SmartTags.makeSmartTag({
+    name: 'null',
+    defaultMode: 'isolation',
+    isolationInitType: 'null',
+    mainValueCheck: i => Outcome.makeSuccess(i),
+    argsValueCheck: a => Outcome.makeSuccess(a),
+    func: () => Outcome.makeSuccess(null)
 });
-export {
-  nullFunc
-};