@dungarees/core 0.11.0 → 0.11.2

package/marbles.d.ts

@@ -1,3 +1,4 @@
+import type { DetachableMethods } from './type-util.ts';
 import type { Observable } from 'rxjs';
 import { Expect } from 'rxjs-marbles/expect.js';
 import { marbles } from 'rxjs-marbles/jest/index.js';
@@ -5,13 +6,13 @@ import type { ExpectHelpers, TestObservableLike } from 'rxjs-marbles/types.js';
 type Marbles = typeof marbles;
 type MarblesRunner = Parameters<Marbles>[0];
 type MarblesParam = Parameters<MarblesRunner>[0];
-type Runner = (m: MarblesExtensions, ...args: any[]) => ReturnType<MarblesRunner>;
+type Runner<ARGS extends unknown[] = []> = (m: MarblesExtensions, ...args: ARGS) => void | Promise<void>;
 type MarbleFunctions = Record<string, () => void>;
 type MarblesExtensions = {
     coldCall: (marble: string, functions: MarbleFunctions) => void;
     coldBoolean: (marble: string) => TestObservableLike<boolean>;
-    expect: <T = any>(actual: Observable<T>, subscription?: string) => ExtendedExpect<T>;
-} & MarblesParam;
+    expect: <T = unknown>(actual: Observable<T>, subscription?: string) => ExtendedExpect<T>;
+} & DetachableMethods<MarblesParam>;
 declare class ExtendedExpect<T> extends Expect<T> {
     readonly actual_: Observable<T>;
     readonly helpers_: ExpectHelpers;
@@ -19,7 +20,7 @@ declare class ExtendedExpect<T> extends Expect<T> {
     constructor(actual_: Observable<T>, helpers_: ExpectHelpers, subscription_?: string);
     toBeObservableBoolean(marble: string): void;
 }
-export declare const coreMarbles: (runner: Runner) => (() => void);
+export declare const coreMarbles: <ARGS extends unknown[] = []>(runner: Runner<ARGS>) => ((...args: ARGS) => void | Promise<void>);
 export declare const MARBLES_BOOLEAN: {
     t: boolean;
     f: boolean;

package/marbles.js

@@ -11,42 +11,45 @@ class ExtendedExpect extends Expect {
         this.toBeObservable(marble, MARBLES_BOOLEAN);
     }
 }
-export const coreMarbles = (runner) => (...args) => marbles((m) => {
-    const coldCall = (marble, functions) => {
-        const marbleDefinition = Object.fromEntries(Object.keys(functions).map((key) => [key, key]));
-        m.cold(marble, marbleDefinition).subscribe((key) => {
-            functions[key]?.();
-        });
-    };
-    const coldBoolean = (marble) => m.cold(marble, MARBLES_BOOLEAN);
-    // This function and the ExtendedExpect depends on internals of the `rxjs-marbles` library
-    // potentially not future proof
-    const expect = (actual, subscription) => {
-        const { helpers_ } = m;
-        return new ExtendedExpect(actual, helpers_, subscription);
-    };
-    // The methods on `m` (the RunContext) are on the prototype, so we have to bind the original
-    // ones to be able to use destructuring
-    return runner({
-        get autoFlush() {
-            return m.autoFlush;
-        },
-        coldCall,
-        coldBoolean,
-        expect,
-        equal: m.equal.bind(m),
-        cold: m.cold.bind(m),
-        bind: m.bind.bind(m),
-        configure: m.configure.bind(m),
-        flush: m.flush.bind(m),
-        has: m.has.bind(m),
-        hot: m.hot.bind(m),
-        reframe: m.reframe.bind(m),
-        scheduler: m.scheduler,
-        teardown: m.teardown.bind(m),
-        time: m.time.bind(m),
-    }, ...args);
-})();
+export const coreMarbles = (runner) => (...args) => {
+    const runInMarbles = marbles((m) => {
+        const coldCall = (marble, functions) => {
+            const marbleDefinition = Object.fromEntries(Object.keys(functions).map((key) => [key, key]));
+            m.cold(marble, marbleDefinition).subscribe((key) => {
+                functions[key]?.();
+            });
+        };
+        const coldBoolean = (marble) => m.cold(marble, MARBLES_BOOLEAN);
+        // This function and the ExtendedExpect depends on internals of the `rxjs-marbles` library
+        // potentially not future proof
+        const expect = (actual, subscription) => {
+            const { helpers_ } = m;
+            return new ExtendedExpect(actual, helpers_, subscription);
+        };
+        // The methods on `m` (the RunContext) are on the prototype, so we have to bind the original
+        // ones to be able to use destructuring
+        return runner({
+            get autoFlush() {
+                return m.autoFlush;
+            },
+            coldCall,
+            coldBoolean,
+            expect,
+            equal: m.equal.bind(m),
+            cold: m.cold.bind(m),
+            bind: m.bind.bind(m),
+            configure: m.configure.bind(m),
+            flush: m.flush.bind(m),
+            has: m.has.bind(m),
+            hot: m.hot.bind(m),
+            reframe: m.reframe.bind(m),
+            scheduler: m.scheduler,
+            teardown: m.teardown.bind(m),
+            time: m.time.bind(m),
+        }, ...args);
+    });
+    return runInMarbles();
+};
 export const MARBLES_BOOLEAN = {
     t: true,
     f: false,

package/package.json

@@ -14,13 +14,38 @@
     "vitest": "^3.0.2"
   },
   "author": "info@productkind.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/productkind/monorepo.git",
+    "directory": "dungarees/src/core"
+  },
   "license": "MIT",
-  "version": "0.11.0",
+  "dependencies": {
+    "hotscript": "^1.0.13",
+    "rxjs": "^7.8.1"
+  },
+  "version": "0.11.2",
   "exports": {
     "./application.ts": {
       "import": "./application.js",
       "types": "./application.d.ts"
     },
+    "./error.test.ts": {
+      "import": "./error.test.js",
+      "types": "./error.test.d.ts"
+    },
+    "./error.ts": {
+      "import": "./error.js",
+      "types": "./error.d.ts"
+    },
+    "./event.test.ts": {
+      "import": "./event.test.js",
+      "types": "./event.test.d.ts"
+    },
+    "./event.ts": {
+      "import": "./event.js",
+      "types": "./event.d.ts"
+    },
     "./fake.test.ts": {
       "import": "./fake.test.js",
       "types": "./fake.test.d.ts"
@@ -476,6 +501,7 @@
     "./util.ts": {
       "import": "./util.js",
       "types": "./util.d.ts"
-    }
+    },
+    "./tsconfig.base.json": "./tsconfig.base.json"
   }
 }

package/tsconfig.base.json

@@ -0,0 +1,35 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "lib": ["dom", "dom.iterable", "esnext", "webworker"],
+    "types": ["node", "vite/client"],
+    "allowJs": true,
+    "allowImportingTsExtensions": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "strict": true,
+    "allowSyntheticDefaultImports": true,
+    "exactOptionalPropertyTypes": true,
+    "forceConsistentCasingInFileNames": true,
+    "noImplicitAny": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noImplicitThis": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noUncheckedIndexedAccess": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "strictBindCallApply": true,
+    "strictFunctionTypes": true,
+    "strictNullChecks": true,
+    "strictPropertyInitialization": true,
+    "useUnknownInCatchVariables": true,
+    "noFallthroughCasesInSwitch": true,
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "sourceMap": true
+  }
+}

package/type-util.d.ts

@@ -1,3 +1,4 @@
+import type { Fn } from 'hotscript';
 export type StringLiteral<T> = T extends string ? (string extends T ? never : T) : never;
 export type ObjectWithStringLiteralKey<KEY, VALUE> = {
     [K in StringLiteral<KEY>]: VALUE;
@@ -6,28 +7,26 @@ export type JsonType = number | string | boolean | null | undefined | JsonType[]
 export type JsonObject = {
     [key: string]: JsonType;
 };
+export type Serializable = JsonType;
 export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
 export type TokenNonEmptyString<TOKEN extends string | number> = TOKEN extends '' ? never : TOKEN;
-export type Guard<T = any> = (arg: unknown) => arg is T;
+export type Guard<T = unknown> = (arg: unknown) => arg is T;
 export type GetGuarded<GUARD extends Guard> = GUARD extends (arg: unknown) => arg is infer GUARDED ? GUARDED : never;
-export type EntryTuple<KEY extends string = string, VALUE = any> = [KEY, VALUE];
-export type RecordToEntries<RECORD extends Record<string, any>, KEY = keyof RECORD> = KEY extends string ? (KEY extends keyof RECORD ? EntryTuple<KEY, RECORD[KEY]> : never) : never;
+export type EntryTuple<KEY extends string = string, VALUE = unknown> = [KEY, VALUE];
+export type RecordToEntries<RECORD extends Record<string, unknown>, KEY = keyof RECORD> = KEY extends string ? (KEY extends keyof RECORD ? EntryTuple<KEY, RECORD[KEY]> : never) : never;
 export type GetValueByKey<ENTRIES extends EntryTuple, KEY extends string> = ENTRIES extends EntryTuple<KEY, infer ENTRY> ? ENTRY : never;
 export type GetKey<ENTRIES extends EntryTuple> = ENTRIES[0];
 export type GetValue<ENTRIES extends EntryTuple> = ENTRIES[1];
-export type FilterRecord2<RECORD extends Record<string | number | symbol, any>, TYPE> = Pick<RECORD, {
+export type FilterRecord<RECORD extends Record<string | number | symbol, unknown>, TYPE> = Pick<RECORD, {
     [K in keyof RECORD]: RECORD[K] extends TYPE ? K : never;
 }[keyof RECORD]>;
-export type FilterRecord<RECORD extends Record<string | number | symbol, any>, TYPE> = {
-    [K in keyof RECORD]: RECORD[K] extends TYPE ? RECORD[K] : never;
-};
 export type Split<STRING extends string, DELIMITER extends string> = SplitHelper<STRING, DELIMITER>;
 type SplitHelper<STRING extends string, DELIMITER extends string, ACC extends readonly string[] = []> = STRING extends `${infer FIRST}${DELIMITER}${infer REST}` ? SplitHelper<REST, DELIMITER, [...ACC, FIRST]> : readonly [...ACC, STRING];
 export type SplitObjectPath<PATH extends string> = Split<PATH, '.'>;
 export type SplitFilePath<PATH extends string> = Split<PATH, '/'>;
 export type GetAllPaths<OBJECT, PATH extends string = ''> = PathsHelper<OBJECT, PATH, never>;
 type PathsHelper<OBJECT, PATH extends string, ACC extends string> = {
-    [K in keyof OBJECT & string]: PATH extends '' ? K | (OBJECT[K] extends Record<string, any> ? PathsHelper<OBJECT[K], K, K> : never) : `${PATH}.${K}` | (OBJECT[K] extends Record<string, any> ? PathsHelper<OBJECT[K], `${PATH}.${K}`, `${PATH}.${K}` | ACC> : never);
+    [K in keyof OBJECT & string]: PATH extends '' ? K | (OBJECT[K] extends Record<string, unknown> ? PathsHelper<OBJECT[K], K, K> : never) : `${PATH}.${K}` | (OBJECT[K] extends Record<string, unknown> ? PathsHelper<OBJECT[K], `${PATH}.${K}`, `${PATH}.${K}` | ACC> : never);
 }[keyof OBJECT & string] | ACC;
 export type GetValueByPath<OBJECT, PATH extends string> = PATH extends keyof OBJECT ? OBJECT[PATH] : PATH extends `${infer K}.${infer Rest}` ? K extends keyof OBJECT ? GetValueByPath<OBJECT[K], Rest & string> : never : never;
 export type JoinArray<STRINGS extends readonly string[], DELIMITER extends string, ACC extends string = ''> = STRINGS extends [] ? '' : STRINGS extends [infer L, ...infer R] ? L extends string ? R['length'] extends 0 ? `${ACC}${L & string}` : R extends string[] ? JoinArray<R, DELIMITER, `${ACC}${L}${DELIMITER}`> : never : ACC : never;
@@ -43,8 +42,17 @@ export type Mutable<T> = {
     -readonly [K in keyof T]: T[K];
 };
 export type PartialBesides<OBJECT, KEYS extends keyof OBJECT> = Partial<Omit<OBJECT, KEYS>> & Pick<OBJECT, KEYS>;
+export type FlattenIntersection<OBJECT> = {
+    [KEY in keyof OBJECT]: OBJECT[KEY];
+};
+export type DetachableMethods<OBJECT> = {
+    [KEY in keyof OBJECT]: OmitThisParameter<OBJECT[KEY]>;
+};
 export type DeepPartial<T> = {
     [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
 };
-export type SyncFunctionToAsync<FUNC extends (...args: any[]) => any> = FUNC extends (...args: infer ARGS) => infer RETURN ? (...args: ARGS) => Promise<RETURN> : never;
+export type SyncFunctionToAsync<FUNC extends (...args: never[]) => unknown> = FUNC extends (...args: infer ARGS) => infer RETURN ? (...args: ARGS) => Promise<RETURN> : never;
+export interface StaticFn<RETURN> extends Fn {
+    return: RETURN;
+}
 export {};

package/type-util.test.js

@@ -1,41 +1,38 @@
-import { assert } from 'tsafe';
-import { test } from 'vitest';
+import { expect, expectTypeOf, test } from 'vitest';
 test('Split<PATH, DELIMITER>', () => {
-    assert();
-    assert();
-    assert();
-    assert();
-    assert();
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
 });
 test('SplitObjectPath<PATH>', () => {
-    assert();
-    assert();
-    assert();
-    assert();
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
 });
 test('SplitFilePath<PATH>', () => {
-    assert();
-    assert();
-    assert();
-    assert();
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
 });
 test('StringLiteral<LITERAL>', () => {
     const literal = 'asd';
-    assert();
+    expectTypeOf(literal).toEqualTypeOf();
+    // Widened through an annotation rather than an `as` cast, so rule 4 still holds.
+    const widened = 'asd';
     // @ts-expect-error it has to be a literal
-    const nonLiteral = 'asd';
-    assert();
+    const nonLiteral = widened;
+    expectTypeOf(nonLiteral).toEqualTypeOf();
 });
 test('ObjectWithStringLiteralKey<KEY, VALUE>', () => {
     const obj = {
         a: 1,
     };
-    assert();
+    expectTypeOf(obj).toEqualTypeOf();
     // @ts-expect-error it has to be a literal
     const nonLiteral = {
         a: 1,
     };
-    assert();
+    expectTypeOf(nonLiteral).toEqualTypeOf();
 });
 test('JsonType', () => {
     const json = {
@@ -45,91 +42,106 @@ test('JsonType', () => {
         d: null,
         e: [1, '2', true, null, [1, '2', true, null]],
     };
-    assert();
+    expect(json).toBeDefined();
     // @ts-expect-error it cannot be a function
     const nonJson = {
         f: () => { },
     };
-    assert();
+    expect(nonJson).toBeDefined();
 });
 test('TokenNonEmptyString<TOKEN>', () => {
     const token = 'a';
-    assert();
+    expectTypeOf(token).toEqualTypeOf();
     // @ts-expect-error it cannot be empty
     const nonToken = '';
-    assert();
+    expectTypeOf(nonToken).toEqualTypeOf();
 });
 test('Guard<TYPE>', () => {
     const guard = (arg) => arg === 1;
-    assert();
+    expectTypeOf(guard).toEqualTypeOf();
     // @ts-expect-error it has to be a guard
     const nonGuard = (arg) => arg === 1;
-    assert();
+    expectTypeOf(nonGuard).toEqualTypeOf();
 });
 test('GetGuarded<GUARD>', () => {
-    const guard = (arg) => arg === 1;
-    assert();
+    const testUnused_guard = (arg) => arg === 1;
+    expectTypeOf().toEqualTypeOf();
 });
 test('EntryTuples', () => {
-    assert();
-    assert();
-    assert();
-    assert();
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
 });
 test('FilterRecord<RECORD, TYPE>', () => {
-    // TODO remove the keys as well
-    assert();
+    expectTypeOf().toEqualTypeOf();
 });
 test('GetAllPaths<OBJECT>', () => {
-    assert();
+    expectTypeOf().toEqualTypeOf();
 });
 test('GetValuesByPath<OBJECT, PATH>', () => {
-    assert();
+    expectTypeOf().toEqualTypeOf();
 });
 test('JoinArray<STRINGS, DELIMITER>', () => {
-    assert();
-    assert();
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
 });
 test('FromCamelCase<STRING>', () => {
-    assert();
-    assert();
-    assert();
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
 });
 test('ToCamelCase<STRING[]>', () => {
-    assert();
-    assert();
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
 });
 test('FromKebabCase<STRING>', () => {
-    assert();
-    assert();
-    assert();
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
 });
 test('ToKebabCase<STRING[]>', () => {
-    assert();
-    assert();
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
 });
 test('FromSnakeCase<STRING>', () => {
-    assert();
-    assert();
-    assert();
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
 });
 test('ToSnakeCase<STRING[]>', () => {
-    assert();
-    assert();
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
 });
 test('Mutable<TYPE>', () => {
-    assert();
-    assert();
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
+});
+test('FlattenIntersection<OBJECT>', () => {
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
 });
 test('PartialBesides<OBJECT, KEYS>', () => {
-    assert();
+    // Flattened first: PartialBesides produces an intersection, and expectTypeOf compares that
+    // by its parts rather than by the object it is equivalent to.
+    expectTypeOf().toEqualTypeOf();
 });
 test('DeepPartial<T> - single level', () => {
-    assert();
+    expectTypeOf().toEqualTypeOf();
 });
 test('DeepPartial<T> - nested props', () => {
-    assert();
+    expectTypeOf().toEqualTypeOf();
 });
 test('SyncFunctionToAsync<FUNC>', () => {
-    assert();
+    expectTypeOf().toEqualTypeOf();
+});
+test('SyncFunctionToAsync<FUNC> accepts every function shape', () => {
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
+});
+test('DetachableMethods<OBJECT>', () => {
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
 });

package/util.d.ts

@@ -1,5 +1,5 @@
-import type { Guard, JsonType } from './type-util.ts';
-import type { Call, Fn } from 'hotscript';
+import type { FromCamelCase, FromKebabCase, Guard, JoinArray, JsonType, ObjectWithStringLiteralKey, Split, StringLiteral, ToCamelCase, ToKebabCase } from './type-util.ts';
+import type { Call, Fn, Objects, Pipe } from 'hotscript';
 export declare const typeKey: unique symbol;
 export declare const makeObjectFromStringLiteral: <KEY, VALUE>(key: StringLiteral<KEY>, value: VALUE) => ObjectWithStringLiteralKey<KEY, VALUE>;
 export declare const split: <const STRING extends string, const DELIMITER extends string>(str: STRING, delimiter: DELIMITER) => Split<STRING, DELIMITER>;
@@ -9,20 +9,20 @@ export declare const pluralize: (str: string, value: number, prefix?: boolean) =
 export declare const toCamelCase: <const SEGMENTS extends readonly string[]>(segments: SEGMENTS) => ToCamelCase<SEGMENTS>;
 export declare const kebabCase2camelCase: <const KEBAB_CASE extends string>(kebabCase: KEBAB_CASE) => ToCamelCase<FromKebabCase<KEBAB_CASE>>;
 export declare const camelCase2kebabCase: <const CAMEL_CASE extends string>(camelCase: CAMEL_CASE) => ToKebabCase<FromCamelCase<CAMEL_CASE>>;
-export declare const isDeepEqual: (a: any, b: any) => boolean;
-export declare const deepEqualPartial: (actual: any, expected: any) => boolean;
+export declare const isDeepEqual: (a: unknown, b: unknown) => boolean;
+export declare const deepEqualPartial: (actual: unknown, expected: unknown) => boolean;
 export declare const findByPattern: <MATCH extends JsonType, const PATTERNS extends readonly FindByPatterns[]>(patterns: PATTERNS, itemToMatch: MATCH) => GetValueFromPatternList<PATTERNS> | undefined;
 export declare const optionalPatternToList: <const VALUE>(value: VALUE) => OptionalPatternToList<VALUE>;
 export type FindByPatterns = FindByPattern | FindByPartialPattern | FindByDefault;
-export type FindByPattern<VALUE = any, PATTERN extends JsonType = JsonType> = {
+export type FindByPattern<VALUE = unknown, PATTERN extends JsonType = JsonType> = {
     readonly value: VALUE;
     readonly pattern: PATTERN;
 };
-export type FindByPartialPattern<VALUE = any, PATTERN extends JsonType = JsonType> = {
+export type FindByPartialPattern<VALUE = unknown, PATTERN extends JsonType = JsonType> = {
     readonly value: VALUE;
     readonly patternPartial: Partial<PATTERN>;
 };
-export type FindByDefault<VALUE = any> = {
+export type FindByDefault<VALUE = unknown> = {
     readonly value: VALUE;
 };
 export type OptionalPatternList<VALUE, PATTERN extends JsonType> = VALUE | Array<FindByPattern<VALUE, PATTERN> | FindByPartialPattern<VALUE, PATTERN> | FindByDefault<VALUE>>;
@@ -36,7 +36,7 @@ type AssertPredicateArg<T> = {
     predicate: (value: T) => boolean;
     message: ErrorMessage<T>;
 };
-export declare const assertPredicate: <T>({ value, predicate, message, }: AssertPredicateArg<T>) => T;
+export declare const assertPredicate: <T>({ value, predicate, message }: AssertPredicateArg<T>) => T;
 export declare const assertImpossible: (message: string) => never;
 type ErrorMessage<T> = string | ((value: T) => string);
 type AssertTypeByGuardArg<T, V> = {
@@ -44,10 +44,28 @@ type AssertTypeByGuardArg<T, V> = {
     guard: Guard<T>;
     message: ErrorMessage<V>;
 };
-export declare const unPrototypeProperties: <const T extends Record<string, any>, const KEYS extends keyof T>(obj: T, keys: KEYS[]) => Pick<T, KEYS>;
-type MapConstResult<ARRAY extends readonly any[], F extends Fn> = {
+export declare const unPrototypeProperties: <const T extends object, const KEYS extends keyof T>(obj: T, keys: KEYS[]) => Pick<T, KEYS>;
+export declare const boolFromThrow: (fn: () => void) => boolean;
+export declare const boolFromThrowAsync: (fn: () => Promise<void>) => Promise<boolean>;
+type MapConstResult<ARRAY extends readonly unknown[], F extends Fn> = {
     readonly [K in keyof ARRAY]: Call<F, ARRAY[K]>;
 };
-export declare const mapConst: <const ARRAY extends readonly any[]>(array: ARRAY) => <F extends Fn>(transformer: (value: ARRAY[number]) => unknown) => MapConstResult<ARRAY, F>;
-export declare const objectFromConstEntries: <const ENTRIES extends readonly (readonly [string, any])[]>(entries: ENTRIES) => { [K in ENTRIES[number] as K[0]]: K[1]; };
+export declare function mapConst<const ARRAY extends readonly unknown[]>(array: ARRAY): <F extends Fn>(transformer: (value: ARRAY[number], index: Pipe<ARRAY, [Objects.Keys]>) => MapConstResult<ARRAY, F>[number]) => MapConstResult<ARRAY, F>;
+export declare function mapConst<const ARRAY extends readonly unknown[], const R>(array: ARRAY, transformer: (value: ARRAY[number], index: Pipe<ARRAY, [Objects.Keys]>) => R): {
+    readonly [K in keyof ARRAY]: R;
+};
+type MapConstKeysToEntriesResult<ARRAY extends readonly unknown[], F extends Fn> = {
+    readonly [K in keyof ARRAY]: [ARRAY[K], Call<F, ARRAY[K]>];
+};
+export declare function mapConstKeysToEntries<const ARRAY extends readonly unknown[]>(array: ARRAY): <F extends Fn>(transformer: (value: ARRAY[number], index: Pipe<ARRAY, [Objects.Keys]>) => MapConstKeysToEntriesResult<ARRAY, F>[number][1]) => MapConstKeysToEntriesResult<ARRAY, F>;
+export declare function mapConstKeysToEntries<const ARRAY extends readonly unknown[], const R>(array: ARRAY, transformer: (value: ARRAY[number], index: Pipe<ARRAY, [Objects.Keys]>) => R): {
+    readonly [K in keyof ARRAY]: [ARRAY[K], R];
+};
+export declare const objectFromConstEntries: <const ENTRIES extends readonly (readonly [string, unknown])[]>(entries: ENTRIES) => { [K in ENTRIES[number] as K[0]]: K[1]; };
+export declare function mapObjectFromKeys<const KEYS extends readonly string[]>(keys: KEYS): <F extends Fn>(transformer: (key: KEYS[number], index: Pipe<KEYS, [Objects.Keys]>) => Call<F, KEYS[number]>) => {
+    [K in MapConstKeysToEntriesResult<KEYS, F>[number] as K[0]]: K[1];
+};
+export declare function mapObjectFromKeys<const KEYS extends readonly string[], const R>(keys: KEYS, transformer: (key: KEYS[number], index: Pipe<KEYS, [Objects.Keys]>) => R): {
+    [K in KEYS[number]]: R;
+};
 export {};