udic 0.0.3 → 0.1.0

package/README.md

@@ -1,23 +1,37 @@
 A simple dependency injection library.
 ```ts
-import { di } from 'udic';
+import * as di from 'udic';
 
-const rand = di.service('rand')<number>();
-const computed = di.compute((val) => val + 1, rand);
+// Create a service that generates random number
+const randNumber = di.service('randNumber')<() => number>();
 
-const rand1 = di.service('rand1')<number>();
-const computed1 = di.compute(
-  (val, computed0) => val + computed0,
-  rand1,
-  computed,
+// Use the service
+const computed = 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,
 );
 
 console.log(
+  // Provide implementations of services
   computed1({
-    rand: 9,
-    rand1: 9,
+    randNumber: () => Math.random(),
+    randString: () => crypto.randomUUID(),
   }),
-);
-```
+); // Output: '<random uuid>: <random number + 1>'
 
-This should only be used to replace singletons.
+console.log(
+  computed1({
+    randNumber: () => 0,
+    randString: () => 'reve'
+  })
+); // Output: 'reve: 1'
+```

package/index.d.ts

@@ -1,2 +1,37 @@
-export * as di from "./di.js";
-export * from "./di.js";
+declare const _: 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;
+	[_]: undefined extends K ? { [k in T]? : K } : { [k in T] : K };
+}
+export interface Compute<
+	T extends Dependency[],
+	R
+> {
+	(args: InferRecord<T>): R;
+	0: R;
+	[_]: InferRecord<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][typeof _]>;
+/**
+* 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<T, R>;
+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]));

package/package.json

@@ -1,14 +1,17 @@
 {
 "name": "udic",
-"version": "0.0.3",
+"version": "0.1.0",
 "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,29 +0,0 @@
-declare const tag: unique symbol;
-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: InferDependenciesRecord<T>): R;
-	0: R;
-	1: InferDependenciesRecord<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[]> = T extends [infer A extends Dependency, ...infer B extends Dependency[]] ? [A[0], ...InferDependencies<B>] : [];
-export type InferDependenciesRecord<T extends Dependency[]> = T extends [infer A extends Dependency, ...infer B extends Dependency[]] ? A[1] & InferDependenciesRecord<B> : {};
-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]));