udic 0.1.0 → 0.1.2

package/README.md

@@ -1,37 +1,108 @@
 A simple dependency injection library.
+
+# Examples
 ```ts
 import * as di from 'udic';
+```
+
+Run code that depends on a service:
+```ts
+// Create a service that generates random number
+const randNumber = di.service('randNumber')<() => number>();
+
+// Use the service
+const compute = di.derive(
+  [randNumber],
+  (getRandNumber) => getRandNumber() + 1
+);
+
+// 1
+console.log(
+  compute({ randNumber: () => 0 })
+);
+```
 
+Nested `derive()`:
+```ts
 // Create a service that generates random number
 const randNumber = di.service('randNumber')<() => number>();
 
 // Use the service
-const computed = di.derive(
+const compute = di.derive(
   [randNumber],
   (getRandNumber) => getRandNumber() + 1
 );
 
+// Use `compute()` within current context
+const anotherCompute = di.derive(
+  [compute],
+  (computedValue) => computedValue * 2
+);
+
+// 2
+console.log(
+  anotherCompute({ randNumber: () => 0 })
+);
+```
+
+Multiple dependencies:
+```ts
+// Create a service that generates random number
+const randNumber = di.service('randNumber')<() => number>();
+
+// Use the service
+const computeNumber = di.derive(
+  [randNumber],
+  (getRandNumber) => getRandNumber() + 1,
+);
+
 // Create a service that generates random string
 const randString = di.service('randString')<() => string>();
 
 // Use the computed value of `computed`
-const computed1 = di.derive(
-  [randString, computed],
-  (getRandString, computedValue) => getRandString() + ': ' + computedValue,
+const computeString = di.derive(
+  [randString, computeNumber],
+  (getRandString, number) => getRandString() + ': ' + number,
 );
 
+// 'reve: 1'
 console.log(
-  // Provide implementations of services
-  computed1({
-    randNumber: () => Math.random(),
-    randString: () => crypto.randomUUID(),
+  computeString({
+    randNumber: () => 0,
+    randString: () => 'reve',
   }),
-); // Output: '<random uuid>: <random number + 1>'
+);
+```
 
+Inject not all dependencies:
+```ts
+// Create a service that generates random number
+const randNumber = di.service('randNumber')<() => number>();
+
+// Use the service
+const computeNumber = di.derive(
+  [randNumber],
+  (getRandNumber) => getRandNumber() + 1,
+);
+
+// Create a service that generates random string
+const randString = di.service('randString')<() => string>();
+
+// Use the computed value of `computed`
+const computeString = di.derive(
+  [randString, computeNumber],
+  (getRandString, number) => getRandString() + ': ' + number,
+);
+
+// Inject the randNumber service
+const computeString1 = di.inject(computeString, {
+  randNumber: () => 0
+});
+
+// 'reve: 1'
 console.log(
-  computed1({
-    randNumber: () => 0,
-    randString: () => 'reve'
-  })
-); // Output: 'reve: 1'
+  computeString1({
+    randString: () => 'reve',
+  }),
+);
 ```

package/index.d.ts

@@ -1,4 +1,5 @@
 declare const _: unique symbol;
+type _ = typeof _;
 type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
 export interface Service<
 	T extends string | symbol,
@@ -8,18 +9,18 @@ export interface Service<
 	[_]: undefined extends K ? { [k in T]? : K } : { [k in T] : K };
 }
 export interface Compute<
-	T extends Dependency[],
+	T,
 	R
 > {
-	(args: InferRecord<T>): R;
+	(c: T): R;
 	0: R;
-	[_]: InferRecord<T>;
+	[_]: T;
 }
 export type AnyService = Service<string | symbol, any>;
-export type AnyCompute = Compute<any[], 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][typeof _]>;
+export type InferRecord<T extends Dependency[]> = UnionToIntersection<T[number][_]>;
 /**
 * Create a service
 * @param name - The service name
@@ -33,5 +34,14 @@ export declare const service: <T extends string | symbol>(name: T) => (<K>() =>
 export declare const derive: <
 	const T extends Dependency[],
 	const R
->(deps: T, f: (...args: InferDependencies<T>) => R) => Compute<T, R>;
+>(deps: T, f: (...args: InferDependencies<T>) => R) => Compute<InferRecord<T>, R>;
+/**
+* Inject some 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]>;
 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 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(Object.assign(n,t));

package/package.json

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