@pippenly/ts-utils 1.0.1 → 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.1",
+  "version": "1.0.5",
   "description": "",
   "type": "module",
   "main": "./dist/index.js",

package/src/dom/resin.ts

@@ -13,6 +13,7 @@ type BoundResin<T, E extends HTMLElement> = Resin<T>
 
 type BindingOptions<T, E extends HTMLElement, Mapped = T> = {
     bindTo?: 'innerText' | 'textContent' | 'innerHTML' | 'value';
+    stringParse?: 'naive' | 'sanitized'; // try to prevent XSS when using bindTo with innerHTML
     map?: (value: T) => Mapped;
     tap?: (value: Mapped, element: E) => void;
     if?: (value: Mapped) => boolean;
@@ -128,6 +129,8 @@ export function bind<T, E extends HTMLElement>(resin: Resin<T>, element: E, opti
                     element.textContent = String(mappedValue);
                     break;
                 case "innerHTML":
+                    console.warn("Using bindTo 'innerHTML' can lead to XSS vulnerabilities if the value is not properly sanitized.");
+                    // TODO: Add sanitizer dependency
                     element.innerHTML = String(mappedValue);
                     break;
                 case "value":

package/src/index.ts

@@ -1,2 +1,4 @@
 export * from './result/index.js';
 export * from './utils/index.js';
+export * from './scope/index.js';
+export * from './dom/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/index.ts

@@ -0,0 +1 @@
+export * from './scope.js';

package/src/scope/scope.ts

@@ -0,0 +1,121 @@
+import { type Result, Ok, Err, type InferOk, type InferErr, type AsyncResult } from "@/result/index.js";
+
+type Brand<K> = {
+    __brand: K;
+};
+
+type SimpleError = {
+    message: string;
+};
+
+export type InjectorError = SimpleError & Brand<"InjectorError">;
+
+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 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<Token<any>>>(...deps: TDeps): Scope<TDeps> {
+    return createScope(deps, new Map());
+}
+
+export function asyncScope<TDeps extends ReadonlyArray<Token<any>>>(...deps: TDeps): AsyncScope<TDeps> {
+    return createAsyncScope(deps, new Map());
+}
+
+function createScope<TDeps extends ReadonlyArray<Token<any>>>(
+    deps: TDeps,
+    instances: Map<symbol, any>,
+): Scope<TDeps> {
+    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(t.id)) {
+            throw new Error(`Dependency "${t.name}" has not been provided.`);
+        }
+        return instances.get(t.id)!;
+    };
+
+    return {
+        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(t.id, instance);
+            return createScope(deps, next);
+        },
+        run<R>(fn: (get: <C extends TDeps[number]>(t: C) => TokenType<C>) => R): R {
+            return fn(find);
+        },
+        [Symbol.dispose]() {
+            instances.clear();
+        },
+    };
+}
+
+function createAsyncScope<TDeps extends ReadonlyArray<Token<any>>>(
+    deps: TDeps,
+    instances: Map<symbol, any>,
+): AsyncScope<TDeps> {
+    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(t.id)) {
+            throw new Error(`Dependency "${t.name}" has not been provided.`);
+        }
+        return instances.get(t.id)!;
+    };
+
+    return {
+        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(t.id, instance);
+            return createAsyncScope(deps, next);
+        },
+        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();
+        },
+    };
+}
+
+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>;