inferred-types 0.53.10 → 0.53.12

package/modules/runtime/dist/index.d.ts

@@ -624,6 +624,13 @@ interface Thenable {
 }
 
 type TupleRange = [required: number, optional: number];
+type _Tuple<TType = unknown, TLength extends number | TupleRange | `${number}+` = 0> = 0 extends TLength ? TType extends any[] ? Readonly<TType> : readonly TType[] : TLength extends number ? Readonly<FixedLengthArray<TType, TLength>> : TLength extends TupleRange ? Readonly<[
+    ...FixedLengthArray<TType, TLength[0]>,
+    ...FixedLengthArray<TType | undefined, TLength[1]>
+]> : TLength extends `${infer Num extends number}+` ? Num extends number ? Readonly<[
+    ...FixedLengthArray<TType, Num>,
+    ...TType[]
+]> : never : never;
 /**
  * **Tuple**`<TType,TLength>`
  *
@@ -639,13 +646,7 @@ type TupleRange = [required: number, optional: number];
  * type T2 = Tuple<string, 4>;
  * ```
  */
-type Tuple<TType = unknown, TLength extends number | TupleRange | `${number}+` = 0> = 0 extends TLength ? TType extends any[] ? Readonly<TType> : readonly TType[] : TLength extends number ? Readonly<FixedLengthArray<TType, TLength>> : TLength extends TupleRange ? Readonly<[
-    ...FixedLengthArray<TType, TLength[0]>,
-    ...FixedLengthArray<TType | undefined, TLength[1]>
-]> : TLength extends `${infer Num extends number}+` ? Num extends number ? Readonly<[
-    ...FixedLengthArray<TType, Num>,
-    ...TType[]
-]> : never : never;
+type Tuple<TType = unknown, TLength extends number | TupleRange | `${number}+` = 0> = _Tuple<TType, TLength> extends readonly unknown[] ? _Tuple<TType, TLength> : never;
 
 type Process$1x<TVal, TDefault> = TVal extends Something ? TVal : TDefault;
 /**
@@ -9946,6 +9947,14 @@ type IterateOverDefinitions<T extends readonly unknown[], TElse> = {
     [K in keyof T]: ToType$1<T[K], TElse>;
 };
 type TypeDefinition = NarrowableScalar | ShapeCallback;
+type _FromDefineObject<T extends Required<DefineObject>> = {
+    [K in keyof T]: T[K] extends SimpleToken ? SimpleType<T[K]> : T[K] extends ShapeCallback ? ReturnType<HandleDoneFn<T[K]>> : never;
+};
+/**
+ * Converts a `DefineObject` definition into the type that it is
+ * defining.
+ */
+type FromDefineObject<T extends DefineObject> = MakeKeysOptional<_FromDefineObject<Required<T>>, UnionToTuple$1<OptionalKeys<T>> extends readonly ObjectKey[] ? UnionToTuple$1<OptionalKeys<T>> : never>;
 /**
  * **FromDefn**`<T, [TElse]>`
  *
@@ -9961,9 +9970,7 @@ type TypeDefinition = NarrowableScalar | ShapeCallback;
  * Note: when dictionary objects are found the _values_ will be
  * interrogated for ShapeCallback's.
  */
-type FromDefn$1<T, TElse = Constant$1<"not-set">> = T extends DefineObject ? {
-    [K in keyof T]: T[K] extends SimpleToken ? SimpleType<T[K]> : T[K] extends ShapeCallback ? HandleDoneFn<T[K]> : never;
-} : T extends readonly unknown[] ? IterateOverDefinitions<T, TElse> : ToType$1<T, TElse>;
+type FromDefn$1<T, TElse = Constant$1<"not-set">> = T extends DefineObject ? FromDefineObject<T> : T extends readonly unknown[] ? IterateOverDefinitions<T, TElse> : ToType$1<T, TElse>;
 
 type WideTokenNames = "string" | "number" | "boolean" | "null" | "undefined" | "never" | "unknown" | "string[]" | "number[]" | "boolean[]" | "unknown[]";
 type ConvertWideTokenNames<T extends WideTokenNames> = T extends "string" ? string : T extends "number" ? number : T extends "boolean" ? boolean : T extends "null" ? null : T extends "undefined" ? undefined : T extends "never" ? never : T extends "unknown" ? unknown : T extends "string[]" ? string[] : T extends "number[]" ? number[] : T extends "boolean[]" ? boolean[] : T extends "unknown[]" ? unknown[] : never;
@@ -10291,6 +10298,48 @@ type Process$e<TObj extends Dictionary, TKeys extends ObjectKey> = [] extends TK
  */
 type WithoutKeys<TObj extends Dictionary, TKeys extends ObjectKey | readonly ObjectKey[]> = TKeys extends readonly ObjectKey[] ? Process$e<TObj, TupleToUnion<TKeys>> : ExpandDictionary<Process$e<TObj, TKeys extends readonly ObjectKey[] ? TupleToUnion<TKeys> : TKeys>>;
 
+type ProcessTupleKeys<TObj extends AnyObject, TKeys extends readonly ObjectKey[]> = ExpandDictionary<WithoutKeys<TObj, TKeys> & {
+    [K in keyof WithKeys<TObj, TKeys>]?: K extends keyof TObj ? TObj[K] : never;
+}>;
+type ProcessUnionKeys<TObj extends AnyObject, TKeys extends (string | symbol)> = ExpandDictionary<WithoutKeys<TObj, TKeys> & {
+    [K in keyof WithKeys<TObj, TKeys>]?: K extends keyof TObj ? TObj[K] : never;
+}>;
+/**
+ * **MakeKeysOptional**`<TObj, TKeys>`
+ *
+ * Makes a set of keys on a known object `TObj` become
+ * _optional_ parameters while leaving the other properties
+ * "as is".
+ *
+ * **Related:** `MakeKeysRequired`
+ */
+type MakeKeysOptional<TObj extends AnyObject, TKeys extends (string | symbol) | readonly ObjectKey[]> = IsWideContainer<TObj> extends true ? TObj : TKeys extends readonly ObjectKey[] ? ProcessTupleKeys<TObj, TKeys> : TKeys extends (string | symbol) ? IsWideUnion<TKeys> extends true ? never : ProcessUnionKeys<TObj, TKeys> : never;
+
+/**
+ * **OptionalKeys**`<T,[V]>`
+ *
+ * Provides a union type of the _keys_ in `T` which are
+ * **optional** properties.
+ *
+ * **Note:** you also may optionally filter further by specifying a value
+ * by the _value_ of the key and then only keys which are required AND
+ * who extend `V` will be included in the union.
+ *
+ * **Related:** `OptionalKeys`, `RequiredProps` * Provides a union type of the _keys_ in `T` which are
+ * **required** properties.
+ *
+ * **Note:** you also may optionally filter further by specifying a value
+ * by the _value_ of the key and then only keys which are required AND
+ * who extend `V` will be included in the union.
+ *
+ * **Related:** `RequiredKeys`, `RequiredProps`
+ */
+type OptionalKeys<T extends AnyObject, V = Unset> = {
+    [K in keyof T]-?: EmptyObject extends {
+        [P in K]: T[K];
+    } ? If<IsEqual<V, Unset>, K, K extends V ? K : never> : never;
+}[keyof T];
+
 /**
  * **CombinedKeys**`<A,B>`
  *
@@ -10797,7 +10846,9 @@ type TypeTuple<TType extends Narrowable = Narrowable, TDesc extends string = str
  *
  * - typically used though a function of type `DefineObjectApi`
  */
-type DefineObject = Record<string, SimpleToken | ShapeCallback>;
+interface DefineObject {
+    [key: string]: SimpleToken | ShapeCallback;
+}
 
 type BuildObj<T extends readonly string[] | Dictionary | [Dictionary], TType> = T extends Dictionary ? T : T extends [Dictionary] ? T[0] : T extends string[] ? CreateKV<T, TType> : never;
 /**
@@ -11355,6 +11406,7 @@ declare function getYesterday(): Iso8601Date<"explicit">;
  */
 declare function isLeapYear(val: NumberLike | Record<string, any> | Date | number): boolean;
 
+type Returns$1<T extends DefineObject, P extends readonly (keyof T & string)[]> = P["length"] extends 0 ? FromDefineObject<T> : MakeKeysOptional<T, P> extends DefineObject ? FromDefineObject<MakeKeysOptional<T, P>> : never;
 /**
  * Takes an object definition where the values are either
  * `SimpleToken` representations of a type or a `ShapeCallback`.
@@ -11362,7 +11414,7 @@ declare function isLeapYear(val: NumberLike | Record<string, any> | Date | numbe
  * In both cases the runtime type is left unchanged but the
  * type is converted to represent the designed object shape.
  */
-declare function defineObject<T extends DefineObject>(defn: T): FromDefn$1<T>;
+declare function defineObject<T extends DefineObject, P extends readonly (keyof T & string)[]>(defn: T, ..._optProps: P): Returns$1<T, P>;
 
 /**
  * **entries**
@@ -13330,8 +13382,10 @@ declare function isArray(value: unknown): value is unknown[];
  * **isBoolean**(value)
  *
  * Type guard which validates that type is a boolean value.
+ *
+ * **Related:** `isBooleanLike()`
  */
-declare function isBoolean<T>(value: T): value is T & boolean;
+declare function isBoolean(value: unknown): value is boolean;
 
 /**
  * **isBooleanLike**`(val)`
@@ -13405,17 +13459,20 @@ declare function isFalse(i: unknown): i is false;
 declare function isFalsy<V extends Narrowable>(val: V): val is V & FalsyValue;
 
 /**
- * **isFnWithDict**(input)
+ * **isFnWithParams**(input, [...params | count])
  *
  * Type guard which checks whether a give variable is a function
  * which contains at least one parameter.
  *
- * - if you set the parameter types, it will check that precisely the
- * correct amount are set
+ * - the optional second parameter may be used to express the **types** of
+ * the expected parameters or just the expected **count** of parameters
+ * - if you set the parameter types, it will check that the
+ * correct amount of parameters are set but can only _assume_ the types of
+ * the parameters are as you have expressed
  */
-declare function isFnWithParams<T, P extends readonly SimpleToken[]>(input: T, ...params: P): input is T & AsNarrowingFn<P["length"] extends 0 ? [any, ...any[]] : {
+declare function isFnWithParams<T, P extends (readonly SimpleToken[]) | [number]>(input: T, ...params: P): input is T & AsNarrowingFn<"length" extends keyof T ? T["length"] extends 0 ? IsLiteral<P["length"]> extends true ? Tuple<any, P["length"]> : [any, ...any[]] : [any, ...any[]] : P extends readonly SimpleToken[] ? {
     [K in keyof P]: SimpleType<P[K]>;
-}, T extends TypedFunction ? ReturnType<T> : unknown>;
+} : P extends [number] ? Tuple<any, P[0]> : never, T extends TypedFunction ? ReturnType<T> : unknown>;
 
 /**
  * **isFunction**(value)
@@ -13424,7 +13481,7 @@ declare function isFnWithParams<T, P extends readonly SimpleToken[]>(input: T, .
  *
  * **Related:** `isFnWithParams`, `ifFunction`
  */
-declare function isFunction<T>(value: T): value is T & TypedFunction;
+declare function isFunction(value: unknown): value is TypedFunction;
 
 /**
  * **isHexadecimal**`(val)`

package/modules/runtime/dist/index.js

@@ -2054,7 +2054,7 @@ function isLeapYear(val) {
 }
 
 // src/dictionary/defineObject.ts
-function defineObject(defn) {
+function defineObject(defn, ..._optProps) {
   return defn;
 }