@pippenly/ts-utils 1.0.1 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pippenly/ts-utils",
-  "version": "1.0.1",
+  "version": "1.0.4",
   "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/scope/index.ts

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

package/src/scope/scope.ts

@@ -0,0 +1,112 @@
+import { type Result, Ok, Err } from "@/result/index.js";
+
+type Brand<K> = {
+    __brand: K;
+};
+
+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;
+    [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>;
+    [Symbol.asyncDispose]: () => Promise<void>;
+};
+
+export function scope<TDeps extends ReadonlyArray<Ctor<any>>>(...deps: TDeps): Scope<TDeps> {
+    return createScope(deps, new Map());
+}
+
+export function asyncScope<TDeps extends ReadonlyArray<Ctor<any>>>(...deps: TDeps): AsyncScope<TDeps> {
+    return createAsyncScope(deps, new Map());
+}
+
+function createScope<TDeps extends ReadonlyArray<Ctor<any>>>(
+    deps: TDeps,
+    instances: Map<Ctor<any>, 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.`));
+        }
+        if (!instances.has(ctor)) {
+            return Err(taggedError("InjectorError", `Dependency ${ctor.name} has not been provided.`));
+        }
+        return Ok(instances.get(ctor)!);
+    };
+
+    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.`));
+            }
+            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);
+        },
+        finalize<R>(fn: (get: <C extends TDeps[number]>(ctor: C) => Result<InstanceType<C>, InjectorError>) => R): R {
+            return fn(find);
+        },
+        [Symbol.dispose]() {
+            instances.clear();
+        },
+    };
+}
+
+function createAsyncScope<TDeps extends ReadonlyArray<Ctor<any>>>(
+    deps: TDeps,
+    instances: Map<Ctor<any>, 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.`));
+        }
+        if (!instances.has(ctor)) {
+            return Err(taggedError("InjectorError", `Dependency ${ctor.name} has not been provided.`));
+        }
+        return Ok(instances.get(ctor)!);
+    };
+
+    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.`));
+            }
+            const next = new Map(instances);
+            next.set(ctor, instance);
+            return Ok(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 [Symbol.asyncDispose]() {
+            instances.clear();
+        },
+    };
+}
+
+function taggedError<K extends string>(brand: K, message: string): Brand<K> & SimpleError {
+    return {
+        __brand: brand,
+        message,
+    };
+}