udic 0.0.1 → 0.0.3

package/README.md

@@ -1,17 +1,23 @@
-## DEI
-A simple dependency injection library
+A simple dependency injection library.
 ```ts
-const rand = dependency<number>();
+import { di } from 'udic';
 
-const code = compute((value) => {
-  return value + 1;
-}, rand);
+const rand = di.service('rand')<number>();
+const computed = di.compute((val) => val + 1, rand);
 
-const dependentCode = compute((computedValue) => computedValue * 2, code);
+const rand1 = di.service('rand1')<number>();
+const computed1 = di.compute(
+  (val, computed0) => val + computed0,
+  rand1,
+  computed,
+);
 
-const ctx = {
-  [rand]: 9
-};
-
-dependentCode(ctx);
+console.log(
+  computed1({
+    rand: 9,
+    rand1: 9,
+  }),
+);
 ```
+
+This should only be used to replace singletons.

package/di.d.ts

@@ -0,0 +1,29 @@
+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

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

package/index.d.ts

@@ -1,2 +1,2 @@
-export * as udic from "./main.js";
-export * from "./main.js";
+export * as di from "./di.js";
+export * from "./di.js";

package/index.js

@@ -1 +1 @@
-export*as udic from"./main.js";export*from"./main.js";
+export*as di from"./di.js";export*from"./di.js";

package/package.json

@@ -1,6 +1,6 @@
 {
 "name": "udic",
-"version": "0.0.1",
+"version": "0.0.3",
 "description": "A simple dependency injection library",
 "keywords": [],
 "license": "MIT",
@@ -8,7 +8,7 @@
 "main": "./index.js",
 "types": "./index.d.ts",
 "exports": {
-"./main": "./main.js",
+"./di": "./di.js",
 ".": "./index.js"
 }
 }

package/main.d.ts

@@ -1,44 +0,0 @@
-type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
-export type Dependency<
-	Tag extends {
-		0: any
-	} = any,
-	T = any
-> = {
-	0: Record<Tag[0], T>
-	1: T
-} & symbol;
-export interface Compute<
-	T extends Params[] = any,
-	R = any
-> {
-	(c: UnionToIntersection<T[number][0] & {}>): R;
-	0: UnionToIntersection<T[number]>;
-	1: R;
-}
-type Params = Dependency | Compute;
-type InferParams<T extends Params[]> = T extends [infer A extends Params, ...infer B extends Params[]] ? [A[1] & {}, ...InferParams<B>] : [];
-/**
-* Create a dependency
-*/
-export declare const dependency: <T>() => Dependency<{
-	readonly 0: unique symbol
-}, T>;
-/**
-* Compute another value based on dependencies or other computes
-* @param f
-* @param deps
-* @returns a compute
-*/
-export declare const compute: <
-	const T extends Params[],
-	const R
->(f: (...data: InferParams<NoInfer<T>>) => R, ...deps: T) => Compute<T, R>;
-/**
-* Create a dependency context
-* @param x
-*/
-export declare const provide: <T extends {
-	[K: Dependency]: (typeof K)[1]
-}>(x: T) => Readonly<UnionToIntersection<keyof T extends Dependency ? (keyof T)[0] : any>>;
-export {};

package/main.js

@@ -1 +0,0 @@
-export let dependency=Symbol;export let compute=(e,...t)=>n=>{for(let e=0;e<t.length;e++)t[e]=typeof t[e]===`symbol`?n[t[e]]:n[t[e]]??=t[e](n);return e(...t)};export let provide=e=>e;