udic 0.1.3 → 0.1.5

package/README.md

@@ -1,10 +1,9 @@
 A dependency injection library.
-
-# Examples
 ```ts
 import * as di from 'udic';
 ```
 
+# Examples
 Run code that depends on a service:
 ```ts
 // Create a service that generates random number

package/index.d.ts

@@ -1,47 +1,46 @@
-declare const _: unique symbol;
-type _ = typeof _;
+declare const _t: unique symbol;
+declare const _d: unique symbol;
 type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
+type Prettify<T> = { [K in keyof T] : T[K] } & {};
 export interface Service<
 	T extends string | symbol,
 	K
 > {
-	0: K;
-	[_]: undefined extends K ? { [k in T]? : K } : { [k in T] : K };
+	[_t]: K;
+	[_d]: undefined extends K ? { [k in T]? : K } : { [k in T] : K };
 }
 export interface Compute<
 	T,
 	R
 > {
+	[_t]: R;
+	[_d]: T;
 	(c: T): R;
-	0: R;
-	[_]: T;
 }
-export type AnyService = Service<string | symbol, any>;
-export type AnyCompute = Compute<any, any>;
-export type Dependency = AnyService | AnyCompute;
-export type InferDependencies<T extends Dependency[]> = { [K in keyof T] : T[K][0] };
-export type InferRecord<T extends Dependency[]> = UnionToIntersection<T[number][_]>;
+export type Dependency = Service<any, any> | Compute<any, any>;
+export type InferDependencies<T extends Dependency> = Prettify<UnionToIntersection<T[typeof _d]>>;
 /**
 * Create a service
 * @param name - The service name
 */
 export declare const service: <T extends string | symbol>(name: T) => (<K>() => Service<T, K>);
 /**
-* Create a service that relies on other services
+* Create a compute that relies on other services or computes
 * @param deps - The service dependencies
 * @param f
 */
 export declare const derive: <
 	const T extends Dependency[],
 	const R
->(deps: T, f: (...args: InferDependencies<T>) => R) => Compute<InferRecord<T>, R>;
+>(deps: T, f: (...args: { [K in keyof T] : T[K][typeof _t] }) => R) => Compute<InferDependencies<T[number]>, R>;
 /**
-* Inject some dependencies to the compute
+* Inject dependencies to the compute
 * @param compute
 * @param deps - Dependencies to inject
 */
 export declare const inject: <
-	T extends AnyCompute,
-	D extends Partial<T[_]>
->(compute: T, d: D) => Compute<Omit<T[_], keyof D>, T[0]>;
+	T,
+	R,
+	D extends Partial<T>
+>(compute: Compute<T, R>, d: D) => Compute<Prettify<Omit<T, keyof D>>, R>;
 export {};

package/index.js

@@ -1 +1 @@
-export let service=e=>()=>e;export let derive=(e,t)=>n=>t(...e.map(e=>typeof e===`function`?n[e]??=e(n):n[e]));export let inject=(e,t)=>n=>e({...n,...t});
+;export let service=e=>()=>e;export let derive=(e,t)=>n=>t(...e.map(e=>typeof e===`function`?n[e]??=e(n):n[e]));export let inject=(e,t)=>n=>e({...n,...t});

package/package.json

@@ -1,6 +1,6 @@
 {
 "name": "udic",
-"version": "0.1.3",
+"version": "0.1.5",
 "description": "A simple dependency injection library",
 "keywords": ["di"],
 "license": "MIT",