@strictly/define 0.0.1

package/dist/index.js

@@ -0,0 +1,775 @@
+// transformers/copies/copy_to.ts
+import {
+  map,
+  reduce,
+  UnexpectedImplementationError,
+  UnreachableError
+} from "@strictly/base";
+
+// types/definitions.ts
+var TypeDefType = /* @__PURE__ */ ((TypeDefType2) => {
+  TypeDefType2[TypeDefType2["Literal"] = 1] = "Literal";
+  TypeDefType2[TypeDefType2["List"] = 2] = "List";
+  TypeDefType2[TypeDefType2["Record"] = 3] = "Record";
+  TypeDefType2[TypeDefType2["Object"] = 4] = "Object";
+  TypeDefType2[TypeDefType2["Union"] = 5] = "Union";
+  return TypeDefType2;
+})(TypeDefType || {});
+
+// transformers/copies/copy_to.ts
+function copyTo({ definition }, value, copier) {
+  return internalCopyTo(
+    definition,
+    value,
+    copier
+  );
+}
+function internalCopyTo(definition, value, copier) {
+  switch (definition.type) {
+    case 1 /* Literal */:
+      return copyLiteral(
+        definition,
+        value,
+        copier
+      );
+    case 2 /* List */:
+      return copyList(
+        definition,
+        value,
+        copier
+      );
+    case 3 /* Record */:
+      return copyRecord(
+        definition,
+        value,
+        copier
+      );
+    case 4 /* Object */:
+      return copyObject(
+        definition,
+        value,
+        copier
+      );
+    case 5 /* Union */:
+      return copyUnion(
+        definition,
+        value,
+        copier
+      );
+    default:
+      throw new UnreachableError(definition);
+  }
+}
+function copyLiteral(typeDef, value, copier) {
+  return copier(value, typeDef);
+}
+function copyList(typeDef, arr, copier) {
+  const {
+    elements
+  } = typeDef;
+  const list2 = arr.map(function(value) {
+    return internalCopyTo(elements, value, copier);
+  });
+  return copier(
+    list2,
+    typeDef
+  );
+}
+function copyRecord(typeDef, value, copier) {
+  const {
+    valueTypeDef
+  } = typeDef;
+  const record2 = map(
+    value,
+    function(_key, value2) {
+      return internalCopyTo(valueTypeDef, value2, copier);
+    }
+  );
+  return copier(
+    record2,
+    typeDef
+  );
+}
+function copyObjectFields(fields, value, copier, extra) {
+  const record2 = reduce(fields, function(acc, key, field) {
+    const fieldValue = value[key];
+    acc[key] = fieldValue != null ? internalCopyTo(field, fieldValue, copier) : fieldValue;
+    return acc;
+  }, extra);
+  return record2;
+}
+function copyObject(typeDef, value, copier) {
+  const {
+    fields
+  } = typeDef;
+  const record2 = copyObjectFields(fields, value, copier, {});
+  return copier(record2, typeDef);
+}
+function copyUnion(typeDef, value, copier) {
+  const {
+    discriminator,
+    unions
+  } = typeDef;
+  if (discriminator != null) {
+    const discriminatorValue = value[discriminator];
+    const discriminatingUnion = {
+      ...internalCopyTo(
+        unions[discriminatorValue],
+        value,
+        copier
+      ),
+      [discriminator]: discriminatorValue
+    };
+    return copier(discriminatingUnion, typeDef);
+  }
+  const allTypeDefs = Object.values(unions);
+  const variableTypeDefs = allTypeDefs.filter(function(typeDef2) {
+    return typeDef2.type !== 1 /* Literal */ || typeDef2.valuePrototype == null;
+  });
+  if (variableTypeDefs.length <= 1) {
+    const targetTypeDef = allTypeDefs.find(function(typeDef2) {
+      return typeDef2.type === 1 /* Literal */ && typeDef2.valuePrototype != null && typeDef2.valuePrototype.indexOf(value) >= 0;
+    }) || variableTypeDefs[0];
+    return internalCopyTo(targetTypeDef, value, copier);
+  }
+  throw new UnexpectedImplementationError(
+    "unions must be strict in order to be copied"
+  );
+}
+
+// transformers/copies/copy.ts
+function identity(v) {
+  return v;
+}
+function copy(t, proto) {
+  return copyTo(t, proto, identity);
+}
+
+// transformers/copies/mobx_copy.ts
+import {
+  reduce as reduce3,
+  UnreachableError as UnreachableError3
+} from "@strictly/base";
+import {
+  makeObservable,
+  observable
+} from "mobx";
+
+// transformers/flatteners/flatten_value_type_to.ts
+import {
+  reduce as reduce2,
+  UnreachableError as UnreachableError2
+} from "@strictly/base";
+
+// transformers/flatteners/json_path.ts
+function jsonPath(prefix, segment, qualifier = "") {
+  const s = `.${qualifier}${segment}`;
+  return `${prefix}${s}`;
+}
+function jsonPathPop(path) {
+  const parts = path.split(".");
+  if (parts.length <= 1) {
+    return null;
+  }
+  return [
+    parts.slice(0, -1).join("."),
+    parts.pop()
+  ];
+}
+
+// transformers/flatteners/flatten_value_type_to.ts
+function flattenValueTypeTo({ definition }, v, setter, mapper) {
+  const r = {};
+  internalFlattenValue(
+    "$",
+    "$",
+    definition,
+    v,
+    setter,
+    mapper,
+    r
+  );
+  return r;
+}
+function internalFlattenValue(valuePath, typePath, typeDef, v, setter, mapper, r) {
+  r[valuePath] = mapper(typeDef, v, setter, typePath, valuePath);
+  return internalFlattenValueChildren(valuePath, typePath, "", typeDef, v, mapper, r);
+}
+function internalFlattenValueChildren(valuePath, typePath, qualifier, typeDef, v, mapper, r) {
+  switch (typeDef.type) {
+    case 1 /* Literal */:
+      return r;
+    case 2 /* List */:
+      return internalFlattenListChildren(valuePath, typePath, typeDef, v, mapper, r);
+    case 3 /* Record */:
+      return internalFlattenRecordChildren(valuePath, typePath, typeDef, v, mapper, r);
+    case 4 /* Object */:
+      return internalFlattenObjectChildren(valuePath, typePath, qualifier, typeDef, v, mapper, r);
+    case 5 /* Union */:
+      return internalFlattenUnionChildren(valuePath, typePath, qualifier, typeDef, v, mapper, r);
+    default:
+      throw new UnreachableError2(typeDef);
+  }
+}
+function internalFlattenListChildren(valuePath, typePath, { elements }, v, mapper, r) {
+  const newTypePath = jsonPath(typePath, "*");
+  return v.reduce(function(r2, e, i) {
+    return internalFlattenValue(
+      jsonPath(valuePath, i),
+      newTypePath,
+      elements,
+      e,
+      (e2) => {
+        v[i] = e2;
+      },
+      mapper,
+      r2
+    );
+  }, r);
+}
+function internalFlattenRecordChildren(valuePath, typePath, { valueTypeDef }, v, mapper, r) {
+  const newTypePath = jsonPath(typePath, "*");
+  return reduce2(
+    v,
+    function(r2, k, value) {
+      return internalFlattenValue(
+        jsonPath(valuePath, k),
+        newTypePath,
+        valueTypeDef,
+        value,
+        (value2) => {
+          v[k] = value2;
+        },
+        mapper,
+        r2
+      );
+    },
+    r
+  );
+}
+function internalFlattenObjectChildren(valuePath, typePath, qualifier, { fields }, v, mapper, r) {
+  return reduce2(
+    fields,
+    function(r2, k, fieldTypeDef) {
+      const fieldValue = v[k];
+      return internalFlattenValue(
+        jsonPath(valuePath, k, qualifier),
+        jsonPath(typePath, k, qualifier),
+        fieldTypeDef,
+        fieldValue,
+        (value) => {
+          v[k] = value;
+        },
+        mapper,
+        r2
+      );
+    },
+    r
+  );
+}
+function internalFlattenUnionChildren(valuePath, typePath, qualifier, typeDef, v, mapper, r) {
+  const childTypeDef = getUnionTypeDef(typeDef, v);
+  const newQualifier = typeDef.discriminator != null ? `${qualifier}${v[typeDef.discriminator]}:` : qualifier;
+  return internalFlattenValueChildren(
+    valuePath,
+    typePath,
+    newQualifier,
+    childTypeDef,
+    v,
+    mapper,
+    r
+  );
+}
+function getUnionTypeDef(typeDef, v) {
+  if (typeDef.discriminator == null) {
+    return reduce2(
+      typeDef.unions,
+      function(acc, _k, t) {
+        if (t.type === 1 /* Literal */ && t.valuePrototype) {
+          if (t.valuePrototype.indexOf(v) >= 0) {
+            return t;
+          }
+        } else {
+          if (acc == null) {
+            return t;
+          }
+        }
+        return acc;
+      },
+      null
+    );
+  }
+  return typeDef.unions[v[typeDef.discriminator]];
+}
+
+// transformers/copies/mobx_copy.ts
+function observeValue(v, def) {
+  if (v == null) {
+    return v;
+  }
+  switch (def.type) {
+    case 1 /* Literal */:
+      return v;
+    case 2 /* List */:
+      return observable.array(v, { deep: false });
+    case 3 /* Record */:
+      return observable(
+        v,
+        {},
+        {
+          deep: false
+        }
+      );
+    case 4 /* Object */:
+      return makeObservable(
+        v,
+        reduce3(
+          def.fields,
+          function(acc, k) {
+            acc[k] = observable;
+            return acc;
+          },
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          {}
+        ),
+        {
+          deep: false
+        }
+      );
+    case 5 /* Union */:
+      return observeValue(v, getUnionTypeDef(def, v));
+    default:
+      throw new UnreachableError3(def);
+  }
+}
+function mobxCopy(t, proto) {
+  return copyTo(t, proto, observeValue);
+}
+
+// transformers/flatteners/flatten_accessors_of.ts
+function mapAccessor(_t, value, set) {
+  return {
+    value,
+    set
+  };
+}
+function flattenAccessorsOf(t, value, setValue) {
+  return flattenValueTypeTo(
+    t,
+    value,
+    setValue,
+    mapAccessor
+  );
+}
+
+// transformers/flatteners/flatten_json_value_to_type_paths_of.ts
+function mapTypePaths(_t, _value, _set, typePath) {
+  return typePath;
+}
+function flattenJsonValueToTypePathsOf(t, value) {
+  return flattenValueTypeTo(
+    t,
+    value,
+    function() {
+    },
+    mapTypePaths
+  );
+}
+
+// transformers/flatteners/flatten_type_def_to.ts
+import {
+  reduce as reduce4,
+  UnreachableError as UnreachableError4
+} from "@strictly/base";
+function flattenTypeDefTo({ definition }, mapper) {
+  const typeDefs = internalFlattenTypeDef("$", definition, {});
+  return reduce4(
+    typeDefs,
+    function(acc, key, typeDef) {
+      acc[key] = mapper(typeDef);
+      return acc;
+    },
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    {}
+  );
+}
+function internalFlattenTypeDef(path, t, r) {
+  r[path] = t;
+  return internalFlattenTypeDefChildren(path, "", t, r);
+}
+function internalFlattenTypeDefChildren(path, qualifier, t, r) {
+  switch (t.type) {
+    case 1 /* Literal */:
+      return r;
+    case 2 /* List */:
+      return internalFlattenedListTypeDefChildren(path, t, r);
+    case 3 /* Record */:
+      return internalFlattenRecordTypeDefChildren(path, t, r);
+    case 4 /* Object */:
+      return internalFlattenObjectTypeDefChildren(path, qualifier, t, r);
+    case 5 /* Union */:
+      return internalFlattenUnionTypeDefChildren(path, qualifier, t, r);
+    default:
+      throw new UnreachableError4(t);
+  }
+}
+function internalFlattenedListTypeDefChildren(path, { elements }, r) {
+  return internalFlattenTypeDef(jsonPath(path, "*"), elements, r);
+}
+function internalFlattenRecordTypeDefChildren(path, { valueTypeDef }, r) {
+  return internalFlattenTypeDef(jsonPath(path, "*"), valueTypeDef, r);
+}
+function internalFlattenObjectTypeDefChildren(path, qualifier, { fields }, r) {
+  return reduce4(
+    fields,
+    function(acc, fieldName, fieldTypeDef) {
+      return internalFlattenTypeDef(
+        jsonPath(path, fieldName, qualifier),
+        fieldTypeDef,
+        acc
+      );
+    },
+    r
+  );
+}
+function internalFlattenUnionTypeDefChildren(path, qualifier, {
+  discriminator,
+  unions
+}, r) {
+  return reduce4(
+    unions,
+    function(acc, key, typeDef) {
+      return internalFlattenTypeDefChildren(
+        path,
+        discriminator != null ? `${qualifier}${key}:` : qualifier,
+        typeDef,
+        acc
+      );
+    },
+    r
+  );
+}
+
+// transformers/flatteners/flatten_type_defs_of.ts
+function flattenTypeDefsOf(t) {
+  return flattenTypeDefTo(
+    t,
+    function(definition) {
+      return { definition };
+    }
+  );
+}
+
+// transformers/flatteners/value_path_to_type_path.ts
+import {
+  assertEqual,
+  assertExists,
+  assertExistsAndReturn,
+  PreconditionFailedError,
+  reduce as reduce5,
+  UnreachableError as UnreachableError5
+} from "@strictly/base";
+function valuePathToTypePath({ definition: typeDef }, valuePath, allowMissingPaths = false) {
+  const valueSteps = valuePath.split(/\.|\[/g);
+  assertEqual(valueSteps[0], "$");
+  const typeSteps = internalJsonValuePathToTypePath(
+    typeDef,
+    valueSteps.slice(1),
+    allowMissingPaths,
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    valuePath
+  );
+  typeSteps.unshift("$");
+  return typeSteps.join(".");
+}
+function internalJsonValuePathToTypePath(typeDef, valueSteps, allowMissingPaths, originalValuePath) {
+  if (valueSteps.length === 0) {
+    return [];
+  }
+  const [
+    valueStep,
+    ...remainingValueSteps
+  ] = valueSteps;
+  switch (typeDef.type) {
+    case 1 /* Literal */:
+      if (allowMissingPaths) {
+        return valueSteps;
+      } else {
+        throw new PreconditionFailedError(
+          "literal should terminate path {} ({})",
+          originalValuePath,
+          valueStep
+        );
+      }
+    case 2 /* List */:
+      return [
+        "*",
+        ...internalJsonValuePathToTypePath(
+          typeDef.elements,
+          remainingValueSteps,
+          allowMissingPaths,
+          originalValuePath
+        )
+      ];
+    case 3 /* Record */:
+      return [
+        "*",
+        ...internalJsonValuePathToTypePath(
+          typeDef.valueTypeDef,
+          remainingValueSteps,
+          allowMissingPaths,
+          originalValuePath
+        )
+      ];
+    case 4 /* Object */:
+      if (allowMissingPaths) {
+        if (typeDef.fields[valueStep] == null) {
+          return valueSteps;
+        }
+      } else {
+        assertExists(typeDef.fields[valueStep], "missing field in {} ({})", originalValuePath, valueStep);
+      }
+      return [
+        valueStep,
+        ...internalJsonValuePathToTypePath(
+          typeDef.fields[valueStep],
+          remainingValueSteps,
+          allowMissingPaths,
+          originalValuePath
+        )
+      ];
+    case 5 /* Union */:
+      if (typeDef.discriminator == null) {
+        if (remainingValueSteps.length > 0) {
+          const union2 = reduce5(
+            typeDef.unions,
+            function(acc, _k, v) {
+              if (v.type !== 1 /* Literal */ || v.type === 1 /* Literal */ && v.valuePrototype == null) {
+                return v;
+              }
+              return acc;
+            },
+            null
+          );
+          assertExists(union2, "expected a complex union {}", originalValuePath);
+          return internalJsonValuePathToTypePath(
+            union2,
+            valueSteps,
+            allowMissingPaths,
+            originalValuePath
+          );
+        } else {
+          return [];
+        }
+      } else {
+        const qualifierIndex = valueStep.indexOf(":");
+        if (qualifierIndex < 0) {
+          if (allowMissingPaths) {
+            return valueSteps;
+          } else {
+            throw new PreconditionFailedError(
+              "mismatched qualifiers in {} (at {})",
+              originalValuePath,
+              valueStep
+            );
+          }
+        }
+        const qualifier = valueStep.substring(0, qualifierIndex);
+        const remainder = valueStep.substring(qualifierIndex + 1);
+        const union2 = assertExistsAndReturn(typeDef.unions[qualifier], "missing union {}", qualifier);
+        const [
+          typeStep,
+          ...remainingTypeSteps
+        ] = internalJsonValuePathToTypePath(
+          union2,
+          [
+            remainder,
+            ...remainingValueSteps
+          ],
+          allowMissingPaths,
+          originalValuePath
+        );
+        return [
+          `${qualifier}:${typeStep}`,
+          ...remainingTypeSteps
+        ];
+      }
+    default:
+      throw new UnreachableError5(typeDef);
+  }
+}
+
+// types/builders.ts
+var TypeDefBuilder = class {
+  constructor(definition) {
+    this.definition = definition;
+  }
+  // returns just the relevant types, which can help typescript
+  // from complaining about infinitely deep data structures
+  get narrow() {
+    return {
+      definition: this.definition
+    };
+  }
+};
+var LiteralTypeDefBuilder = class extends TypeDefBuilder {
+};
+var ListTypeDefBuilder = class extends TypeDefBuilder {
+  readonly() {
+    return this;
+  }
+};
+var RecordTypeDefBuilder = class extends TypeDefBuilder {
+  partial() {
+    return this;
+  }
+  readonly() {
+    return this;
+  }
+};
+var ObjectTypeDefBuilder = class _ObjectTypeDefBuilder extends TypeDefBuilder {
+  set(name, { definition: typeDef }) {
+    const newFields = {
+      [name]: typeDef
+    };
+    return new _ObjectTypeDefBuilder({
+      type: 4 /* Object */,
+      fields: {
+        ...this.definition.fields,
+        ...newFields
+      }
+    });
+  }
+  setReadonly(name, { definition: typeDef }) {
+    const newFields = {
+      [name]: typeDef
+    };
+    return new _ObjectTypeDefBuilder({
+      type: 4 /* Object */,
+      fields: {
+        ...this.definition.fields,
+        ...newFields
+      }
+    });
+  }
+  setOptional(name, { definition: typeDef }) {
+    const newFields = {
+      [name]: typeDef
+    };
+    return new _ObjectTypeDefBuilder({
+      type: 4 /* Object */,
+      fields: {
+        ...this.definition.fields,
+        ...newFields
+      }
+    });
+  }
+  setReadonlyOptional(name, { definition: typeDef }) {
+    const newFields = {
+      [name]: typeDef
+    };
+    return new _ObjectTypeDefBuilder({
+      type: 4 /* Object */,
+      fields: {
+        ...this.definition.fields,
+        ...newFields
+      }
+    });
+  }
+};
+var UnionTypeDefBuilder = class _UnionTypeDefBuilder extends TypeDefBuilder {
+  add(k, {
+    definition: typeDef
+  }) {
+    const {
+      discriminator,
+      unions
+    } = this.definition;
+    return new _UnionTypeDefBuilder(
+      {
+        type: 5 /* Union */,
+        discriminator,
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        unions: {
+          ...unions,
+          [k]: typeDef
+        }
+      }
+    );
+  }
+};
+function literal(value) {
+  return new LiteralTypeDefBuilder({
+    type: 1 /* Literal */,
+    valuePrototype: value
+  });
+}
+var stringType = literal();
+var numberType = literal();
+var booleanType = literal();
+var nullType = literal([null]);
+function nullable(nonNullable) {
+  return new UnionTypeDefBuilder(
+    {
+      type: 5 /* Union */,
+      discriminator: null,
+      unions: {
+        ["0"]: nonNullable.definition,
+        ["1"]: nullType.definition
+      }
+    }
+  );
+}
+function list(elements) {
+  return new ListTypeDefBuilder({
+    type: 2 /* List */,
+    elements: elements.definition
+  });
+}
+function record({ definition: typeDef }) {
+  return new RecordTypeDefBuilder({
+    type: 3 /* Record */,
+    // eslint-disable-next-line no-undefined
+    keyPrototype: void 0,
+    valueTypeDef: typeDef
+  });
+}
+function object() {
+  return new ObjectTypeDefBuilder({
+    type: 4 /* Object */,
+    fields: {}
+  });
+}
+function union(discriminator) {
+  return new UnionTypeDefBuilder(
+    {
+      type: 5 /* Union */,
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      discriminator: discriminator ?? null,
+      unions: {}
+    }
+  );
+}
+export {
+  TypeDefType,
+  booleanType,
+  copy,
+  flattenAccessorsOf,
+  flattenJsonValueToTypePathsOf,
+  flattenTypeDefsOf,
+  flattenValueTypeTo,
+  getUnionTypeDef,
+  jsonPath,
+  jsonPathPop,
+  list,
+  literal,
+  mobxCopy,
+  nullType,
+  nullable,
+  numberType,
+  object,
+  record,
+  stringType,
+  union,
+  valuePathToTypePath
+};