inferred-types 0.28.5 → 0.30.0

package/dist/index.d.ts

@@ -807,7 +807,7 @@ declare const mapToDict: MapperApi;
  * const many2one = mapTo.manyToOne().map<I,O>( ... );
  * ```
  */
-declare const mapTo: (<I, O>(map: (source: I) => O[]) => <S extends I | I[]>(source: S) => S extends I[] ? O[] : O[] | null) & MapperApi;
+declare const mapTo: (<I, O>(map: (source: I) => O[]) => Mapper<I, O, FinalizedMapConfig<"req", "I -> O[]", "opt">>) & MapperApi;
 
 /**
  * Expresses relationship between inputs/outputs:
@@ -873,7 +873,7 @@ declare type MapCardinalityConfig<IR extends OptRequired | undefined, OR extends
  * method which allows the user configure the specifics of the mapping.
  */
 declare type ConfiguredMap<C extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>> = {
-    map: <I, O>(map: MapTo<I, O, C>) => MapFn<I, O, C>;
+    map: <I, O>(map: MapTo<I, O, C>) => Mapper<I, O, C>;
     input: MapIR<C>;
     cardinality: MapCard<C>;
     output: MapOR<C>;
@@ -970,6 +970,25 @@ declare type MapFnInput<I, IR extends OptRequired, D extends MapCardinalityIllus
  *    ```
  */
 declare type MapFn<I, O, C extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>> = MapIR<C> extends "opt" ? <S extends MapFnInput<I, MapIR<C>, MapCard<C>>>(source?: S) => MapFnOutput<I, O, S, MapOR<C>, MapCard<C>> : <S extends MapFnInput<I, MapIR<C>, MapCard<C>>>(source: S) => MapFnOutput<I, O, S, MapOR<C>, MapCard<C>>;
+/**
+ * **Mapper**
+ *
+ * A fully configured _mapper_ stemming from the **mapTo()** utility. It is both a mapping
+ * function and a dictionary which describes the mapper's properties.
+ * ```ts
+ * const m = mapTo.oneToOne().map( ... );
+ * const mapped = m(inputs);
+ * const mappedOver = inputs.map(m);
+ * ```
+ */
+declare type Mapper<I, O, C extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>> = {
+    input: MapIR<C>;
+    output: MapOR<C>;
+    cardinality: MapCard<C>;
+    debug: boolean | string;
+    inputType: I;
+    outputType: O;
+} & MapFn<I, O, C>;
 
 /**
  * Given a dictionary of type `<T>`, this utility function will
@@ -2260,4 +2279,4 @@ interface IFluentConfigurator<C> {
  */
 declare function FluentConfigurator<I>(initial?: I): IFluentConfigurator<{}>;
 
-export { AllCaps, Alpha, AlphaNumeric, Api, ApiFunction, ApiValue, AppendToDictionary, AppendToObject, ArrConcat, Array$1 as Array, ArrayConverter, AsArray, AsFinalizedConfig, AssertExtends, Bracket, Break, CamelCase, CapitalizeWords, Cardinality, Cardinality0, Cardinality1, CardinalityExplicit, CardinalityFilter0, CardinalityFilter1, CardinalityIn, CardinalityInput, CardinalityNode, CardinalityOut, CardinalityTuple, ClosingBracket, Condition, ConditionFilter, Configurator, ConfiguredMap, Constructor, DEFAULT_MANY_TO_ONE_MAPPING, DEFAULT_ONE_TO_MANY_MAPPING, DEFAULT_ONE_TO_ONE_MAPPING, DashToSnake, DashUppercase, Dasherize, DecomposeMapConfig, DefaultManyToOneMapping, DefaultOneToManyMapping, DefaultOneToOneMapping, DefinePropertiesApi, DictArrApi, DictArray, DictArrayFilterCallback, DictArrayKv, DictChangeValue, DictFromKv, DictKvTuple, DictPartialApplication, DictPrependWithFn, DictReturnValues, DynamicRule, DynamicRuleSet, Email, EnumValues, ExpandRecursively, ExpectExtends, ExplicitFunction, Extends, ExtendsClause, ExtendsNarrowlyClause, FilterContains, FilterDefn, FilterEnds, FilterEquals, FilterFn, FilterGreaterThan, FilterIs, FilterLessThan, FilterNotEqual, FilterStarts, FinalReturn, FinalizedMapConfig, First, FirstKey, FirstKeyValue, FirstOfEach, FluentConfigurator, FluentFunction, FromDictArray, FunctionType, GeneralDictionary, Get, HasUppercase, IConfigurator, IFluentConfigurator, If, IfBooleanLiteral, IfExtends, IfExtendsThen, IfLiteral, IfNumericLiteral, IfObject, IfOptionalLiteral, IfScalar, IfStringLiteral, Include, Includes, IntersectingKeys, IsArray, IsBoolean, IsBooleanLiteral, IsCapitalized, IsFalse, IsFunction, IsLiteral, IsNumericLiteral, IsObject, IsOptionalLiteral, IsScalar, IsString, IsStringLiteral, IsTrue, KebabCase, KeyValue, KeyedRecord, Keys, KeysWithValue, KvFrom, KvTuple, LastInUnion, LeftWhitespace, Length, LogicFunction, LogicalCombinator, LowerAllCaps, LowerAlpha, ManyToMany, ManyToOne, ManyToZero, MapCard, MapCardinality, MapCardinalityIllustrated, MapConfig, MapFn, MapFnInput, MapFnOutput, MapIR, MapInput, MapOR, MapOutput, MapTo, MapperApi, MaybeFalse, MaybeTrue, Model, Mutable, MutableProps, MutationFunction, MutationIdentity, Narrowable, NonAlpha, NonNumericKeys, NonStringKeys, Not, NotFilter, Numeric, NumericFilter, NumericKeys, NumericString, ObjectType, OneToMany, OneToOne, OneToZero, Opaque, OpeningBracket, OptRequired, OptionalKeys, OptionalProps, Parenthesis, PascalCase, Pluralize, PrivateKey, PrivateKeys, PublicKeys, Punctuation, PureFluentApi, Replace, RequireProps, RequiredKeys, RequiredProps, Retain, RightWhitespace, RuleDefinition, RuntimeProp, RuntimeType, SameKeys, SecondOfEach, SimplifyObject, SnakeCase, SpecialCharacters, StringDelimiter, StringFilter, StringKeys, StringLength, ToFluent, Transformer, Trim, TrimLeft, TrimRight, TupleToUnion, Type, TypeApi, TypeCondition, TypeDefault, TypeDefinition, TypeGuard, TypeOptions, UndefinedArrayIsUnknown, UndefinedTreatment, UndefinedValue, UnionToIntersection, UnionToTuple, UniqueDictionary, UniqueForProp, Uniqueness, UnwrapNot, UpperAlpha, ValueTuple, ValueTypeFunc, ValueTypes, Where, WhereNot, Whitespace, Widen, WithNumericKeys, WithStringKeys, WithValue, ZeroToMany, ZeroToOne, ZeroToZero, ZipCode, and, api, arrayToKeyLookup, arrayToObject, asArray, condition, createFnWithProps, createMutationFunction, defineProperties, defineType, dictArr, dictToKv, dictionaryTransform, entries, filter, filterDictArray, fnWithProps, groupBy, idLiteral, idTypeGuard, identity, ifTypeOf, isArray, isBoolean, isFalse, isFunction, isNotFilter, isNull, isNumber, isNumericFilter, isObject, isString, isSymbol, isTrue, isType, isUndefined, keys, kindLiteral, kv, kvToDict, literal, mapTo, mapToDict, mapToFn, mapValues, nameLiteral, not, or, randomString, readonlyFnWithProps, ruleSet, strArrayToDict, type, typeApi, uuid, valueTypes, withValue };
+export { AllCaps, Alpha, AlphaNumeric, Api, ApiFunction, ApiValue, AppendToDictionary, AppendToObject, ArrConcat, Array$1 as Array, ArrayConverter, AsArray, AsFinalizedConfig, AssertExtends, Bracket, Break, CamelCase, CapitalizeWords, Cardinality, Cardinality0, Cardinality1, CardinalityExplicit, CardinalityFilter0, CardinalityFilter1, CardinalityIn, CardinalityInput, CardinalityNode, CardinalityOut, CardinalityTuple, ClosingBracket, Condition, ConditionFilter, Configurator, ConfiguredMap, Constructor, DEFAULT_MANY_TO_ONE_MAPPING, DEFAULT_ONE_TO_MANY_MAPPING, DEFAULT_ONE_TO_ONE_MAPPING, DashToSnake, DashUppercase, Dasherize, DecomposeMapConfig, DefaultManyToOneMapping, DefaultOneToManyMapping, DefaultOneToOneMapping, DefinePropertiesApi, DictArrApi, DictArray, DictArrayFilterCallback, DictArrayKv, DictChangeValue, DictFromKv, DictKvTuple, DictPartialApplication, DictPrependWithFn, DictReturnValues, DynamicRule, DynamicRuleSet, Email, EnumValues, ExpandRecursively, ExpectExtends, ExplicitFunction, Extends, ExtendsClause, ExtendsNarrowlyClause, FilterContains, FilterDefn, FilterEnds, FilterEquals, FilterFn, FilterGreaterThan, FilterIs, FilterLessThan, FilterNotEqual, FilterStarts, FinalReturn, FinalizedMapConfig, First, FirstKey, FirstKeyValue, FirstOfEach, FluentConfigurator, FluentFunction, FromDictArray, FunctionType, GeneralDictionary, Get, HasUppercase, IConfigurator, IFluentConfigurator, If, IfBooleanLiteral, IfExtends, IfExtendsThen, IfLiteral, IfNumericLiteral, IfObject, IfOptionalLiteral, IfScalar, IfStringLiteral, Include, Includes, IntersectingKeys, IsArray, IsBoolean, IsBooleanLiteral, IsCapitalized, IsFalse, IsFunction, IsLiteral, IsNumericLiteral, IsObject, IsOptionalLiteral, IsScalar, IsString, IsStringLiteral, IsTrue, KebabCase, KeyValue, KeyedRecord, Keys, KeysWithValue, KvFrom, KvTuple, LastInUnion, LeftWhitespace, Length, LogicFunction, LogicalCombinator, LowerAllCaps, LowerAlpha, ManyToMany, ManyToOne, ManyToZero, MapCard, MapCardinality, MapCardinalityIllustrated, MapConfig, MapFn, MapFnInput, MapFnOutput, MapIR, MapInput, MapOR, MapOutput, MapTo, Mapper, MapperApi, MaybeFalse, MaybeTrue, Model, Mutable, MutableProps, MutationFunction, MutationIdentity, Narrowable, NonAlpha, NonNumericKeys, NonStringKeys, Not, NotFilter, Numeric, NumericFilter, NumericKeys, NumericString, ObjectType, OneToMany, OneToOne, OneToZero, Opaque, OpeningBracket, OptRequired, OptionalKeys, OptionalProps, Parenthesis, PascalCase, Pluralize, PrivateKey, PrivateKeys, PublicKeys, Punctuation, PureFluentApi, Replace, RequireProps, RequiredKeys, RequiredProps, Retain, RightWhitespace, RuleDefinition, RuntimeProp, RuntimeType, SameKeys, SecondOfEach, SimplifyObject, SnakeCase, SpecialCharacters, StringDelimiter, StringFilter, StringKeys, StringLength, ToFluent, Transformer, Trim, TrimLeft, TrimRight, TupleToUnion, Type, TypeApi, TypeCondition, TypeDefault, TypeDefinition, TypeGuard, TypeOptions, UndefinedArrayIsUnknown, UndefinedTreatment, UndefinedValue, UnionToIntersection, UnionToTuple, UniqueDictionary, UniqueForProp, Uniqueness, UnwrapNot, UpperAlpha, ValueTuple, ValueTypeFunc, ValueTypes, Where, WhereNot, Whitespace, Widen, WithNumericKeys, WithStringKeys, WithValue, ZeroToMany, ZeroToOne, ZeroToZero, ZipCode, and, api, arrayToKeyLookup, arrayToObject, asArray, condition, createFnWithProps, createMutationFunction, defineProperties, defineType, dictArr, dictToKv, dictionaryTransform, entries, filter, filterDictArray, fnWithProps, groupBy, idLiteral, idTypeGuard, identity, ifTypeOf, isArray, isBoolean, isFalse, isFunction, isNotFilter, isNull, isNumber, isNumericFilter, isObject, isString, isSymbol, isTrue, isType, isUndefined, keys, kindLiteral, kv, kvToDict, literal, mapTo, mapToDict, mapToFn, mapValues, nameLiteral, not, or, randomString, readonlyFnWithProps, ruleSet, strArrayToDict, type, typeApi, uuid, valueTypes, withValue };

package/dist/index.js

@@ -627,7 +627,7 @@ And produced: ${JSON.stringify(
   }
 };
 var mapper = (config) => (map) => {
-  return (source) => {
+  const fn = (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) {
       const output = source.flatMap(map);
@@ -639,6 +639,14 @@ var mapper = (config) => (map) => {
       return output;
     }
   };
+  return createFnWithProps(fn, {
+    input: config.input,
+    output: config.output,
+    cardinality: config.cardinality,
+    debug: config.debug,
+    inputType: {},
+    outputType: {}
+  });
 };
 var setMapper = (config = { input: void 0, output: void 0, cardinality: void 0 }, defaultValue) => ({
   map: (source) => {

package/dist/index.mjs

@@ -536,7 +536,7 @@ And produced: ${JSON.stringify(
   }
 };
 var mapper = (config) => (map) => {
-  return (source) => {
+  const fn = (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) {
       const output = source.flatMap(map);
@@ -548,6 +548,14 @@ var mapper = (config) => (map) => {
       return output;
     }
   };
+  return createFnWithProps(fn, {
+    input: config.input,
+    output: config.output,
+    cardinality: config.cardinality,
+    debug: config.debug,
+    inputType: {},
+    outputType: {}
+  });
 };
 var setMapper = (config = { input: void 0, output: void 0, cardinality: void 0 }, defaultValue) => ({
   map: (source) => {

package/package.json

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

package/src/types/dictionary/MapTo.ts

@@ -87,7 +87,7 @@ type MapCardinalityConfig<
 export type ConfiguredMap<
   C extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>
 > = {
-  map: <I, O>(map: MapTo<I, O, C>) => MapFn<I, O, C>;
+  map: <I, O>(map: MapTo<I, O, C>) => Mapper<I, O, C>;
   input: MapIR<C>;
   cardinality: MapCard<C>;
   output: MapOR<C>;
@@ -361,3 +361,27 @@ export type MapFn<
   : <S extends MapFnInput<I, MapIR<C>, MapCard<C>>>(
       source: S
     ) => MapFnOutput<I, O, S, MapOR<C>, MapCard<C>>;
+
+/**
+ * **Mapper**
+ *
+ * A fully configured _mapper_ stemming from the **mapTo()** utility. It is both a mapping
+ * function and a dictionary which describes the mapper's properties.
+ * ```ts
+ * const m = mapTo.oneToOne().map( ... );
+ * const mapped = m(inputs);
+ * const mappedOver = inputs.map(m);
+ * ```
+ */
+export type Mapper<
+  I,
+  O,
+  C extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>
+> = {
+  input: MapIR<C>;
+  output: MapOR<C>;
+  cardinality: MapCard<C>;
+  debug: boolean | string;
+  inputType: I;
+  outputType: O;
+} & MapFn<I, O, C>;

package/src/utility/dictionary/mapTo.ts

@@ -1,16 +1,13 @@
 import {
   FinalizedMapConfig,
   MapCardinalityIllustrated,
-  MapFnInput,
   MapperApi,
   MapTo,
   AsFinalizedConfig,
   MapConfig,
   ConfiguredMap,
-  MapFnOutput,
-  MapIR,
-  MapCard,
-  MapOR,
+  Mapper,
+  MapFn,
 } from "src/types/dictionary";
 import { OptRequired } from "src/types/literal-unions";
 import { createFnWithProps } from "../createFnWithProps";
@@ -69,11 +66,18 @@ const debugMsg = <C extends FinalizedMapConfig<any, any, any>>(
  * The single implementation for all mapping
  */
 const mapper =
-  <C extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>>(config: C) =>
-  <I, O>(map: MapTo<I, O, C>) => {
-    return <S extends MapFnInput<I, MapIR<C>, MapCard<C>>>(
-      source?: S
-    ): MapFnOutput<I, O, S, MapOR<C>, MapCard<C>> => {
+  <
+    //
+    C extends FinalizedMapConfig<
+      OptRequired, //
+      MapCardinalityIllustrated,
+      OptRequired
+    >
+  >(
+    config: C
+  ) =>
+  <I, O>(map: MapTo<I, O, C>): Mapper<I, O, C> => {
+    const fn: MapFn<I, O, C> = <S>(source: S) => {
       /**
        * Determine whether input is an array; this will be true
        */
@@ -93,18 +97,28 @@ const mapper =
         // item and this approach achieves this.
         // TODO: we should check that the approach below doesn't work for M:1 here
         // as well
-        const output = (source as any).flatMap(map) as MapFnOutput<I, O, S, MapOR<C>, MapCard<C>>;
+        const output = (source as any).flatMap(map);
         debugMsg(config, source, output);
 
         return output;
       } else {
         // receive _all_ inputs provided as pass into ; this is just a single input unless the
         // cardinality is
-        const output = map(source as any) as MapFnOutput<I, O, S, MapOR<C>, MapCard<C>>;
+        const output = map(source as any);
         debugMsg(config, source, output);
+
         return output;
       }
     };
+
+    return createFnWithProps(fn, {
+      input: config.input,
+      output: config.output,
+      cardinality: config.cardinality,
+      debug: config.debug,
+      inputType: {} as I,
+      outputType: {} as O,
+    });
   };
 
 /**

package/tests/dictionary/mapTo.test.ts

@@ -6,6 +6,7 @@ import {
   AsFinalizedConfig,
   MapConfig,
   ConfiguredMap,
+  Mapper,
 } from "src/types/dictionary";
 import { describe, expect, it } from "vitest";
 import type { Expect, Equal } from "@type-challenges/utils";
@@ -169,37 +170,21 @@ describe("MapTo<I,O> and MapToFn<I,O>", () => {
       // map() function's parameters (unknown is I)
       Expect<Equal<[map: (source: unknown) => unknown], M1P>>,
       // map() function's return value
-      Expect<
-        Equal<<S extends unknown>(source: S) => S extends unknown[] ? unknown[] : unknown, M1R>
-      >,
+      Expect<Equal<Mapper<unknown, unknown, FinalizedMapConfig<"req", "I -> O", "opt">>, M1R>>,
 
       // merged configuration is same as default for M:1
       Expect<Equal<C2, FinalizedMapConfig<"req", "I[] -> O", "req">>>,
       // map() function's parameters (unknown is I)
       Expect<Equal<[map: (source: unknown[]) => unknown], M2P>>,
       // map() function's return value
-      Expect<
-        Equal<
-          <S extends unknown[] | unknown[][]>(
-            source: S
-          ) => S extends unknown[][] ? [unknown, ...unknown[]] : unknown,
-          M2R
-        >
-      >,
+      Expect<Equal<Mapper<unknown, unknown, FinalizedMapConfig<"req", "I[] -> O", "req">>, M2R>>,
 
       // merged configuration should be M:1 default with an "opt" for output
       Expect<Equal<C3, FinalizedMapConfig<"req", "I[] -> O", "opt">>>,
       // map() function's parameters (unknown is I)
       Expect<Equal<[map: (source: unknown[]) => unknown | null], M3P>>,
       // map() function's return value
-      Expect<
-        Equal<
-          <S extends unknown[] | unknown[][]>(
-            source: S
-          ) => S extends unknown[][] ? unknown[] : unknown,
-          M3R
-        >
-      >
+      Expect<Equal<Mapper<unknown, unknown, FinalizedMapConfig<"req", "I[] -> O", "opt">>, M3R>>
     ];
 
     const cases: cases = [true, true, true, true, true, true, true, true, true];
@@ -269,6 +254,22 @@ describe("mapTo() utility function", () => {
     expect(c1.cardinality).toBe(MapCardinality.OneToMany);
   });
 
+  it("Mapper<I,O,C>", () => {
+    const m0 = mapTo.oneToOne();
+    const m1 = m0.map<I, I>((i) => i);
+
+    expect(m1.input).toBe("req");
+    expect(m1.output).toBe("req");
+    expect(m1.cardinality).toBe("I -> O");
+    expect(m1(i)).toEqual(i);
+
+    type cases = [
+      Expect<Equal<typeof m1["inputType"], I>>, //
+      Expect<Equal<typeof m1["outputType"], I>> //
+    ];
+    const cases: cases = [true, true];
+  });
+
   it("M:1 conversion", () => {
     const m = mapTo
       .config({
@@ -314,9 +315,13 @@ describe("mapTo() utility function", () => {
       .config({ output: "req", cardinality: "I -> O[]" })
       .map<I, O>((i) => [{ title: i.title, count: i.products.length }]);
     const o = m([i, i2]);
+    type RT = ReturnType<typeof m>;
 
     expect(o.length).toBe(2);
     o.map((item) => expect("title" in item).toBeTruthy());
+
+    type cases = [Expect<Equal<RT, O[] | [O, ...O[]]>>];
+    const cases: cases = [true];
   });
 
   it("1:M conversion with filtering", () => {