@pippenly/ts-utils 1.0.4 → 1.0.5

package/README.md

@@ -40,6 +40,8 @@ For two way binding, `model(sourceResin, element, options?)` exists, where eleme
 throttle / debounce options and custom get/set if needed.
 
 ```ts
+import { resin, bind, model, watchEffect } from "@pippenly/ts-utils/dom";
+
 const name = resin("");
 const m = model(name, document.querySelector<HTMLInputElement>("#name")!, {
     debounce: 300
@@ -59,6 +61,74 @@ const ageModel = model(age, document.querySelector<HTMLInputElement>("#age")!, {
 });
 ```
 
+# Scope
+Creating a scope with a dependency injection system
+```ts
+import { asyncScope, Err, Ok, token, type AsyncRunnable, type Result } from "@pippenly/ts-utils";
+
+interface Logger {
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+}
+
+interface HttpClient {
+    get: (url: string) => Promise<any>;
+    post: (url: string, data: any) => Promise<any>;
+}
+
+type HttpRunnable = AsyncRunnable<typeof httpScope, Result<any, string>>;
+
+const httpScope = asyncScope(Logger, HttpClient)
+    .provide(Logger, new ConsoleLogger())
+    .provide(HttpClient, new BrowserHttpClient());
+
+const sendMessage: HttpRunnable = async (get): AsyncResult<any, string> => {
+    const logger = get(Logger);
+    const httpClient = get(HttpClient);
+    logger.info("Sending message...");
+    try {
+        const response = await httpClient.post("/api/messages", { text: "Hello, World!" });
+        logger.info("Message sent successfully: " + JSON.stringify(response));
+        return Ok(response);
+    } catch (error) {
+        logger.error("Failed to send message: " + error);
+        return Err("Failed to send message");
+    }
+}
+
+const sendHealth: HttpRunnable = async (get): AsyncResult<any, string> => {
+    const logger = get(Logger);
+    const httpClient = get(HttpClient);
+    logger.info("Checking server health...");
+    try {
+        const response = await httpClient.get("/api/health");
+        logger.info("Server health: " + JSON.stringify(response));
+        return Ok(response);
+    }
+    catch (error) {
+        logger.error("Failed to check server health: " + error);
+        return Err("Failed to check server health");
+    }
+}
+
+async function run() {
+    const sendMessageResult = await httpScope.run(sendMessage);
+    if (sendMessageResult.ok) {
+        console.log("Message response:", sendMessageResult.value);
+    } else {
+        console.error("Error sending message:", sendMessageResult.error);
+    }
+
+    const healthResult = await httpScope.run(sendHealth);
+    if (healthResult.ok) {
+        console.log("Health response:", healthResult.value);
+    } else {
+        console.error("Error checking health:", healthResult.error);
+    }
+}
+
+```
 
 ## Utilities
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pippenly/ts-utils",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "",
   "type": "module",
   "main": "./dist/index.js",

package/src/result/sync/index.ts

@@ -1,3 +1,5 @@
+import type { AsyncResult } from "../async/index.js";
+
 export type Ok<T> = {
     ok: true;
     value: T;
@@ -19,6 +21,9 @@ export function Err<E>(error: E, code?: number): Err<E> {
     return { ok: false, error, code };
 }
 
+export type InferOk<R> = R extends Result<infer T, any> | AsyncResult<infer T, any> ? T : never;
+export type InferErr<R> = R extends Result<any, infer E> | AsyncResult<any, infer E> ? E : never;
+
 export function tryCatch<T, E>(fn: () => T, onErr: (e: unknown) => E): Result<T, E> {
     try {
         return Ok(fn());

package/src/scope/scope.ts

@@ -1,4 +1,4 @@
-import { type Result, Ok, Err } from "@/result/index.js";
+import { type Result, Ok, Err, type InferOk, type InferErr, type AsyncResult } from "@/result/index.js";
 
 type Brand<K> = {
     __brand: K;
@@ -8,59 +8,66 @@ type SimpleError = {
     message: string;
 };
 
-type Ctor<T> = new (...args: any[]) => T;
-
 export type InjectorError = SimpleError & Brand<"InjectorError">;
 
-export type Scope<TDeps extends readonly Ctor<any>[]> = {
-    provide: <C extends TDeps[number]>(ctor: C, instance: InstanceType<C>) => Result<Scope<TDeps>, InjectorError>;
-    run: <R>(fn: (get: <C extends TDeps[number]>(ctor: C) => Result<InstanceType<C>, InjectorError>) => R) => R;
-    finalize: <R>(fn: (get: <C extends TDeps[number]>(ctor: C) => Result<InstanceType<C>, InjectorError>) => R) => R;
+export type Token<T> = {
+    readonly id: symbol;
+    readonly name: string;
+    readonly _type: T;
+};
+
+export function token<T>(name: string): Token<T> {
+    return { id: Symbol(name), name } as Token<T>;
+}
+
+type TokenType<T> = T extends Token<infer U> ? U : never;
+
+export type Scope<TDeps extends readonly Token<any>[]> = {
+    provide: <C extends TDeps[number]>(token: C, instance: TokenType<C>) => Scope<TDeps>;
+    run: <R>(fn: (get: <C extends TDeps[number]>(token: C) => TokenType<C>) => R) => R;
     [Symbol.dispose]: () => void;
 };
 
-export type AsyncScope<TDeps extends readonly Ctor<any>[]> = {
-    provide: <C extends TDeps[number]>(ctor: C, instance: InstanceType<C>) => Result<AsyncScope<TDeps>, InjectorError>;
-    run: <R>(fn: (get: <C extends TDeps[number]>(ctor: C) => Result<InstanceType<C>, InjectorError>) => Promise<R>) => Promise<R>;
-    finalize: <R>(fn: (get: <C extends TDeps[number]>(ctor: C) => Result<InstanceType<C>, InjectorError>) => Promise<R>) => Promise<R>;
+export type AsyncScope<TDeps extends readonly Token<any>[]> = {
+    provide: <C extends TDeps[number]>(token: C, instance: TokenType<C>) => AsyncScope<TDeps>;
+    run: <R>(fn: (get: <C extends TDeps[number]>(token: C) => TokenType<C>) => Promise<R>) => Promise<R>;
     [Symbol.asyncDispose]: () => Promise<void>;
 };
 
-export function scope<TDeps extends ReadonlyArray<Ctor<any>>>(...deps: TDeps): Scope<TDeps> {
+export function scope<TDeps extends ReadonlyArray<Token<any>>>(...deps: TDeps): Scope<TDeps> {
     return createScope(deps, new Map());
 }
 
-export function asyncScope<TDeps extends ReadonlyArray<Ctor<any>>>(...deps: TDeps): AsyncScope<TDeps> {
+export function asyncScope<TDeps extends ReadonlyArray<Token<any>>>(...deps: TDeps): AsyncScope<TDeps> {
     return createAsyncScope(deps, new Map());
 }
 
-function createScope<TDeps extends ReadonlyArray<Ctor<any>>>(
+function createScope<TDeps extends ReadonlyArray<Token<any>>>(
     deps: TDeps,
-    instances: Map<Ctor<any>, any>,
+    instances: Map<symbol, any>,
 ): Scope<TDeps> {
-    const find = <C extends TDeps[number]>(ctor: C): Result<InstanceType<C>, InjectorError> => {
-        if (!deps.includes(ctor)) {
-            return Err(taggedError("InjectorError", `Dependency ${ctor.name} is not registered in this scope.`));
+    const ids = new Set(deps.map(d => d.id));
+
+    const find = <C extends TDeps[number]>(t: C): TokenType<C> => {
+        if (!ids.has(t.id)) {
+            throw new Error(`Dependency "${t.name}" is not registered in this scope.`);
         }
-        if (!instances.has(ctor)) {
-            return Err(taggedError("InjectorError", `Dependency ${ctor.name} has not been provided.`));
+        if (!instances.has(t.id)) {
+            throw new Error(`Dependency "${t.name}" has not been provided.`);
         }
-        return Ok(instances.get(ctor)!);
+        return instances.get(t.id)!;
     };
 
     return {
-        provide<C extends TDeps[number]>(ctor: C, instance: InstanceType<C>): Result<Scope<TDeps>, InjectorError> {
-            if (!deps.includes(ctor)) {
-                return Err(taggedError("InjectorError", `Cannot provide instance for ${ctor.name}: not registered in this scope.`));
+        provide<C extends TDeps[number]>(t: C, instance: TokenType<C>): Scope<TDeps> {
+            if (!ids.has(t.id)) {
+                throw new Error(`Cannot provide "${t.name}": not registered in this scope.`);
             }
             const next = new Map(instances);
-            next.set(ctor, instance);
-            return Ok(createScope(deps, next));
-        },
-        run<R>(fn: (get: <C extends TDeps[number]>(ctor: C) => Result<InstanceType<C>, InjectorError>) => R): R {
-            return fn(find);
+            next.set(t.id, instance);
+            return createScope(deps, next);
         },
-        finalize<R>(fn: (get: <C extends TDeps[number]>(ctor: C) => Result<InstanceType<C>, InjectorError>) => R): R {
+        run<R>(fn: (get: <C extends TDeps[number]>(t: C) => TokenType<C>) => R): R {
             return fn(find);
         },
         [Symbol.dispose]() {
@@ -69,34 +76,33 @@ function createScope<TDeps extends ReadonlyArray<Ctor<any>>>(
     };
 }
 
-function createAsyncScope<TDeps extends ReadonlyArray<Ctor<any>>>(
+function createAsyncScope<TDeps extends ReadonlyArray<Token<any>>>(
     deps: TDeps,
-    instances: Map<Ctor<any>, any>,
+    instances: Map<symbol, any>,
 ): AsyncScope<TDeps> {
-    const find = <C extends TDeps[number]>(ctor: C): Result<InstanceType<C>, InjectorError> => {
-        if (!deps.includes(ctor)) {
-            return Err(taggedError("InjectorError", `Dependency ${ctor.name} is not registered in this scope.`));
+    const ids = new Set(deps.map(d => d.id));
+
+    const find = <C extends TDeps[number]>(t: C): TokenType<C> => {
+        if (!ids.has(t.id)) {
+            throw new Error(`Dependency "${t.name}" is not registered in this scope.`);
         }
-        if (!instances.has(ctor)) {
-            return Err(taggedError("InjectorError", `Dependency ${ctor.name} has not been provided.`));
+        if (!instances.has(t.id)) {
+            throw new Error(`Dependency "${t.name}" has not been provided.`);
         }
-        return Ok(instances.get(ctor)!);
+        return instances.get(t.id)!;
     };
 
     return {
-        provide<C extends TDeps[number]>(ctor: C, instance: InstanceType<C>): Result<AsyncScope<TDeps>, InjectorError> {
-            if (!deps.includes(ctor)) {
-                return Err(taggedError("InjectorError", `Cannot provide instance for ${ctor.name}: not registered in this scope.`));
+        provide<C extends TDeps[number]>(t: C, instance: TokenType<C>): AsyncScope<TDeps> {
+            if (!ids.has(t.id)) {
+                throw new Error(`Cannot provide "${t.name}": not registered in this scope.`);
             }
             const next = new Map(instances);
-            next.set(ctor, instance);
-            return Ok(createAsyncScope(deps, next));
+            next.set(t.id, instance);
+            return createAsyncScope(deps, next);
         },
-        async run<R>(fn: (get: <C extends TDeps[number]>(ctor: C) => Result<InstanceType<C>, InjectorError>) => Promise<R>): Promise<R> {
-            return fn(find);
-        },
-        async finalize<R>(fn: (get: <C extends TDeps[number]>(ctor: C) => Result<InstanceType<C>, InjectorError>) => Promise<R>): Promise<R> {
-            return fn(find);
+        async run<R>(fn: (get: <C extends TDeps[number]>(t: C) => TokenType<C>) => Promise<R>): Promise<R> {
+            return await fn(find);
         },
         async [Symbol.asyncDispose]() {
             instances.clear();
@@ -104,9 +110,12 @@ function createAsyncScope<TDeps extends ReadonlyArray<Ctor<any>>>(
     };
 }
 
-function taggedError<K extends string>(brand: K, message: string): Brand<K> & SimpleError {
-    return {
-        __brand: brand,
-        message,
-    };
-}
+type InferDeps<T> = T extends Scope<infer D> | AsyncScope<infer D> ? D : never;
+
+export type Runnable<TScope extends Scope<any>, TResult> = (
+    get: <C extends InferDeps<TScope>[number]>(token: C) => TokenType<C>
+) => TResult;
+
+export type AsyncRunnable<TScope extends AsyncScope<any>, TResult> = (
+    get: <C extends InferDeps<TScope>[number]>(token: C) => TokenType<C>
+) => Promise<TResult>;