udic 0.0.4 → 0.1.1

package/README.md

@@ -1,23 +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 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
-import { di } from 'udic';
+// Create a service that generates random number
+const randNumber = di.service('randNumber')<() => number>();
 
-const rand = di.service('rand')<number>();
-const computed = di.compute((val) => val + 1, rand);
+// Use the service
+const computeNumber = di.derive(
+  [randNumber],
+  (getRandNumber) => getRandNumber() + 1,
+);
 
-const rand1 = di.service('rand1')<number>();
-const computed1 = di.compute(
-  (val, computed0) => val + computed0,
-  rand1,
-  computed,
+// 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,
 );
 
+// 'reve: 1'
 console.log(
-  computed1({
-    rand: 9,
-    rand1: 9,
+  computeString({
+    randNumber: () => 0,
+    randString: () => 'reve',
   }),
 );
 ```
 
-This should only be used to replace singletons.
+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(
+  computeString1({
+    randString: () => 'reve',
+  }),
+);
+```

package/index.d.ts

@@ -1,2 +1,47 @@
-export * as di from "./di.js";
-export * from "./di.js";
+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,
+	K
+> {
+	0: K;
+	[_]: undefined extends K ? { [k in T]? : K } : { [k in T] : K };
+}
+export interface Compute<
+	T,
+	R
+> {
+	(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][_]>;
+/**
+* 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
+* @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>;
+/**
+* Inject some dependencies to the compute
+* @param compute
+* @param deps
+*/
+export declare const inject: <
+	T extends AnyCompute,
+	D extends Partial<T[_]>
+>(compute: T, deps: D) => Compute<Omit<T[_], keyof D>, T[0]>;
+export {};

package/index.js

@@ -1 +1 @@
-export*as di from"./di.js";export*from"./di.js";
+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,14 +1,17 @@
 {
 "name": "udic",
-"version": "0.0.4",
+"version": "0.1.1",
 "description": "A simple dependency injection library",
 "keywords": [],
 "license": "MIT",
+"repository": {
+"type": "git",
+"url": "git+https://github.com/re-utils/di.git"
+},
 "type": "module",
 "main": "./index.js",
 "types": "./index.d.ts",
 "exports": {
-"./di": "./di.js",
 ".": "./index.js"
 }
 }

package/di.d.ts

@@ -1,30 +0,0 @@
-declare const tag: unique symbol;
-type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
-export interface Service<
-	T extends string | symbol,
-	K
-> {
-	0: K;
-	1: K extends undefined ? { [k in T]? : K } : { [k in T] : K };
-	readonly [tag]: null;
-}
-export interface Compute<
-	T extends Dependency[],
-	R
-> {
-	(args: InferRecord<T>): R;
-	0: R;
-	1: InferRecord<T>;
-	readonly [tag]: null;
-}
-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][1]>;
-export declare const service: <T extends string | symbol>(t: T) => (<K>() => Service<T, K>);
-export declare const compute: <
-	const T extends Dependency[],
-	const R
->(f: (...args: InferDependencies<NoInfer<T>>) => R, ...deps: T) => Compute<T, R>;
-export {};

package/di.js

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