inferred-types 0.27.0 → 0.28.2

package/dist/index.js

@@ -21,9 +21,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   Configurator: () => Configurator,
+  DEFAULT_MANY_TO_ONE_MAPPING: () => DEFAULT_MANY_TO_ONE_MAPPING,
+  DEFAULT_ONE_TO_MANY_MAPPING: () => DEFAULT_ONE_TO_MANY_MAPPING,
+  DEFAULT_ONE_TO_ONE_MAPPING: () => DEFAULT_ONE_TO_ONE_MAPPING,
   ExplicitFunction: () => ExplicitFunction,
   FluentConfigurator: () => FluentConfigurator,
-  MapDirection: () => MapDirection,
+  MapCardinality: () => MapCardinality,
   Model: () => Model,
   MutationIdentity: () => MutationIdentity,
   and: () => and,
@@ -130,12 +133,12 @@ var valueTypes = {
 };
 
 // src/types/dictionary/MapTo.ts
-var MapDirection = /* @__PURE__ */ ((MapDirection2) => {
-  MapDirection2["OneToMany"] = "I -> O[]";
-  MapDirection2["OneToOne"] = "I -> O";
-  MapDirection2["ManyToOne"] = "I[] -> O";
-  return MapDirection2;
-})(MapDirection || {});
+var MapCardinality = /* @__PURE__ */ ((MapCardinality2) => {
+  MapCardinality2["OneToMany"] = "I -> O[]";
+  MapCardinality2["OneToOne"] = "I -> O";
+  MapCardinality2["ManyToOne"] = "I[] -> O";
+  return MapCardinality2;
+})(MapCardinality || {});
 
 // src/utility/keys.ts
 function keys(obj, ...without) {
@@ -590,32 +593,66 @@ function mapValues(obj, valueMapper) {
 }
 
 // src/utility/dictionary/mapTo.ts
-var mapper = (config = {}) => (map) => {
-  config = {
-    input: "req",
-    output: "opt",
-    direction: "I -> O[]",
-    ...config
-  };
-  const fn = (source) => {
-    const isArray2 = config.direction === "I -> O[]" && Array.isArray(source) ? true : config.direction === "I[] -> O" && Array.isArray(source) && Array.isArray(source[0]) ? true : false;
+var toFinalizedConfig = (config) => {
+  return { ...config, finalized: true };
+};
+var DEFAULT_ONE_TO_MANY_MAPPING = toFinalizedConfig({
+  input: "req",
+  output: "opt",
+  cardinality: "I -> O[]"
+});
+var DEFAULT_ONE_TO_ONE_MAPPING = toFinalizedConfig({
+  input: "req",
+  output: "req",
+  cardinality: "I -> O"
+});
+var DEFAULT_MANY_TO_ONE_MAPPING = toFinalizedConfig({
+  input: "req",
+  output: "req",
+  cardinality: "I[] -> O"
+});
+var mapper = (config) => (map) => {
+  return (source) => {
+    const isArray2 = config.cardinality === "I -> O[]" && Array.isArray(source) ? true : config.cardinality === "I[] -> O" && Array.isArray(source) && Array.isArray(source[0]) ? true : false;
     if (isArray2) {
       return source.flatMap(map);
     } else {
       return map(source);
     }
   };
-  return fn;
 };
+var setMapper = (config = { input: void 0, output: void 0, cardinality: void 0 }, defaultValue) => ({
+  map: (source) => {
+    const c = {
+      ...defaultValue,
+      ...config
+    };
+    return mapper(c)(source);
+  },
+  input: (config == null ? void 0 : config.input) || defaultValue.input,
+  output: (config == null ? void 0 : config.output) || defaultValue.output,
+  cardinality: (config == null ? void 0 : config.cardinality) || defaultValue.cardinality
+});
 var mapToFn = (map) => {
-  return mapper()(map);
+  return mapper(DEFAULT_ONE_TO_MANY_MAPPING)(map);
 };
 var mapToDict = {
-  config: (c = { input: "req", output: "opt", direction: "I -> O[]" }) => ({
-    map(map) {
-      return mapper(c)(map);
-    }
-  })
+  config(config) {
+    const c = { ...DEFAULT_ONE_TO_MANY_MAPPING, ...config };
+    return setMapper(c, DEFAULT_ONE_TO_MANY_MAPPING);
+  },
+  oneToOne(config) {
+    const c = { ...DEFAULT_ONE_TO_ONE_MAPPING, ...config };
+    return setMapper(c, DEFAULT_ONE_TO_ONE_MAPPING);
+  },
+  manyToOne(config) {
+    const c = { ...DEFAULT_MANY_TO_ONE_MAPPING, ...config };
+    return setMapper(c, DEFAULT_MANY_TO_ONE_MAPPING);
+  },
+  oneToMany(config) {
+    const c = { ...DEFAULT_ONE_TO_MANY_MAPPING, ...config };
+    return setMapper(c, DEFAULT_ONE_TO_MANY_MAPPING);
+  }
 };
 var mapTo = createFnWithProps(mapToFn, mapToDict);
 
@@ -783,9 +820,12 @@ function Model(name) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Configurator,
+  DEFAULT_MANY_TO_ONE_MAPPING,
+  DEFAULT_ONE_TO_MANY_MAPPING,
+  DEFAULT_ONE_TO_ONE_MAPPING,
   ExplicitFunction,
   FluentConfigurator,
-  MapDirection,
+  MapCardinality,
   Model,
   MutationIdentity,
   and,

package/dist/index.mjs

@@ -42,12 +42,12 @@ var valueTypes = {
 };
 
 // src/types/dictionary/MapTo.ts
-var MapDirection = /* @__PURE__ */ ((MapDirection2) => {
-  MapDirection2["OneToMany"] = "I -> O[]";
-  MapDirection2["OneToOne"] = "I -> O";
-  MapDirection2["ManyToOne"] = "I[] -> O";
-  return MapDirection2;
-})(MapDirection || {});
+var MapCardinality = /* @__PURE__ */ ((MapCardinality2) => {
+  MapCardinality2["OneToMany"] = "I -> O[]";
+  MapCardinality2["OneToOne"] = "I -> O";
+  MapCardinality2["ManyToOne"] = "I[] -> O";
+  return MapCardinality2;
+})(MapCardinality || {});
 
 // src/utility/keys.ts
 function keys(obj, ...without) {
@@ -502,32 +502,66 @@ function mapValues(obj, valueMapper) {
 }
 
 // src/utility/dictionary/mapTo.ts
-var mapper = (config = {}) => (map) => {
-  config = {
-    input: "req",
-    output: "opt",
-    direction: "I -> O[]",
-    ...config
-  };
-  const fn = (source) => {
-    const isArray2 = config.direction === "I -> O[]" && Array.isArray(source) ? true : config.direction === "I[] -> O" && Array.isArray(source) && Array.isArray(source[0]) ? true : false;
+var toFinalizedConfig = (config) => {
+  return { ...config, finalized: true };
+};
+var DEFAULT_ONE_TO_MANY_MAPPING = toFinalizedConfig({
+  input: "req",
+  output: "opt",
+  cardinality: "I -> O[]"
+});
+var DEFAULT_ONE_TO_ONE_MAPPING = toFinalizedConfig({
+  input: "req",
+  output: "req",
+  cardinality: "I -> O"
+});
+var DEFAULT_MANY_TO_ONE_MAPPING = toFinalizedConfig({
+  input: "req",
+  output: "req",
+  cardinality: "I[] -> O"
+});
+var mapper = (config) => (map) => {
+  return (source) => {
+    const isArray2 = config.cardinality === "I -> O[]" && Array.isArray(source) ? true : config.cardinality === "I[] -> O" && Array.isArray(source) && Array.isArray(source[0]) ? true : false;
     if (isArray2) {
       return source.flatMap(map);
     } else {
       return map(source);
     }
   };
-  return fn;
 };
+var setMapper = (config = { input: void 0, output: void 0, cardinality: void 0 }, defaultValue) => ({
+  map: (source) => {
+    const c = {
+      ...defaultValue,
+      ...config
+    };
+    return mapper(c)(source);
+  },
+  input: (config == null ? void 0 : config.input) || defaultValue.input,
+  output: (config == null ? void 0 : config.output) || defaultValue.output,
+  cardinality: (config == null ? void 0 : config.cardinality) || defaultValue.cardinality
+});
 var mapToFn = (map) => {
-  return mapper()(map);
+  return mapper(DEFAULT_ONE_TO_MANY_MAPPING)(map);
 };
 var mapToDict = {
-  config: (c = { input: "req", output: "opt", direction: "I -> O[]" }) => ({
-    map(map) {
-      return mapper(c)(map);
-    }
-  })
+  config(config) {
+    const c = { ...DEFAULT_ONE_TO_MANY_MAPPING, ...config };
+    return setMapper(c, DEFAULT_ONE_TO_MANY_MAPPING);
+  },
+  oneToOne(config) {
+    const c = { ...DEFAULT_ONE_TO_ONE_MAPPING, ...config };
+    return setMapper(c, DEFAULT_ONE_TO_ONE_MAPPING);
+  },
+  manyToOne(config) {
+    const c = { ...DEFAULT_MANY_TO_ONE_MAPPING, ...config };
+    return setMapper(c, DEFAULT_MANY_TO_ONE_MAPPING);
+  },
+  oneToMany(config) {
+    const c = { ...DEFAULT_ONE_TO_MANY_MAPPING, ...config };
+    return setMapper(c, DEFAULT_ONE_TO_MANY_MAPPING);
+  }
 };
 var mapTo = createFnWithProps(mapToFn, mapToDict);
 
@@ -694,9 +728,12 @@ function Model(name) {
 }
 export {
   Configurator,
+  DEFAULT_MANY_TO_ONE_MAPPING,
+  DEFAULT_ONE_TO_MANY_MAPPING,
+  DEFAULT_ONE_TO_ONE_MAPPING,
   ExplicitFunction,
   FluentConfigurator,
-  MapDirection,
+  MapCardinality,
   Model,
   MutationIdentity,
   and,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inferred-types",
-  "version": "0.27.0",
+  "version": "0.28.2",
   "description": "Functions which provide useful type inference on TS projects",
   "license": "MIT",
   "author": "Ken Snyder<ken@ken.net>",

package/src/types/Mutable.ts

@@ -1,6 +1,8 @@
+import { IsObject } from "./TypeInfo";
+
 /**
  * Makes a readonly structure mutable
  */
 export type Mutable<T> = {
-  -readonly [K in keyof T]: T[K];
+  -readonly [K in keyof T]: IsObject<T[K]> extends true ? Mutable<T[K]> : T[K];
 };

package/src/types/TypeInfo/Extends.ts

@@ -0,0 +1,14 @@
+/**
+ * **Extends**
+ *
+ * Boolean type utility which returns `true` if `E` _extends_ `T`.
+ */
+export type Extends<E, T> = E extends T ? true : false;
+
+/**
+ * **IfExtends**
+ *
+ * Branching type utility which returns type `IF` when `E` _extends_ `T`; otherwise
+ * it will return the type `ELSE`.
+ */
+export type IfExtends<E, T, IF, ELSE> = Extends<E, T> extends true ? IF : ELSE;

package/src/types/TypeInfo/IsBooleanLiteral.ts

@@ -5,3 +5,12 @@
  * just the wider _boolean_ type.
  */
 export type IsBooleanLiteral<T extends boolean> = boolean extends T ? false : true;
+
+/**
+ * **IfBooleanLiteral**
+ *
+ * Branch utility which returns `IF` type when `T` is a boolean literal and `ELSE` otherwise
+ */
+export type IfBooleanLiteral<T extends boolean, IF, ELSE> = IsBooleanLiteral<T> extends true
+  ? IF
+  : ELSE;

package/src/types/TypeInfo/IsLiteral.ts

@@ -11,10 +11,44 @@ import { IsNumericLiteral } from "./IsNumericLiteral";
  * string, number, or boolean -- is a _literal_ value of that type (true) or
  * the more generic wide type (false).
  */
-export type IsLiteral<T extends string | number | boolean> = [T] extends [string]
+export type IsLiteral<T> = [T] extends [string]
   ? IsStringLiteral<T>
   : [T] extends [boolean]
   ? IsBooleanLiteral<T>
   : [T] extends [number]
   ? IsNumericLiteral<T>
-  : never;
+  : false;
+
+/**
+ * **IsOptionalLiteral**
+ *
+ * Type utility which returns true/false if the value passed -- a form of a
+ * string, number, or boolean -- is a _literal_ value of that type (true) or
+ * the more generic wide type (false).
+ *
+ * This type also strips off _undefined_ from any possible union type to evaluate
+ * to `true` even when a literal value is in union with _undefined_. If you don't
+ * want to test for the union with _undefined_ use the `IsOptional` utility instead.
+ */
+export type IsOptionalLiteral<T> = [Exclude<T, undefined>] extends [string]
+  ? IsStringLiteral<Exclude<T, undefined>>
+  : [Exclude<T, undefined>] extends [boolean]
+  ? IsBooleanLiteral<Exclude<T, undefined>>
+  : [Exclude<T, undefined>] extends [number]
+  ? IsNumericLiteral<Exclude<T, undefined>>
+  : false;
+
+/**
+ * **IfLiteral**
+ *
+ * Branch type utility with return `IF` when `T` is a _literal_ value and `ELSE` otherwise
+ */
+export type IfLiteral<T, IF, ELSE> = IsLiteral<T> extends true ? IF : ELSE;
+
+/**
+ * **IfOptionalLiteral**
+ *
+ * Branch type utility with return `IF` when `T` is a _literal_ value (with possibly
+ * the inclusion of _undefined_); otherwise returns the type `ELSE`
+ */
+export type IfOptionalLiteral<T, IF, ELSE> = IsOptionalLiteral<T> extends true ? IF : ELSE;

package/src/types/TypeInfo/IsNumericLiteral.ts

@@ -5,3 +5,12 @@
  * just the _number_ type.
  */
 export type IsNumericLiteral<T extends number> = number extends T ? false : true;
+
+/**
+ * **IfNumericLiteral**
+ *
+ * Branch utility which returns `IF` type when `T` is a numeric literal and `ELSE` otherwise
+ */
+export type IfNumericLiteral<T extends number, IF, ELSE> = IsNumericLiteral<T> extends true
+  ? IF
+  : ELSE;

package/src/types/TypeInfo/IsObject.ts

@@ -0,0 +1,27 @@
+import { FunctionType } from "../FunctionType";
+import { Mutable } from "../Mutable";
+
+/**
+ * **IsObject**
+ *
+ * Boolean type utility used to check whether a type `T` is an object
+ */
+export type IsObject<T> = Mutable<T> extends Record<string, any>
+  ? // an object of some type
+    T extends FunctionType
+    ? // when a function with props is found, categorize as a function not object
+      false
+    : Mutable<T> extends any[]
+    ? // Array's are objects too but in our narrower definition we're looking only
+      // dictionary based arrays.
+      false
+    : true
+  : false;
+
+/**
+ * **IfObject**
+ *
+ * Branch type utility with return `IF` when `T` extends an object type
+ * and `ELSE` otherwise
+ */
+export type IfObject<T, IF, ELSE> = IsObject<T> extends true ? IF : ELSE;

package/src/types/TypeInfo/IsScalar.ts

@@ -0,0 +1,14 @@
+export type IsScalar<T> = [T] extends [string]
+  ? true
+  : [T] extends [number]
+  ? true
+  : [T] extends [boolean]
+  ? true
+  : false;
+
+/**
+ * **IfScalar**
+ *
+ * Branch type utility which returns `IF` when `T` is a scalar value and `ELSE` otherwise
+ */
+export type IfScalar<T, IF, ELSE> = IsScalar<T> extends true ? IF : ELSE;

package/src/types/TypeInfo/IsStringLiteral.ts

@@ -5,3 +5,12 @@
  * just the _string_ type.
  */
 export type IsStringLiteral<T extends string> = string extends T ? false : true;
+
+/**
+ * **IfStringLiteral**
+ *
+ * Branch utility which returns `IF` type when `T` is a string literal and `ELSE` otherwise
+ */
+export type IfStringLiteral<T extends string, IF, ELSE> = IsStringLiteral<T> extends true
+  ? IF
+  : ELSE;

package/src/types/TypeInfo/IsUndefined.ts

@@ -0,0 +1,14 @@
+/**
+ * **IsUndefined**
+ *
+ * Boolean type utility returns `true` if `T` is undefined; `false` otherwise
+ */
+export type IsUndefined<T> = T extends undefined ? true : false;
+
+/**
+ * **IfUndefined**
+ *
+ * Branch utility which returns `IF` type when `T` is an _undefined_ value
+ * otherwise returns `ELSE` type
+ */
+export type IfUndefined<T, IF, ELSE> = IsUndefined<T> extends true ? IF : ELSE;

package/src/types/TypeInfo/TypeDefault.ts

@@ -0,0 +1,58 @@
+import { IsObject } from "src/types/TypeInfo";
+import { SimplifyObject } from "../SimplifyObject";
+import { IfExtends } from "./Extends";
+import { IfOptionalLiteral } from "./IsLiteral";
+import { IfUndefined } from "./IsUndefined";
+
+/**
+ * **TypeDefault**
+ *
+ * A type utility designed to help maintain strong and narrow types where
+ * you have a value `T` which _might_ be **undefined** and a type `D` which
+ * defines all the _default_ type for `T`.
+ *
+ * - In all cases we compare first whether `T` is undefined and replace it's
+ * type with `D` 1-for-1 if it is
+ * - To address a larger set of use cases, when `D` _extends_ an object we will
+ * compare each property of `D` against `T`
+ * ```ts
+ * type I = { foo?: "foo" |  undefined; bar?: 42 | 53 | undefined };
+ * type D = { foo: "foo"; bar: 53 };
+ * type DF = TypeDefault<I,D>; // `D`
+ * const i = { foo: undefined, bar: 99 } as const;
+ * type DF2 = TypeDefault<typeof i, D>; // `{ foo: "foo"; bar: 99 }`
+ * ```
+ */
+export type TypeDefault<T, D> = //
+  IsObject<D> extends true //
+    ? IsObject<T> extends true
+      ? // both T and D are objects; start by iterating over D
+        SimplifyObject<{
+          [K in keyof D]: K extends keyof T
+            ? // both D[T] and K[T] are present
+              TypeDefault<T[K], D[K]>
+            : // only D[K] present
+              D[K];
+        }>
+      : // T is not an object, but D is
+        IfUndefined<
+          T, // check if T is undefined
+          D, // use D as the type
+          Exclude<T, undefined> // use T as the type but remove "undefined"
+        >
+    : // neither D or T is an object
+      IfUndefined<
+        T, // check whether is T is undefined
+        D, // assign to D if it is
+        IfOptionalLiteral<
+          T, // if T is a literal
+          IfExtends<
+            D,
+            T,
+            D, // use D since it extends the value of T
+            Exclude<T, undefined> // use T's literal value minus "undefined"
+          >,
+          // T is a wide type
+          Exclude<T, undefined>
+        >
+      >;

package/src/types/TypeInfo/index.ts

@@ -1,5 +1,9 @@
 export * from "./Includes";
 export * from "./IsBooleanLiteral";
 export * from "./IsNumericLiteral";
+export * from "./IsScalar";
 export * from "./IsStringLiteral";
 export * from "./IsLiteral";
+export * from "./Extends";
+export * from "./TypeDefault";
+export * from "./IsObject";