inferred-types 0.18.4 → 0.20.0

package/dist/index.d.ts

@@ -899,6 +899,11 @@ declare type SnakeCase<S extends string> = string extends S ? string : DashUpper
  */
 declare type Get<T, K> = K extends `${infer FK}.${infer L}` ? FK extends keyof T ? Get<T[FK], L> : never : K extends keyof T ? T[K] : never;
 
+/**
+ * Accepts an object with at least one property defined on it
+ */
+declare type NotEmptyObject<T extends {}> = ExpandRecursively<Length<UnionToTuple<Keys<T>>> extends 0 ? false : T>;
+
 /**
  * **ToFluent**
  *
@@ -1037,7 +1042,7 @@ declare type FirstKeyValue<T extends object> = FirstKey<T> extends keyof T ? T[F
 declare type FirstOfEach<T extends readonly any[][]> = T[number][0] extends T[number][number] ? T[number][0] : never;
 
 /**
- * Typescript utility which recieves `T` as shape which resembles `DictArray<D>`
+ * Typescript utility which receives `T` as shape which resembles `DictArray<D>`
  * and if the type `D` can be inferred it is returned.
  * ```ts
  * // { foo: 1; bar: "hi" }
@@ -1082,6 +1087,19 @@ declare type LastInUnion<U> = UnionToIntersection<U extends unknown ? (x: U) =>
  */
 declare type UnionToTuple<U, Last = LastInUnion<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, Last>>, Last];
 
+/**
+ * Given a dictionary of key/values, where the value is a function, this
+ * type utility will maintain the keys but change the values to whatever
+ * the `ReturnType` of the function was.
+ * ```ts
+ * // { foo: string }
+ * type Test = UnwrapValue<{ foo: (name: string) => name }>
+ * ```
+ */
+declare type UnwrapValue<T extends Record<string, (...args: any[]) => any>> = {
+    [K in keyof T]: T[K] extends Function ? ReturnType<T[K]> : never;
+}[keyof T];
+
 declare type ValueFunction<T extends any> = <R extends any>(v: T) => R;
 /**
  * **SameKeys**
@@ -1096,6 +1114,14 @@ declare type WrapValue<T extends {}, F extends ValueFunction<T>> = {
 };
 
 declare function createFnWithProps<F extends Function, P extends {}>(fn: F, props: P): F & P;
+/**
+ * Adds a dictionary of key/value pairs to a function.
+ */
+declare function fnWithProps<A extends any[], R extends any, P extends {}>(fn: ((...args: A) => R), props: P): ((...args: A) => R) & P;
+/**
+ * Adds read-only (and narrowly typed) key/value pairs to a function
+ */
+declare function readonlyFnWithProps<A extends any[], R extends any, N extends Narrowable, P extends Record<keyof P, N>>(fn: ((...args: A) => R), props: P): ((...args: A) => R) & Readonly<P>;
 
 /**
  * Provides the _keys_ of an object with the `keyof T` made explicit.
@@ -9770,4 +9796,4 @@ declare function KeyStorage(): {
     done: () => never[];
 };
 
-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, DictArray, DictArrayFilterCallback, DictArrayKv, DictFromKv, DictKvTuple, DynamicRule, DynamicRuleSet, Email, EnumValues, ExpandRecursively, ExpectExtends, ExplicitFunction, ExtendsClause, ExtendsNarrowlyClause, Filter, First, FirstKey, FirstKeyValue, FirstOfEach, FluentConfigurator, FluentFunction, FromDictArray, FunctionType, GeneralDictionary, Get, HasUppercase, IConfigurator, IFluentConfigurator, If, IfExtends, IfExtendsThen, Include, Includes, IsArray, IsBoolean, IsCapitalized, IsFalse, IsFunction, IsLiteral, IsObject, IsString, IsTrue, KebabCase, KeyStorage, KeyStorageApi, KeyValue, KeyedRecord, Keys, KeysWithValue, KvFrom, KvTuple, LastInUnion, LeftWhitespace, Length, LowerAllCaps, LowerAlpha, MaybeFalse, MaybeTrue, Model, Mutable, MutationFunction, MutationIdentity, Narrowable, NonAlpha, NonNumericKeys, NonStringKeys, Not, Numeric, NumericKeys, NumericString, ObjectType, Opaque, OpenningBracket, OptionalKeys, OptionalProps, Parenthesis, PascalCase, Pluralize, PrivateKey, PrivateKeys, PublicKeys, Punctuation, PureFluentApi, Replace, RequiredKeys, RequiredProps, Retain, RightWhitespace, RuleDefinition, RuntimeProp, RuntimeType, SameKeys, SecondOfEach, 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, WrapValue, ZipCode, and, api, arrayToKeyLookup, arrayToObject, condition, createFnWithProps, createMutationFunction, defineType, dictToKv, dictionaryTransform, entries, equals, filterDictArray, greater, groupBy, idLiteral, idTypeGuard, identity, ifTypeOf, isArray, isBoolean, isFalse, isFunction, isLiteral, isNull, isNumber, isObject, isString, isSymbol, isTrue, isType, isUndefined, keys, kindLiteral, kv, kvToDict, less, literal, mapValues, nameLiteral, or, randomString, ruleSet, strArrayToDict, type, typeApi, uuid, valueTypes, valuesOfProp, 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, DictArray, DictArrayFilterCallback, DictArrayKv, DictFromKv, DictKvTuple, DynamicRule, DynamicRuleSet, Email, EnumValues, ExpandRecursively, ExpectExtends, ExplicitFunction, ExtendsClause, ExtendsNarrowlyClause, Filter, First, FirstKey, FirstKeyValue, FirstOfEach, FluentConfigurator, FluentFunction, FromDictArray, FunctionType, GeneralDictionary, Get, HasUppercase, IConfigurator, IFluentConfigurator, If, IfExtends, IfExtendsThen, Include, Includes, IsArray, IsBoolean, IsCapitalized, IsFalse, IsFunction, IsLiteral, IsObject, IsString, IsTrue, KebabCase, KeyStorage, KeyStorageApi, KeyValue, KeyedRecord, Keys, KeysWithValue, KvFrom, KvTuple, LastInUnion, LeftWhitespace, Length, LowerAllCaps, LowerAlpha, MaybeFalse, MaybeTrue, Model, Mutable, MutationFunction, MutationIdentity, Narrowable, NonAlpha, NonNumericKeys, NonStringKeys, Not, NotEmptyObject, Numeric, NumericKeys, NumericString, ObjectType, Opaque, OpenningBracket, OptionalKeys, OptionalProps, Parenthesis, PascalCase, Pluralize, PrivateKey, PrivateKeys, PublicKeys, Punctuation, PureFluentApi, Replace, RequiredKeys, RequiredProps, Retain, RightWhitespace, RuleDefinition, RuntimeProp, RuntimeType, SameKeys, SecondOfEach, SnakeCase, SpecialCharacters, StringDelimiter, StringKeys, StringLength, ToFluent, Transformer, Trim, TrimLeft, TrimRight, TupleToUnion, Type, TypeApi, TypeCondition, TypeDefinition, TypeGuard, TypeOptions, UnionToIntersection, UnionToTuple, UniqueDictionary, UniqueForProp, UnwrapValue, UpperAlpha, ValueTuple, ValueTypeFunc, ValueTypes, Where, WhereNot, Whitespace, WithNumericKeys, WithStringKeys, WithValue, WrapValue, ZipCode, and, api, arrayToKeyLookup, arrayToObject, condition, createFnWithProps, createMutationFunction, defineType, dictToKv, dictionaryTransform, entries, equals, filterDictArray, fnWithProps, greater, groupBy, idLiteral, idTypeGuard, identity, ifTypeOf, isArray, isBoolean, isFalse, isFunction, isLiteral, isNull, isNumber, isObject, isString, isSymbol, isTrue, isType, isUndefined, keys, kindLiteral, kv, kvToDict, less, literal, mapValues, nameLiteral, or, randomString, readonlyFnWithProps, ruleSet, strArrayToDict, type, typeApi, uuid, valueTypes, valuesOfProp, withValue };

package/dist/index.js

@@ -60,6 +60,7 @@ __export(src_exports, {
   entries: () => entries,
   equals: () => equals,
   filterDictArray: () => filterDictArray,
+  fnWithProps: () => fnWithProps,
   greater: () => greater,
   groupBy: () => groupBy,
   idLiteral: () => idLiteral,
@@ -89,6 +90,7 @@ __export(src_exports, {
   nameLiteral: () => nameLiteral,
   or: () => or,
   randomString: () => randomString,
+  readonlyFnWithProps: () => readonlyFnWithProps,
   ruleSet: () => ruleSet,
   strArrayToDict: () => strArrayToDict,
   type: () => type,
@@ -158,6 +160,20 @@ function createFnWithProps(fn, props) {
     return combined;
   })();
 }
+function fnWithProps(fn, props) {
+  let combined = fn;
+  for (const prop of keys(props)) {
+    combined[prop] = props[prop];
+  }
+  return combined;
+}
+function readonlyFnWithProps(fn, props) {
+  let combined = fn;
+  for (const prop of keys(props)) {
+    combined[prop] = props[prop];
+  }
+  return combined;
+}
 
 // src/utility/ruleset.ts
 function ruleSet(defn) {
@@ -641,6 +657,7 @@ module.exports = __toCommonJS(src_exports);
   entries,
   equals,
   filterDictArray,
+  fnWithProps,
   greater,
   groupBy,
   idLiteral,
@@ -670,6 +687,7 @@ module.exports = __toCommonJS(src_exports);
   nameLiteral,
   or,
   randomString,
+  readonlyFnWithProps,
   ruleSet,
   strArrayToDict,
   type,

package/dist/index.mjs

@@ -77,6 +77,20 @@ function createFnWithProps(fn, props) {
     return combined;
   })();
 }
+function fnWithProps(fn, props) {
+  let combined = fn;
+  for (const prop of keys(props)) {
+    combined[prop] = props[prop];
+  }
+  return combined;
+}
+function readonlyFnWithProps(fn, props) {
+  let combined = fn;
+  for (const prop of keys(props)) {
+    combined[prop] = props[prop];
+  }
+  return combined;
+}
 
 // src/utility/ruleset.ts
 function ruleSet(defn) {
@@ -558,6 +572,7 @@ export {
   entries,
   equals,
   filterDictArray,
+  fnWithProps,
   greater,
   groupBy,
   idLiteral,
@@ -587,6 +602,7 @@ export {
   nameLiteral,
   or,
   randomString,
+  readonlyFnWithProps,
   ruleSet,
   strArrayToDict,
   type,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inferred-types",
-  "version": "0.18.4",
+  "version": "0.20.0",
   "description": "Functions which provide useful type inference on TS projects",
   "license": "MIT",
   "author": "Ken Snyder<ken@ken.net>",
@@ -14,6 +14,9 @@
     "build": "run-s clean autoindex lint build:bundle",
     "build:force": "run-s clean autoindex build:bundle",
     "build:bundle": "npx tsup src/index.ts --dts --format='esm,cjs'",
+    "watch": "run-p watch:*",
+    "watch:autoindex": "npx dd autoindex --watch",
+    "watch:bundle": "npx tsup src/index.ts --dts --format='esm,cjs' --watch",
     "clean": "rimraf dist/**/*",
     "lint": "eslint src/**/*.ts --fix && tsc --noEmit ",
     "lint:full": "eslint src/**/*.ts && eslint test/**/*.ts && tsc --noEmit",
@@ -48,4 +51,4 @@
   "dependencies": {
     "common-types": "^1.31.0"
   }
-}
+}

package/src/types/FunctionType.ts

@@ -6,4 +6,4 @@
  */
 export type FunctionType<T extends {} = {}> = {} extends T
   ? Function | (Function & { [key: string]: any })
-  : Function | (Function & T);
+  : Function | (Function & T);

package/src/types/dictionary/NotEmptyObject.ts

@@ -0,0 +1,9 @@
+import { ExpandRecursively } from "../ExpandRecursively";
+import { Keys, Length, UnionToTuple } from "../index";
+
+/**
+ * Accepts an object with at least one property defined on it
+ */
+export type NotEmptyObject<T extends {}> = ExpandRecursively<
+  Length<UnionToTuple<Keys<T>>> extends 0 ? false : T
+>;

package/src/types/dictionary/index.ts

@@ -1,10 +1,11 @@
 // #autoindex
 // #region autoindexed files
-// index last changed at: 1st Jan, 2022, 03:27 PM ( GMT-8 )
-// hash-code: 47804a72
+// index last changed at: 6th Jun, 2022, 03:36 AM ( GMT-7 )
+// hash-code: 1f3a5076
 
 // file exports
 export * from "./Get";
+export * from "./NotEmptyObject";
 
 // #endregion
 

package/src/types/tuples/FromDictArray.ts

@@ -2,7 +2,7 @@ import { ExpandRecursively, UnionToIntersection } from "~/types";
 
 
 /**
- * Typescript utility which recieves `T` as shape which resembles `DictArray<D>`
+ * Typescript utility which receives `T` as shape which resembles `DictArray<D>`
  * and if the type `D` can be inferred it is returned.
  * ```ts
  * // { foo: 1; bar: "hi" }

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

@@ -0,0 +1,13 @@
+
+/**
+ * Given a dictionary of key/values, where the value is a function, this 
+ * type utility will maintain the keys but change the values to whatever
+ * the `ReturnType` of the function was.
+ * ```ts
+ * // { foo: string }
+ * type Test = UnwrapValue<{ foo: (name: string) => name }>
+ * ```
+ */
+export type UnwrapValue<T extends Record<string, (...args: any[]) => any>> = {
+  [K in keyof T]: T[K] extends Function ? ReturnType<T[K]> : never;
+}[keyof T];

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

@@ -1,14 +1,15 @@
 // #autoindex
 
 // #region autoindexed files
-// index last changed at: 1st Jan, 2022, 03:27 PM ( GMT-8 )
-// hash-code: 3c8daf19
+// index last changed at: 6th Jun, 2022, 03:36 AM ( GMT-7 )
+// hash-code: ac142b94
 
 // file exports
 export * from "./SameKeys";
 export * from "./TupleToUnion";
 export * from "./UnionToIntersection";
 export * from "./UnionToTuple";
+export * from "./UnwrapValue";
 export * from "./WrapValue";
 
 // #endregion

package/src/utility/createFnWithProps.ts

@@ -1,3 +1,4 @@
+import { Narrowable } from "../types/Narrowable";
 import { keys } from "./keys";
 
 export function createFnWithProps<F extends Function, P extends {}>(fn: F, props: P) {
@@ -10,3 +11,27 @@ export function createFnWithProps<F extends Function, P extends {}>(fn: F, props
     return combined;
   })() as unknown as F & P;
 }
+
+/**
+ * Adds a dictionary of key/value pairs to a function.
+ */
+export function fnWithProps<A extends any[], R extends any, P extends {}>(fn: ((...args: A) => R), props: P) {
+  // eslint-disable-next-line prefer-const
+  let combined: any = fn;
+  for (const prop of keys(props)) {
+    combined[prop] = props[prop];
+  }
+  return combined as ((...args: A) => R) & P;
+}
+
+/**
+ * Adds read-only (and narrowly typed) key/value pairs to a function
+ */
+export function readonlyFnWithProps<A extends any[], R extends any, N extends Narrowable, P extends Record<keyof P, N>>(fn: ((...args: A) => R), props: P) {
+  // eslint-disable-next-line prefer-const
+  let combined: any = fn;
+  for (const prop of keys(props)) {
+    combined[prop] = props[prop];
+  }
+  return combined as ((...args: A) => R) & Readonly<P>;
+}