inferred-types 0.23.4 → 0.24.1

package/dist/index.d.ts

@@ -667,20 +667,22 @@ declare type SpecialCharacters = "@" | "~" | "^" | "#" | "&" | "*";
 declare type NonAlpha = Whitespace | Punctuation | NumericString | Bracket | SpecialCharacters;
 
 /**
- * Extracts the _required_ keys in the object's type
+ * Extracts the _required_ keys in the object's type. You also may
+ * optionally filter by the _value_ of the key.
  */
-declare type RequiredKeys<T extends object> = {
+declare type RequiredKeys<T extends object, V extends any = any> = {
     [K in keyof T]-?: {} extends {
         [P in K]: T[K];
-    } ? never : K;
+    } ? never : T[K] extends V ? K : never;
 }[keyof T];
 /**
- * Extracts the _optional_ keys in the object's type
+ * Extracts the _optional_ keys in the object's type. You also may
+ * optionally filter by the _value_ of the key.
  */
-declare type OptionalKeys<T extends object> = {
+declare type OptionalKeys<T extends object, V extends any = any> = {
     [K in keyof T]-?: {} extends {
         [P in K]: T[K];
-    } ? K : never;
+    } ? V extends T[K] ? K : never : never;
 }[keyof T];
 /**
  * The _keys_ on a given object `T` which have a literal value of `W`.
@@ -743,7 +745,7 @@ declare type RequiredProps<T extends object> = Pick<T, RequiredKeys<T>>;
  *
  * Reduces an object to only key/value pairs where the key is optional
  */
-declare type OptionalProps<T extends object> = Pick<T, RequiredKeys<T>>;
+declare type OptionalProps<T extends object> = Pick<T, OptionalKeys<T>>;
 /**
  * **WithValue**
  *
@@ -1320,6 +1322,8 @@ declare type FirstOfEach<T extends readonly any[][]> = T[number][0] extends T[nu
  */
 declare type TupleToUnion<T> = Mutable<T> extends any[] ? Mutable<T>[number] : never;
 
+declare type Widen<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T;
+
 /**
  * Typescript utility which receives `T` as shape which resembles `DictArray<D>`
  * and if the type `D` can be inferred it is returned.
@@ -1380,7 +1384,9 @@ declare const api: <N extends Narrowable, TPrivate extends Readonly<Record<any,
  * Passing in an array of strings, you are passed back a dictionary with
  * all the keys being the strings and values set to `true`.
  * ```ts
- * // { foo: true, bar: true }
+ * // { bar: true, bar: true } as const;
+ * const d - dictArr(arr);
+ *
  * const fooBar = arrayToKeyLookup("foo", "bar");
  * ```
  */
@@ -1408,6 +1414,29 @@ declare function defineProperties<T extends {}>(obj: T): DefinePropertiesApi<T>;
  */
 declare function dictionaryTransform<I extends object, O extends SameKeys<I>>(input: I, transform: Transformer<I, O>): O;
 
+interface Uniqueness<T> {
+    /** boolean flag to indicate whether the property was unique across all records */
+    isUnique: boolean;
+    /** the overall number of records which contained the property */
+    size: number;
+    /** specifies if undefined values were encountered for this property */
+    includedUndefined: boolean;
+    /** the unique values for the property across all records */
+    values: readonly T[];
+}
+declare type DictArrApi<T extends Record<string, Narrowable>, A extends readonly T[]> = {
+    length: number;
+    toLookup<PL extends RequiredKeys<T, string> & keyof T & string>(prop: PL): UniqueForProp<A, PL> extends string ? Record<UniqueForProp<A, PL>, T> : Record<string, T>;
+    sum<PS extends RequiredKeys<T, number> | OptionalKeys<T, number>>(prop: PS): number;
+    count<PC extends OptionalKeys<T>>(prop: PC): number;
+    unique<PU extends Keys<T> & keyof T>(prop: PU): Uniqueness<T[PU]>;
+};
+/**
+ * converts an array of objects to a dictionary with keys formed from a given property
+ * of the object and the value being the object itself.
+ */
+declare const dictArr: <T extends Record<string, Narrowable>>(...dicts: readonly T[]) => DictArrApi<T, readonly T[]>;
+
 /**
  * **entries**
  *
@@ -1741,4 +1770,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, AssertExtends, Bracket, Break, CamelCase, CapitalizeWords, ClosingBracket, Condition, Configurator, Constructor, DashToSnake, DashUppercase, Dasherize, DefinePropertiesApi, DictArray, DictArrayFilterCallback, DictArrayKv, DictChangeValue, DictFromKv, DictKvTuple, DictPartialApplication, DictPrependWithFn, DictReturnValues, DynamicRule, DynamicRuleSet, Email, EnumValues, ExpandRecursively, ExpectExtends, ExplicitFunction, ExtendsClause, ExtendsNarrowlyClause, Filter, FinalReturn, First, FirstKey, FirstKeyValue, FirstOfEach, FluentConfigurator, FluentFunction, FromDictArray, FunctionType, GeneralDictionary, Get, HasUppercase, IConfigurator, IFluentConfigurator, If, IfExtends, IfExtendsThen, Include, Includes, IsArray, IsBoolean, IsCapitalized, IsFalse, IsFunction, IsObject, IsString, IsTrue, KebabCase, KeyValue, KeyedRecord, Keys, KeysWithValue, KvFrom, KvTuple, LastInUnion, LeftWhitespace, Length, LowerAllCaps, LowerAlpha, MapTo, MaybeFalse, MaybeTrue, Model, Mutable, MutableProps, MutationFunction, MutationIdentity, Narrowable, NonAlpha, NonNumericKeys, NonStringKeys, Not, Numeric, NumericKeys, NumericString, ObjectType, Opaque, OpeningBracket, 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, StringKeys, StringLength, ToFluent, Transformer, Trim, TrimLeft, TrimRight, TupleToUnion, Type, TypeApi, TypeCondition, TypeDefinition, TypeGuard, TypeOptions, UnionToIntersection, UnionToTuple, UniqueDictionary, UniqueForProp, UpperAlpha, ValueTuple, ValueTypeFunc, ValueTypes, Where, WhereNot, Whitespace, WithNumericKeys, WithStringKeys, WithValue, ZipCode, and, api, arrayToKeyLookup, arrayToObject, condition, createFnWithProps, createMutationFunction, defineProperties, defineType, dictToKv, dictionaryTransform, entries, equals, filterDictArray, fnWithProps, greater, groupBy, idLiteral, idTypeGuard, identity, ifTypeOf, isArray, isBoolean, isFalse, isFunction, isNull, isNumber, isObject, isString, isSymbol, isTrue, isType, isUndefined, keys, kindLiteral, kv, kvToDict, less, literal, mapTo, mapValues, nameLiteral, 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, AssertExtends, Bracket, Break, CamelCase, CapitalizeWords, ClosingBracket, Condition, Configurator, Constructor, DashToSnake, DashUppercase, Dasherize, DefinePropertiesApi, DictArrApi, DictArray, DictArrayFilterCallback, DictArrayKv, DictChangeValue, DictFromKv, DictKvTuple, DictPartialApplication, DictPrependWithFn, DictReturnValues, DynamicRule, DynamicRuleSet, Email, EnumValues, ExpandRecursively, ExpectExtends, ExplicitFunction, ExtendsClause, ExtendsNarrowlyClause, Filter, FinalReturn, First, FirstKey, FirstKeyValue, FirstOfEach, FluentConfigurator, FluentFunction, FromDictArray, FunctionType, GeneralDictionary, Get, HasUppercase, IConfigurator, IFluentConfigurator, If, IfExtends, IfExtendsThen, Include, Includes, IsArray, IsBoolean, IsCapitalized, IsFalse, IsFunction, IsObject, IsString, IsTrue, KebabCase, KeyValue, KeyedRecord, Keys, KeysWithValue, KvFrom, KvTuple, LastInUnion, LeftWhitespace, Length, LowerAllCaps, LowerAlpha, MapTo, MaybeFalse, MaybeTrue, Model, Mutable, MutableProps, MutationFunction, MutationIdentity, Narrowable, NonAlpha, NonNumericKeys, NonStringKeys, Not, Numeric, NumericKeys, NumericString, ObjectType, Opaque, OpeningBracket, 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, StringKeys, StringLength, ToFluent, Transformer, Trim, TrimLeft, TrimRight, TupleToUnion, Type, TypeApi, TypeCondition, TypeDefinition, TypeGuard, TypeOptions, UnionToIntersection, UnionToTuple, UniqueDictionary, UniqueForProp, Uniqueness, UpperAlpha, ValueTuple, ValueTypeFunc, ValueTypes, Where, WhereNot, Whitespace, Widen, WithNumericKeys, WithStringKeys, WithValue, ZipCode, and, api, arrayToKeyLookup, arrayToObject, condition, createFnWithProps, createMutationFunction, defineProperties, defineType, dictArr, dictToKv, dictionaryTransform, entries, equals, filterDictArray, fnWithProps, greater, groupBy, idLiteral, idTypeGuard, identity, ifTypeOf, isArray, isBoolean, isFalse, isFunction, isNull, isNumber, isObject, isString, isSymbol, isTrue, isType, isUndefined, keys, kindLiteral, kv, kvToDict, less, literal, mapTo, mapValues, nameLiteral, or, randomString, readonlyFnWithProps, ruleSet, strArrayToDict, type, typeApi, uuid, valueTypes, withValue };

package/dist/index.js

@@ -34,6 +34,7 @@ __export(src_exports, {
   createMutationFunction: () => createMutationFunction,
   defineProperties: () => defineProperties,
   defineType: () => defineType,
+  dictArr: () => dictArr,
   dictToKv: () => dictToKv,
   dictionaryTransform: () => dictionaryTransform,
   entries: () => entries,
@@ -203,6 +204,44 @@ function dictionaryTransform(input, transform) {
   }, {});
 }
 
+// src/utility/dictionary/dictArr.ts
+var dictArr = (...dicts) => {
+  const api2 = {
+    length: dicts.length,
+    toLookup: (prop) => {
+      let dict = {};
+      for (const obj of dicts) {
+        const key = obj[prop];
+        dict = { ...dict, [key]: obj };
+      }
+      return dict;
+    },
+    unique: (prop) => {
+      const v = /* @__PURE__ */ new Set();
+      dicts.forEach((i) => v.add(i[prop]));
+      const size = dictArr(...dicts).count(prop);
+      const values = Array.from(v);
+      const u = {
+        isUnique: values.includes(void 0) ? size === v.size - 1 : size === v.size,
+        includedUndefined: values.includes(void 0) ? true : false,
+        size,
+        values
+      };
+      return u;
+    },
+    sum: (prop) => {
+      return dicts.reduce((acc, obj) => prop in obj ? acc + obj[prop] : acc, 0);
+    },
+    count: (prop) => {
+      return dicts.reduce(
+        (acc, obj) => prop in obj && typeof obj[prop] !== "undefined" ? acc + 1 : acc,
+        0
+      );
+    }
+  };
+  return api2;
+};
+
 // src/utility/dictionary/entries.ts
 function entries(obj) {
   const iterable = {
@@ -293,9 +332,9 @@ function FluentConfigurator(initial = {}) {
 }
 
 // src/utility/dictionary/kv/filterDictArray.ts
-function filterDictArray(dictArr, cb) {
+function filterDictArray(dictArr2, cb) {
   const state = Configurator();
-  const updated = dictArr.filter((i) => {
+  const updated = dictArr2.filter((i) => {
     const [k, v] = i;
     const keep = cb(k, v);
     if (!keep) {
@@ -639,6 +678,7 @@ function withValue(td) {
   createMutationFunction,
   defineProperties,
   defineType,
+  dictArr,
   dictToKv,
   dictionaryTransform,
   entries,

package/dist/index.mjs

@@ -121,6 +121,44 @@ function dictionaryTransform(input, transform) {
   }, {});
 }
 
+// src/utility/dictionary/dictArr.ts
+var dictArr = (...dicts) => {
+  const api2 = {
+    length: dicts.length,
+    toLookup: (prop) => {
+      let dict = {};
+      for (const obj of dicts) {
+        const key = obj[prop];
+        dict = { ...dict, [key]: obj };
+      }
+      return dict;
+    },
+    unique: (prop) => {
+      const v = /* @__PURE__ */ new Set();
+      dicts.forEach((i) => v.add(i[prop]));
+      const size = dictArr(...dicts).count(prop);
+      const values = Array.from(v);
+      const u = {
+        isUnique: values.includes(void 0) ? size === v.size - 1 : size === v.size,
+        includedUndefined: values.includes(void 0) ? true : false,
+        size,
+        values
+      };
+      return u;
+    },
+    sum: (prop) => {
+      return dicts.reduce((acc, obj) => prop in obj ? acc + obj[prop] : acc, 0);
+    },
+    count: (prop) => {
+      return dicts.reduce(
+        (acc, obj) => prop in obj && typeof obj[prop] !== "undefined" ? acc + 1 : acc,
+        0
+      );
+    }
+  };
+  return api2;
+};
+
 // src/utility/dictionary/entries.ts
 function entries(obj) {
   const iterable = {
@@ -211,9 +249,9 @@ function FluentConfigurator(initial = {}) {
 }
 
 // src/utility/dictionary/kv/filterDictArray.ts
-function filterDictArray(dictArr, cb) {
+function filterDictArray(dictArr2, cb) {
   const state = Configurator();
-  const updated = dictArr.filter((i) => {
+  const updated = dictArr2.filter((i) => {
     const [k, v] = i;
     const keep = cb(k, v);
     if (!keep) {
@@ -556,6 +594,7 @@ export {
   createMutationFunction,
   defineProperties,
   defineType,
+  dictArr,
   dictToKv,
   dictionaryTransform,
   entries,

package/package.json

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

package/src/types/dictionary/props.ts

@@ -1,17 +1,27 @@
 import { Alpha } from "../alphabetic/alpha-characters";
 
 /**
- * Extracts the _required_ keys in the object's type
+ * Extracts the _required_ keys in the object's type. You also may
+ * optionally filter by the _value_ of the key.
  */
-export type RequiredKeys<T extends object> = {
-  [K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+export type RequiredKeys<T extends object, V extends any = any> = {
+  [K in keyof T]-?: {} extends { [P in K]: T[K] }
+    ? never //
+    : T[K] extends V
+    ? K
+    : never;
 }[keyof T];
 
 /**
- * Extracts the _optional_ keys in the object's type
+ * Extracts the _optional_ keys in the object's type. You also may
+ * optionally filter by the _value_ of the key.
  */
-export type OptionalKeys<T extends object> = {
-  [K in keyof T]-?: {} extends { [P in K]: T[K] } ? K : never;
+export type OptionalKeys<T extends object, V extends any = any> = {
+  [K in keyof T]-?: {} extends { [P in K]: T[K] }
+    ? V extends T[K]
+      ? K
+      : never //
+    : never;
 }[keyof T];
 
 /**
@@ -84,7 +94,7 @@ export type RequiredProps<T extends object> = Pick<T, RequiredKeys<T>>;
  *
  * Reduces an object to only key/value pairs where the key is optional
  */
-export type OptionalProps<T extends object> = Pick<T, RequiredKeys<T>>;
+export type OptionalProps<T extends object> = Pick<T, OptionalKeys<T>>;
 
 /**
  * **WithValue**

package/src/types/type-conversion/Widen.ts

@@ -0,0 +1,7 @@
+export type Widen<T> = T extends string
+  ? string
+  : T extends number
+  ? number
+  : T extends boolean
+  ? boolean
+  : T;

package/src/types/type-conversion/index.ts

@@ -8,6 +8,7 @@
 export * from "./TupleToUnion";
 export * from "./UnionToIntersection";
 export * from "./UnionToTuple";
+export * from "./Widen";
 
 // #endregion auto-indexed files
 

package/src/utility/dictionary/arrayToKeyLookup.ts

@@ -2,7 +2,9 @@
  * Passing in an array of strings, you are passed back a dictionary with
  * all the keys being the strings and values set to `true`.
  * ```ts
- * // { foo: true, bar: true }
+ * // { bar: true, bar: true } as const;
+ * const d - dictArr(arr);
+ *
  * const fooBar = arrayToKeyLookup("foo", "bar");
  * ```
  */

package/src/utility/dictionary/dictArr.ts

@@ -0,0 +1,69 @@
+import { Keys, Narrowable, OptionalKeys, RequiredKeys, UniqueForProp } from "src/types";
+
+export interface Uniqueness<T> {
+  /** boolean flag to indicate whether the property was unique across all records */
+  isUnique: boolean;
+  /** the overall number of records which contained the property */
+  size: number;
+  /** specifies if undefined values were encountered for this property */
+  includedUndefined: boolean;
+  /** the unique values for the property across all records */
+  values: readonly T[];
+}
+
+export type DictArrApi<T extends Record<string, Narrowable>, A extends readonly T[]> = {
+  length: number;
+  toLookup<PL extends RequiredKeys<T, string> & keyof T & string>(
+    prop: PL
+  ): UniqueForProp<A, PL> extends string ? Record<UniqueForProp<A, PL>, T> : Record<string, T>;
+  sum<PS extends RequiredKeys<T, number> | OptionalKeys<T, number>>(prop: PS): number;
+  count<PC extends OptionalKeys<T>>(prop: PC): number;
+  unique<PU extends Keys<T> & keyof T>(prop: PU): Uniqueness<T[PU]>;
+};
+
+/**
+ * converts an array of objects to a dictionary with keys formed from a given property
+ * of the object and the value being the object itself.
+ */
+export const dictArr = <T extends Record<string, Narrowable>>(...dicts: readonly T[]) => {
+  // build API
+  const api: DictArrApi<T, typeof dicts> = {
+    length: dicts.length,
+    toLookup: (prop) => {
+      let dict: Record<string, T> = {};
+      for (const obj of dicts) {
+        const key = obj[prop] as string;
+        dict = { ...dict, [key]: obj };
+      }
+      return dict;
+    },
+    /**
+     * The unique values of a given property
+     */
+    unique: (prop) => {
+      type P = typeof prop;
+      const v = new Set<T[P]>();
+      dicts.forEach((i) => v.add(i[prop]));
+      const size = dictArr(...dicts).count(prop as any);
+      const values = Array.from(v);
+      const u: Uniqueness<T[P]> = {
+        isUnique: values.includes(undefined as any) ? size === v.size - 1 : size === v.size,
+        includedUndefined: values.includes(undefined as any) ? true : false,
+        size,
+        values,
+      };
+      return u;
+    },
+    sum: (prop) => {
+      return dicts.reduce((acc, obj) => (prop in obj ? acc + (obj[prop] as number) : acc), 0);
+    },
+    count: (prop) => {
+      return dicts.reduce(
+        (acc, obj) => (prop in obj && typeof obj[prop] !== "undefined" ? acc + 1 : acc),
+        0
+      );
+    },
+  };
+
+  return api;
+};

package/src/utility/dictionary/index.ts

@@ -7,6 +7,7 @@
 export * from "./arrayToKeyLookup";
 export * from "./defineProperties";
 export * from "./dictionaryTransform";
+export * from "./dictArr";
 export * from "./entries";
 export * from "./mapValues";
 export * from "./mapTo";

package/tests/dictionary/OptionalKeys.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect } from "vitest";
+import type { Expect, Equal } from "@type-challenges/utils";
+import { OptionalKeys } from "src/types/dictionary";
+
+type Test = { title: string; value: number; color?: string };
+
+describe("OptionalKeys<T, V>", () => {
+  it("basic usage without filtering on value", () => {
+    type T = OptionalKeys<Test>;
+
+    type cases = [Expect<Equal<T, "color">>];
+    const cases: cases = [true];
+    expect(cases).toBe(cases);
+  });
+
+  it("basic usage with a value filter", () => {
+    type T1 = OptionalKeys<Test, string>;
+    type T2 = OptionalKeys<Test, number>;
+
+    type cases = [Expect<Equal<T1, "color">>, Expect<Equal<T2, never>>];
+    const cases: cases = [true, true];
+    expect(cases).toBe(cases);
+  });
+});

package/tests/dictionary/RequiredKeys.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect } from "vitest";
+import type { Expect, Equal } from "@type-challenges/utils";
+import { RequiredKeys } from "src/types/dictionary";
+import { First, Narrowable } from "src";
+
+type Test = { title: string; value: number; color?: string };
+
+describe("RequiredKeys<T, V>", () => {
+  it("basic usage without filtering on value", () => {
+    type T = RequiredKeys<Test>;
+
+    type cases = [Expect<Equal<T, "title" | "value">>];
+    const cases: cases = [true];
+    expect(cases).toBe(cases);
+  });
+
+  it("basic usage with a value filter", () => {
+    type T1 = RequiredKeys<Test, string>;
+    type T2 = RequiredKeys<Test, number>;
+
+    type cases = [Expect<Equal<T1, "title">>, Expect<Equal<T2, "value">>];
+    const cases: cases = [true, true];
+    expect(cases).toBe(cases);
+  });
+
+  it("typed explicitly", () => {
+    type O = {
+      id: number;
+      name: string;
+      title: string;
+      cost?: number;
+      color?: string;
+    };
+
+    const genericArr: O[] = [
+      { id: 1, name: "foo", title: "one", cost: 15 },
+      { id: 2, name: "bar", title: "one" },
+      { id: 3, name: "baz", title: "two", cost: 45, color: "green" },
+    ];
+    const fn = <T extends Record<string, Narrowable>, A extends readonly T[]>(arr: A): A => arr;
+
+    const v = fn(genericArr);
+    type V = typeof v;
+    type T1 = RequiredKeys<First<V>>;
+    type T2 = RequiredKeys<First<V>, string>;
+
+    type cases = [
+      Expect<Equal<T1, "id" | "name" | "title">>, //
+      Expect<Equal<T2, "name" | "title">>
+    ];
+    const cases: cases = [true, true];
+  });
+});

package/tests/lists/UniqueForProp.spec.ts

@@ -1,26 +1,59 @@
 import { describe, it, expect } from "vitest";
-
-import { Expect, Equal, ExpectExtends } from "@type-challenges/utils";
+import { Expect, Equal } from "@type-challenges/utils";
 import { UniqueForProp } from "src/types/lists";
 
+const narrow_data = [
+  { id: 123, color: "blue" },
+  { id: 456, color: "red" },
+] as const;
+type NarrowData = typeof narrow_data;
+
+type R = { id: number; color: string };
+const wide_data: readonly R[] = [
+  { id: 123, color: "blue" },
+  { id: 456, color: "red" },
+];
+type WideData = typeof wide_data;
+
+type R2<T extends string> = Readonly<{ id: number; color: T }>;
+const hybrid = <H extends R2<any>>(...data: H[]): readonly H[] => data;
+const hybrid_data = hybrid(
+  ...[
+    { id: 123, color: "blue" },
+    { id: 456, color: "red" },
+  ]
+);
+type HybridData = typeof hybrid_data;
+
 describe("UniqueForProp<T, P>", () => {
-  it("pull off uniques for 'id' prop", () => {
-    const data = [
-      { id: 123, color: "blue" },
-      { id: 456, color: "red" },
-    ] as const;
-    type Data = typeof data;
-    type U = UniqueForProp<Data, "id">;
+  it("narrow data works as expected", () => {
+    type U = UniqueForProp<NarrowData, "id">;
 
     type cases = [
       // the expected keys are part of the union
-      Expect<ExpectExtends<U, 123>>,
-      Expect<ExpectExtends<U, 456>>,
-      // but so is a lot other junk
       Expect<Equal<U, 123 | 456>>
     ];
 
-    const c: cases = [true, true, true];
+    const c: cases = [true];
+    expect(c).toBe(c);
+  });
+
+  it("wide data only knows the wide type", () => {
+    type U = UniqueForProp<WideData, "id">;
+
+    type cases = [
+      // the keys are rolled up the wide type
+      Expect<Equal<U, number>>
+    ];
+
+    const c: cases = [true];
+    expect(c).toBe(c);
+  });
+
+  it("wide data only knows the wide type", () => {
+    type U = UniqueForProp<HybridData, "id">;
+    type cases = [Expect<Equal<U, number>>];
+    const c: cases = [true];
     expect(c).toBe(c);
   });
 });

package/tests/lists/dictArr.test.ts

@@ -0,0 +1,110 @@
+import { describe, expect, it } from "vitest";
+import type { Expect, Equal } from "@type-challenges/utils";
+import { dictArr, keys, literal } from "src/utility";
+
+type O = {
+  id: number;
+  name: string;
+  title: string;
+  cost?: number;
+  color?: string;
+};
+
+const genericArr: O[] = [
+  { id: 1, name: "foo", title: "one", cost: 15 },
+  { id: 2, name: "bar", title: "one" },
+  { id: 3, name: "baz", title: "two", cost: 45, color: "green" },
+];
+
+const literalArr = [
+  literal({ id: 1, name: "foo", title: "one", cost: 15 }),
+  literal({ id: 2, name: "bar", title: "one" }),
+  literal({ id: 3, name: "baz", title: "two", cost: 45, color: "green" }),
+];
+
+const wideArr = [
+  { id: 1, name: "foo", title: "one", cost: 15 },
+  { id: 2, name: "bar", title: "one" },
+  { id: 3, name: "baz", title: "two", cost: 45, color: "green" },
+];
+
+describe("dictArr() utility API", () => {
+  it("returns an API when passed the array", () => {
+    const r = dictArr(...genericArr);
+    type R = typeof r;
+    // runtime checks
+    expect(typeof r.toLookup).contains("function");
+    expect(typeof r.unique).contains("function");
+    expect(typeof r.count).contains("function");
+    expect(typeof r.sum).contains("function");
+    expect(typeof r.length).contains("number");
+
+    // type checks
+    type ToLookupParam = Parameters<R["toLookup"]>[0];
+    type UniqueParam = Parameters<R["unique"]>[0];
+    type CountParam = Parameters<R["count"]>[0];
+    type SumParam = Parameters<R["sum"]>[0];
+
+    // type ToLookupReturn = ReturnType<R["toLookup"]>;
+
+    type cases = [
+      Expect<Equal<ToLookupParam, "name" | "title">>,
+      Expect<Equal<UniqueParam, "id" | "name" | "title" | "cost" | "color">>,
+      Expect<Equal<CountParam, "cost" | "color">>,
+      Expect<Equal<SumParam, "id" | "cost">>
+    ];
+    const cases: cases = [true, true, true, true];
+  });
+
+  it("toLookup() creates type-strong lookup", () => {
+    const g = dictArr(...genericArr);
+    const l = dictArr(...literalArr);
+    const pl = dictArr(...wideArr);
+    const byNameG = g.toLookup("name");
+    const byNameL = l.toLookup("name");
+    const byNamePL = pl.toLookup("name");
+    const kg = keys(byNameG);
+    const kl = keys(byNameL);
+    const kpl = keys(byNamePL);
+    expect(kg).contains("foo");
+    expect(kg).contains("bar");
+    expect(kg).contains("baz");
+
+    expect(kl).contains("foo");
+    expect(kl).contains("bar");
+    expect(kl).contains("baz");
+
+    expect(kpl).contains("foo");
+    expect(kpl).contains("bar");
+    expect(kpl).contains("baz");
+
+    const fooG = genericArr.find((i) => i.name === "foo");
+    expect(byNameG.foo).toEqual(fooG);
+
+    const fooL = literalArr.find((i) => i.name === "foo");
+    expect(byNameL.foo).toEqual(fooL);
+  });
+
+  it("summarization works", () => {
+    const r = dictArr(...genericArr);
+    expect(r.sum("cost")).toBe(60);
+  });
+
+  it("counting of non-required props works", () => {
+    const r = dictArr(...genericArr);
+    expect(r.count("color")).toBe(1);
+    expect(r.count("cost")).toBe(2);
+  });
+
+  it("uniqueness", () => {
+    const r = dictArr(...genericArr);
+    const color = r.unique("color");
+    const title = r.unique("title");
+
+    expect(color.isUnique).toBeTruthy();
+    expect(color.includedUndefined).toBeTruthy();
+    expect(color.values).toEqual([undefined, "green"]);
+    expect(title.isUnique).toBeFalsy();
+    expect(title.values).toEqual(["one", "two"]);
+  });
+});