@strictly/define 0.0.1 → 0.0.2

package/dist/index.cjs

@@ -20,14 +20,22 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // index.ts
 var index_exports = {};
 __export(index_exports, {
+  DefinedValidator: () => DefinedValidator,
+  MinimumStringLengthValidationErrorType: () => MinimumStringLengthValidationErrorType,
+  MinimumStringLengthValidator: () => MinimumStringLengthValidator,
   TypeDefType: () => TypeDefType,
+  annotations: () => annotations,
   booleanType: () => booleanType,
   copy: () => copy,
-  flattenAccessorsOf: () => flattenAccessorsOf,
+  flattenAccessorsOfType: () => flattenAccessorsOfType,
   flattenJsonValueToTypePathsOf: () => flattenJsonValueToTypePathsOf,
-  flattenTypeDefsOf: () => flattenTypeDefsOf,
-  flattenValueTypeTo: () => flattenValueTypeTo,
+  flattenTypesOfType: () => flattenTypesOfType,
+  flattenValidatorsOfValidatingType: () => flattenValidatorsOfValidatingType,
+  flattenValueTo: () => flattenValueTo,
+  flattenValuesOfType: () => flattenValuesOfType,
   getUnionTypeDef: () => getUnionTypeDef,
+  isAnnotatedValidator: () => isAnnotatedValidator,
+  isFunctionalValidator: () => isFunctionalValidator,
   jsonPath: () => jsonPath,
   jsonPathPop: () => jsonPathPop,
   list: () => list,
@@ -40,6 +48,7 @@ __export(index_exports, {
   record: () => record,
   stringType: () => stringType,
   union: () => union,
+  validate: () => validate,
   valuePathToTypePath: () => valuePathToTypePath
 });
 module.exports = __toCommonJS(index_exports);
@@ -66,6 +75,9 @@ function copyTo({ definition }, value, copier) {
   );
 }
 function internalCopyTo(definition, value, copier) {
+  if (value === void 0) {
+    return void 0;
+  }
   switch (definition.type) {
     case 1 /* Literal */:
       return copyLiteral(
@@ -190,7 +202,7 @@ function copy(t, proto) {
 var import_base3 = require("@strictly/base");
 var import_mobx = require("mobx");
 
-// transformers/flatteners/flatten_value_type_to.ts
+// transformers/flatteners/flatten_value_to.ts
 var import_base2 = require("@strictly/base");
 
 // transformers/flatteners/json_path.ts
@@ -209,8 +221,8 @@ function jsonPathPop(path) {
   ];
 }
 
-// transformers/flatteners/flatten_value_type_to.ts
-function flattenValueTypeTo({ definition }, v, setter, mapper) {
+// transformers/flatteners/flatten_value_to.ts
+function flattenValueTo({ definition }, v, setter, mapper2) {
   const r = {};
   internalFlattenValue(
     "$",
@@ -218,32 +230,35 @@ function flattenValueTypeTo({ definition }, v, setter, mapper) {
     definition,
     v,
     setter,
-    mapper,
+    mapper2,
     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 internalFlattenValue(valuePath, typePath, typeDef, v, setter, mapper2, r) {
+  r[valuePath] = mapper2(typeDef, v, setter, typePath, valuePath);
+  if (v !== void 0) {
+    return internalFlattenValueChildren(valuePath, typePath, "", typeDef, v, mapper2, r);
+  }
+  return r;
 }
-function internalFlattenValueChildren(valuePath, typePath, qualifier, typeDef, v, mapper, r) {
+function internalFlattenValueChildren(valuePath, typePath, qualifier, typeDef, v, mapper2, r) {
   switch (typeDef.type) {
     case 1 /* Literal */:
       return r;
     case 2 /* List */:
-      return internalFlattenListChildren(valuePath, typePath, typeDef, v, mapper, r);
+      return internalFlattenListChildren(valuePath, typePath, typeDef, v, mapper2, r);
     case 3 /* Record */:
-      return internalFlattenRecordChildren(valuePath, typePath, typeDef, v, mapper, r);
+      return internalFlattenRecordChildren(valuePath, typePath, typeDef, v, mapper2, r);
     case 4 /* Object */:
-      return internalFlattenObjectChildren(valuePath, typePath, qualifier, typeDef, v, mapper, r);
+      return internalFlattenObjectChildren(valuePath, typePath, qualifier, typeDef, v, mapper2, r);
     case 5 /* Union */:
-      return internalFlattenUnionChildren(valuePath, typePath, qualifier, typeDef, v, mapper, r);
+      return internalFlattenUnionChildren(valuePath, typePath, qualifier, typeDef, v, mapper2, r);
     default:
       throw new import_base2.UnreachableError(typeDef);
   }
 }
-function internalFlattenListChildren(valuePath, typePath, { elements }, v, mapper, r) {
+function internalFlattenListChildren(valuePath, typePath, { elements }, v, mapper2, r) {
   const newTypePath = jsonPath(typePath, "*");
   return v.reduce(function(r2, e, i) {
     return internalFlattenValue(
@@ -254,12 +269,12 @@ function internalFlattenListChildren(valuePath, typePath, { elements }, v, mappe
       (e2) => {
         v[i] = e2;
       },
-      mapper,
+      mapper2,
       r2
     );
   }, r);
 }
-function internalFlattenRecordChildren(valuePath, typePath, { valueTypeDef }, v, mapper, r) {
+function internalFlattenRecordChildren(valuePath, typePath, { valueTypeDef }, v, mapper2, r) {
   const newTypePath = jsonPath(typePath, "*");
   return (0, import_base2.reduce)(
     v,
@@ -272,14 +287,14 @@ function internalFlattenRecordChildren(valuePath, typePath, { valueTypeDef }, v,
         (value2) => {
           v[k] = value2;
         },
-        mapper,
+        mapper2,
         r2
       );
     },
     r
   );
 }
-function internalFlattenObjectChildren(valuePath, typePath, qualifier, { fields }, v, mapper, r) {
+function internalFlattenObjectChildren(valuePath, typePath, qualifier, { fields }, v, mapper2, r) {
   return (0, import_base2.reduce)(
     fields,
     function(r2, k, fieldTypeDef) {
@@ -292,14 +307,14 @@ function internalFlattenObjectChildren(valuePath, typePath, qualifier, { fields
         (value) => {
           v[k] = value;
         },
-        mapper,
+        mapper2,
         r2
       );
     },
     r
   );
 }
-function internalFlattenUnionChildren(valuePath, typePath, qualifier, typeDef, v, mapper, r) {
+function internalFlattenUnionChildren(valuePath, typePath, qualifier, typeDef, v, mapper2, r) {
   const childTypeDef = getUnionTypeDef(typeDef, v);
   const newQualifier = typeDef.discriminator != null ? `${qualifier}${v[typeDef.discriminator]}:` : qualifier;
   return internalFlattenValueChildren(
@@ -308,7 +323,7 @@ function internalFlattenUnionChildren(valuePath, typePath, qualifier, typeDef, v
     newQualifier,
     childTypeDef,
     v,
-    mapper,
+    mapper2,
     r
   );
 }
@@ -378,15 +393,15 @@ function mobxCopy(t, proto) {
   return copyTo(t, proto, observeValue);
 }
 
-// transformers/flatteners/flatten_accessors_of.ts
+// transformers/flatteners/flatten_accessors_of_type.ts
 function mapAccessor(_t, value, set) {
   return {
     value,
     set
   };
 }
-function flattenAccessorsOf(t, value, setValue) {
-  return flattenValueTypeTo(
+function flattenAccessorsOfType(t, value, setValue) {
+  return flattenValueTo(
     t,
     value,
     setValue,
@@ -399,7 +414,7 @@ function mapTypePaths(_t, _value, _set, typePath) {
   return typePath;
 }
 function flattenJsonValueToTypePathsOf(t, value) {
-  return flattenValueTypeTo(
+  return flattenValueTo(
     t,
     value,
     function() {
@@ -408,14 +423,14 @@ function flattenJsonValueToTypePathsOf(t, value) {
   );
 }
 
-// transformers/flatteners/flatten_type_def_to.ts
+// transformers/flatteners/flatten_type_to.ts
 var import_base4 = require("@strictly/base");
-function flattenTypeDefTo({ definition }, mapper) {
+function flattenTypeTo({ definition }, mapper2) {
   const typeDefs = internalFlattenTypeDef("$", definition, {});
   return (0, import_base4.reduce)(
     typeDefs,
     function(acc, key, typeDef) {
-      acc[key] = mapper(typeDef);
+      acc[key] = mapper2(typeDef);
       return acc;
     },
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -479,9 +494,9 @@ function internalFlattenUnionTypeDefChildren(path, qualifier, {
   );
 }
 
-// transformers/flatteners/flatten_type_defs_of.ts
-function flattenTypeDefsOf(t) {
-  return flattenTypeDefTo(
+// transformers/flatteners/flatten_types_of_type.ts
+function flattenTypesOfType(t) {
+  return flattenTypeTo(
     t,
     function(definition) {
       return { definition };
@@ -489,6 +504,41 @@ function flattenTypeDefsOf(t) {
   );
 }
 
+// transformers/flatteners/flatten_validators_of_validating_type.ts
+function flattenValidatorsOfValidatingType(type) {
+  return flattenTypeTo(type, function(definition) {
+    const {
+      rule,
+      readonly,
+      required
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    } = definition;
+    return {
+      annotations: function() {
+        return {
+          readonly,
+          required
+        };
+      },
+      validate: rule
+    };
+  });
+}
+
+// transformers/flatteners/flatten_values_of_type.ts
+function mapper(_t, v) {
+  return v;
+}
+function flattenValuesOfType(typeDef, value) {
+  return flattenValueTo(
+    typeDef,
+    value,
+    () => {
+    },
+    mapper
+  );
+}
+
 // transformers/flatteners/value_path_to_type_path.ts
 var import_base5 = require("@strictly/base");
 function valuePathToTypePath({ definition: typeDef }, valuePath, allowMissingPaths = false) {
@@ -621,77 +671,222 @@ function internalJsonValuePathToTypePath(typeDef, valueSteps, allowMissingPaths,
   }
 }
 
+// types/type_of_type.ts
+var import_base6 = require("@strictly/base");
+function typeOfType({ definition }) {
+  return {
+    definition: typeDefOfTypeDef(definition)
+  };
+}
+function typeDefOfTypeDef(t) {
+  switch (t.type) {
+    case 1 /* Literal */:
+      return typeDefOfLiteralTypeDef(t);
+    case 2 /* List */:
+      return typeDefOfListTypeDef(t);
+    case 3 /* Record */:
+      return typeDefOfRecordTypeDef(t);
+    case 4 /* Object */:
+      return typeDefOfObjectTypeDef(t);
+    case 5 /* Union */:
+      return typeDefOfUnionTypeDef(t);
+    default:
+      throw new import_base6.UnreachableError(t);
+  }
+}
+function typeDefOfLiteralTypeDef({
+  type,
+  valuePrototype
+}) {
+  return {
+    type,
+    valuePrototype
+  };
+}
+function typeDefOfListTypeDef({
+  type,
+  elements
+}) {
+  return {
+    type,
+    elements: typeDefOfTypeDef(elements)
+  };
+}
+function typeDefOfRecordTypeDef({
+  type,
+  keyPrototype,
+  valueTypeDef
+}) {
+  return {
+    type,
+    keyPrototype,
+    valueTypeDef: typeDefOfTypeDef(valueTypeDef)
+  };
+}
+function typeDefOfObjectTypeDef({
+  type,
+  fields
+}) {
+  return {
+    type,
+    fields: (0, import_base6.map)(fields, function(_k, v) {
+      return typeDefOfTypeDef(v);
+    })
+  };
+}
+function typeDefOfUnionTypeDef({
+  type,
+  discriminator,
+  unions
+}) {
+  return {
+    type,
+    discriminator,
+    unions: (0, import_base6.map)(unions, function(_k, v) {
+      return typeDefOfTypeDef(v);
+    })
+  };
+}
+
 // types/builders.ts
-var TypeDefBuilder = class {
+function emptyRule() {
+  return null;
+}
+var TypeDefBuilder = class _TypeDefBuilder {
   constructor(definition) {
     this.definition = definition;
   }
-  // returns just the relevant types, which can help typescript
-  // from complaining about infinitely deep data structures
+  enforce(rule) {
+    return new _TypeDefBuilder(
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      {
+        ...this.definition,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        rule: (value) => {
+          return this.definition.rule(value) || rule(value);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      }
+    );
+  }
+  required(rule) {
+    return new _TypeDefBuilder(
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      {
+        ...this.definition,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        rule: (v) => {
+          return this.definition.rule(v) || rule?.(v);
+        },
+        required: true
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      }
+    );
+  }
+  readonly() {
+    return new _TypeDefBuilder(
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      {
+        ...this.definition,
+        readonly: true
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      }
+    );
+  }
+  // should only be used in tests requiring Types, client code should be happy with validating types
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  get _type() {
+    return typeOfType(this);
+  }
   get narrow() {
     return {
       definition: this.definition
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
     };
   }
 };
-var LiteralTypeDefBuilder = class extends TypeDefBuilder {
-};
-var ListTypeDefBuilder = class extends TypeDefBuilder {
-  readonly() {
-    return this;
+var ListTypeDefBuilder = class _ListTypeDefBuilder extends TypeDefBuilder {
+  readonlyElements() {
+    return new _ListTypeDefBuilder({
+      ...this.definition,
+      elements: {
+        ...this.definition.elements,
+        readonly: true
+      }
+    });
   }
 };
-var RecordTypeDefBuilder = class extends TypeDefBuilder {
-  partial() {
+var RecordTypeDefBuilder = class _RecordTypeDefBuilder extends TypeDefBuilder {
+  partialKeys() {
     return this;
   }
-  readonly() {
-    return this;
+  readonlyKeys() {
+    return new _RecordTypeDefBuilder({
+      ...this.definition,
+      valueTypeDef: {
+        ...this.definition.valueTypeDef,
+        readonly: true
+      }
+    });
   }
 };
 var ObjectTypeDefBuilder = class _ObjectTypeDefBuilder extends TypeDefBuilder {
-  set(name, { definition: typeDef }) {
-    const newFields = {
-      [name]: typeDef
-    };
+  field(name, { definition }, rule) {
     return new _ObjectTypeDefBuilder({
-      type: 4 /* Object */,
+      ...this.definition,
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       fields: {
         ...this.definition.fields,
-        ...newFields
+        [name]: {
+          ...definition,
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          rule: function(v) {
+            return definition.rule(v) || rule?.(v);
+          },
+          required: true
+        }
       }
     });
   }
-  setReadonly(name, { definition: typeDef }) {
+  readonlyField(name, { definition }) {
     const newFields = {
-      [name]: typeDef
+      [name]: {
+        ...definition,
+        required: true,
+        readonly: true
+      }
     };
     return new _ObjectTypeDefBuilder({
-      type: 4 /* Object */,
+      ...this.definition,
       fields: {
         ...this.definition.fields,
         ...newFields
       }
     });
   }
-  setOptional(name, { definition: typeDef }) {
+  optionalField(name, { definition }) {
     const newFields = {
-      [name]: typeDef
+      [name]: {
+        ...definition
+      }
     };
     return new _ObjectTypeDefBuilder({
-      type: 4 /* Object */,
+      ...this.definition,
       fields: {
         ...this.definition.fields,
         ...newFields
       }
     });
   }
-  setReadonlyOptional(name, { definition: typeDef }) {
+  readonlyOptionalField(name, { definition }) {
     const newFields = {
-      [name]: typeDef
+      [name]: {
+        ...definition,
+        readonly: true
+      }
     };
     return new _ObjectTypeDefBuilder({
-      type: 4 /* Object */,
+      ...this.definition,
       fields: {
         ...this.definition.fields,
         ...newFields
@@ -700,17 +895,15 @@ var ObjectTypeDefBuilder = class _ObjectTypeDefBuilder extends TypeDefBuilder {
   }
 };
 var UnionTypeDefBuilder = class _UnionTypeDefBuilder extends TypeDefBuilder {
-  add(k, {
+  or(k, {
     definition: typeDef
   }) {
     const {
-      discriminator,
       unions
     } = this.definition;
     return new _UnionTypeDefBuilder(
       {
-        type: 5 /* Union */,
-        discriminator,
+        ...this.definition,
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         unions: {
           ...unions,
@@ -721,9 +914,12 @@ var UnionTypeDefBuilder = class _UnionTypeDefBuilder extends TypeDefBuilder {
   }
 };
 function literal(value) {
-  return new LiteralTypeDefBuilder({
+  return new TypeDefBuilder({
     type: 1 /* Literal */,
-    valuePrototype: value
+    valuePrototype: value,
+    rule: emptyRule,
+    readonly: false,
+    required: false
   });
 }
 var stringType = literal();
@@ -738,28 +934,40 @@ function nullable(nonNullable) {
       unions: {
         ["0"]: nonNullable.definition,
         ["1"]: nullType.definition
-      }
+      },
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      rule: emptyRule,
+      readonly: false,
+      required: false
     }
   );
 }
 function list(elements) {
   return new ListTypeDefBuilder({
     type: 2 /* List */,
-    elements: elements.definition
+    elements: elements.definition,
+    rule: emptyRule,
+    readonly: false,
+    required: false
   });
 }
-function record({ definition: typeDef }) {
+function record({ definition: valueTypeDef }) {
   return new RecordTypeDefBuilder({
     type: 3 /* Record */,
-    // eslint-disable-next-line no-undefined
     keyPrototype: void 0,
-    valueTypeDef: typeDef
+    valueTypeDef,
+    rule: emptyRule,
+    readonly: false,
+    required: false
   });
 }
 function object() {
   return new ObjectTypeDefBuilder({
     type: 4 /* Object */,
-    fields: {}
+    fields: {},
+    rule: emptyRule,
+    readonly: false,
+    required: false
   });
 }
 function union(discriminator) {
@@ -768,20 +976,99 @@ function union(discriminator) {
       type: 5 /* Union */,
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       discriminator: discriminator ?? null,
-      unions: {}
+      unions: {},
+      rule: emptyRule,
+      readonly: false,
+      required: false
     }
   );
 }
+
+// validation/validator.ts
+function isFunctionalValidator(v) {
+  return typeof v === "function";
+}
+function isAnnotatedValidator(v) {
+  return typeof v !== "function";
+}
+function validate(validator, v, valuePath, context) {
+  if (isAnnotatedValidator(validator)) {
+    return validator.validate(v, valuePath, context);
+  } else {
+    return validator(v, valuePath, context);
+  }
+}
+function annotations(validator, valuePath, context) {
+  if (isAnnotatedValidator(validator)) {
+    return validator.annotations(valuePath, context);
+  } else {
+    return {
+      required: false,
+      readonly: false
+    };
+  }
+}
+
+// validation/validators/defined_validator.ts
+var DefinedValidator = class {
+  constructor(error) {
+    this.error = error;
+  }
+  validate(v) {
+    if (v == null) {
+      return this.error;
+    }
+    return null;
+  }
+  annotations() {
+    return {
+      required: true,
+      readonly: false
+    };
+  }
+};
+
+// validation/validators/minimum_string_length_validator.ts
+var MinimumStringLengthValidationErrorType = "minimum_string_length";
+var MinimumStringLengthValidator = class {
+  constructor(minimumLength) {
+    this.minimumLength = minimumLength;
+  }
+  validate(value) {
+    if (value.length < this.minimumLength) {
+      return {
+        type: MinimumStringLengthValidationErrorType,
+        minimumLength: this.minimumLength,
+        receivedLength: value.length
+      };
+    }
+    return null;
+  }
+  annotations() {
+    return {
+      required: true,
+      readonly: false
+    };
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DefinedValidator,
+  MinimumStringLengthValidationErrorType,
+  MinimumStringLengthValidator,
   TypeDefType,
+  annotations,
   booleanType,
   copy,
-  flattenAccessorsOf,
+  flattenAccessorsOfType,
   flattenJsonValueToTypePathsOf,
-  flattenTypeDefsOf,
-  flattenValueTypeTo,
+  flattenTypesOfType,
+  flattenValidatorsOfValidatingType,
+  flattenValueTo,
+  flattenValuesOfType,
   getUnionTypeDef,
+  isAnnotatedValidator,
+  isFunctionalValidator,
   jsonPath,
   jsonPathPop,
   list,
@@ -794,5 +1081,6 @@ function union(discriminator) {
   record,
   stringType,
   union,
+  validate,
   valuePathToTypePath
 });