@raubjo/architect-core 0.1.0 → 0.1.2

package/src/runtimes/react.tsx

@@ -1,22 +1,34 @@
 import { createContext, useContext, type ReactNode } from "react";
-import type { Container } from "inversify";
+import type {
+    ContainerContract,
+    ContainerIdentifier,
+} from "@/container/contract";
 
-const ContainerContext = createContext<Container | null>(null);
+const ContainerContext = createContext<ContainerContract | null>(null);
 
 type ApplicationProviderProps = {
-  container: Container;
-  children?: ReactNode;
+    container: ContainerContract;
+    children?: ReactNode;
 };
 
-export function ApplicationProvider({ container, children }: ApplicationProviderProps) {
-  return <ContainerContext.Provider value={container}>{children}</ContainerContext.Provider>;
+export function ApplicationProvider({
+    container,
+    children,
+}: ApplicationProviderProps) {
+    return (
+        <ContainerContext.Provider value={container}>
+            {children}
+        </ContainerContext.Provider>
+    );
 }
 
-export function useService<T>(identifier: Parameters<Container["get"]>[0]): T {
-  const container = useContext(ContainerContext);
-  if (!container) {
-    throw new Error("Application container is not available in React context.");
-  }
+export function useService<T>(identifier: ContainerIdentifier<T>): T {
+    const container = useContext(ContainerContext);
+    if (!container) {
+        throw new Error(
+            "Application container is not available in React context.",
+        );
+    }
 
-  return container.get<T>(identifier);
+    return container.make<T>(identifier);
 }

package/src/runtimes/solid.tsx

@@ -0,0 +1,30 @@
+import { createContext, createComponent, useContext, type JSX } from "solid-js";
+import type {
+    ContainerContract,
+    ContainerIdentifier,
+} from "@/container/contract";
+
+const ContainerContext = createContext<ContainerContract | null>(null);
+
+type ApplicationProviderProps = {
+    container: ContainerContract;
+    children?: JSX.Element | (() => JSX.Element);
+};
+
+export function ApplicationProvider(props: ApplicationProviderProps) {
+    return createComponent(ContainerContext.Provider, {
+        value: props.container,
+        children: props.children as never,
+    });
+}
+
+export function useService<T>(identifier: ContainerIdentifier<T>): T {
+    const container = useContext(ContainerContext);
+    if (!container) {
+        throw new Error(
+            "Application container is not available in Solid context.",
+        );
+    }
+
+    return container.make<T>(identifier);
+}

package/src/runtimes/svelte.ts

@@ -0,0 +1,23 @@
+import { getContext, setContext } from "svelte";
+import type {
+    ContainerContract,
+    ContainerIdentifier,
+} from "@/container/contract";
+
+export const containerKey: unique symbol = Symbol("application.container");
+
+export function provideContainer(container: ContainerContract): void {
+    setContext(containerKey, container);
+}
+
+export function useService<T>(identifier: ContainerIdentifier<T>): T {
+    const container =
+        getContext<ContainerContract | null>(containerKey) ?? null;
+    if (!container) {
+        throw new Error(
+            "Application container is not available in Svelte context.",
+        );
+    }
+
+    return container.make<T>(identifier);
+}

package/src/runtimes/vue.ts

@@ -0,0 +1,20 @@
+import { inject, type InjectionKey } from "vue";
+import type {
+    ContainerContract,
+    ContainerIdentifier,
+} from "@/container/contract";
+
+export const containerKey: InjectionKey<ContainerContract> = Symbol(
+    "application.container",
+);
+
+export function useService<T>(identifier: ContainerIdentifier<T>): T {
+    const container = inject(containerKey, null);
+    if (!container) {
+        throw new Error(
+            "Application container is not available in Vue context.",
+        );
+    }
+
+    return container.make<T>(identifier);
+}

package/src/solid.ts

@@ -0,0 +1,2 @@
+export { ApplicationProvider, useService } from "./runtimes/solid";
+export { default as Renderer } from "./renderers/adapters/solid";

package/src/storage/adapters/contract.ts

@@ -0,0 +1,10 @@
+export interface Adapter {
+    get<T = unknown>(key: string): Promise<T | null>;
+    set<T = unknown>(key: string, value: T): Promise<void>;
+    has(key: string): Promise<boolean>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    keys(): Promise<string[]>;
+}
+
+export type Contract = Adapter;

package/src/storage/adapters/indexed-db.ts

@@ -1,180 +1,194 @@
-import MemoryStorageAdapter from "./memory";
-import type { StorageAdapter } from "../storage";
+import MemoryStorageAdapter from "@/storage/adapters/memory";
+import type { Adapter } from "@/storage/adapters/contract";
 
 type OpenFactory = Pick<IDBFactory, "open">;
 
-export default class IndexedDbAdapter implements StorageAdapter {
-  protected fallback: StorageAdapter;
-  protected name: string;
-  protected factory: OpenFactory | null;
-  protected dbPromise: Promise<IDBDatabase> | null;
-
-  constructor(
-    options: {
-      factory?: OpenFactory | null;
-      name?: string;
-      fallback?: StorageAdapter;
-    } = {},
-  ) {
-    this.factory = options.factory ?? (globalThis.indexedDB ?? null);
-    this.name = options.name ?? "ioc-storage";
-    this.fallback = options.fallback ?? new MemoryStorageAdapter();
-    this.dbPromise = null;
-  }
-
-  protected req<T>(request: IDBRequest<T>): Promise<T> {
-    return new Promise<T>((resolve, reject) => {
-      request.onsuccess = () => resolve(request.result);
-      request.onerror = () => reject(request.error ?? new Error("IndexedDB request failed."));
-    });
-  }
-
-  protected openDb(): Promise<IDBDatabase> {
-    if (this.dbPromise) {
-      return this.dbPromise;
+export default class IndexedDbAdapter implements Adapter {
+    protected fallback: Adapter;
+    protected name: string;
+    protected factory: OpenFactory | null;
+    protected dbPromise: Promise<IDBDatabase> | null;
+
+    constructor(
+        options: {
+            factory?: OpenFactory | null;
+            name?: string;
+            fallback?: Adapter;
+        } = {},
+    ) {
+        this.factory = options.factory ?? globalThis.indexedDB ?? null;
+        this.name = options.name ?? "ioc-storage";
+        this.fallback = options.fallback ?? new MemoryStorageAdapter();
+        this.dbPromise = null;
     }
 
-    if (!this.factory) {
-      return Promise.reject(new Error("IndexedDB is not available."));
+    protected req<T>(request: IDBRequest<T>): Promise<T> {
+        return new Promise<T>((resolve, reject) => {
+            request.onsuccess = () => resolve(request.result);
+            request.onerror = () =>
+                reject(request.error ?? new Error("IndexedDB request failed."));
+        });
     }
 
-    this.dbPromise = new Promise<IDBDatabase>((resolve, reject) => {
-      const request = this.factory?.open(this.name, 1);
-      if (!request) {
-        reject(new Error("IndexedDB open request could not be created."));
-        return;
-      }
-
-      request.onupgradeneeded = () => {
-        const db = request.result;
-        if (!db.objectStoreNames.contains("kv")) {
-          db.createObjectStore("kv");
+    protected openDb(): Promise<IDBDatabase> {
+        if (this.dbPromise) {
+            return this.dbPromise;
         }
-      };
-      request.onsuccess = () => resolve(request.result);
-      request.onerror = () =>
-        reject(request.error ?? new Error("IndexedDB database could not be opened."));
-    });
 
-    return this.dbPromise;
-  }
+        if (!this.factory) {
+            return Promise.reject(new Error("IndexedDB is not available."));
+        }
 
-  protected async withStore<T>(
-    mode: IDBTransactionMode,
-    action: (store: IDBObjectStore) => Promise<T>,
-  ): Promise<T> {
-    try {
-      const db = await this.openDb();
-      const tx = db.transaction("kv", mode);
-      const store = tx.objectStore("kv");
-      return await action(store);
-    } catch (_error) {
-      return actionFallback(this.fallback, mode, action);
+        this.dbPromise = new Promise<IDBDatabase>((resolve, reject) => {
+            const request = this.factory?.open(this.name, 1);
+            if (!request) {
+                reject(
+                    new Error("IndexedDB open request could not be created."),
+                );
+                return;
+            }
+
+            request.onupgradeneeded = () => {
+                const db = request.result;
+                if (!db.objectStoreNames.contains("kv")) {
+                    db.createObjectStore("kv");
+                }
+            };
+            request.onsuccess = () => resolve(request.result);
+            request.onerror = () =>
+                reject(
+                    request.error ??
+                        new Error("IndexedDB database could not be opened."),
+                );
+        });
+
+        return this.dbPromise;
+    }
+
+    protected async withStore<T>(
+        mode: IDBTransactionMode,
+        action: (store: IDBObjectStore) => Promise<T>,
+    ): Promise<T> {
+        try {
+            const db = await this.openDb();
+            const tx = db.transaction("kv", mode);
+            const store = tx.objectStore("kv");
+            return await action(store);
+        } catch (_error) {
+            return actionFallback(this.fallback, mode, action);
+        }
+    }
+
+    async get<T = unknown>(key: string): Promise<T | null> {
+        return this.withStore("readonly", async (store) => {
+            const value = await this.req<unknown>(store.get(key));
+            return value === undefined ? null : (value as T);
+        });
+    }
+
+    async set<T = unknown>(key: string, value: T): Promise<void> {
+        await this.withStore("readwrite", async (store) => {
+            await this.req(store.put(value, key));
+            return undefined;
+        });
+    }
+
+    async has(key: string): Promise<boolean> {
+        return this.withStore("readonly", async (store) => {
+            const count = await this.req<number>(store.count(key));
+            return count > 0;
+        });
+    }
+
+    async delete(key: string): Promise<void> {
+        await this.withStore("readwrite", async (store) => {
+            await this.req(store.delete(key));
+            return undefined;
+        });
+    }
+
+    async clear(): Promise<void> {
+        await this.withStore("readwrite", async (store) => {
+            await this.req(store.clear());
+            return undefined;
+        });
+    }
+
+    async keys(): Promise<string[]> {
+        return this.withStore("readonly", async (store) => {
+            const keys = await this.req<Array<IDBValidKey>>(store.getAllKeys());
+            const normalized: string[] = [];
+            for (const key of keys) {
+                normalized.push(String(key));
+            }
+
+            return normalized;
+        });
     }
-  }
-
-  async get<T = unknown>(key: string): Promise<T | null> {
-    return this.withStore("readonly", async (store) => {
-      const value = await this.req<unknown>(store.get(key));
-      return value === undefined ? null : (value as T);
-    });
-  }
-
-  async set<T = unknown>(key: string, value: T): Promise<void> {
-    await this.withStore("readwrite", async (store) => {
-      await this.req(store.put(value, key));
-      return undefined;
-    });
-  }
-
-  async has(key: string): Promise<boolean> {
-    return this.withStore("readonly", async (store) => {
-      const count = await this.req<number>(store.count(key));
-      return count > 0;
-    });
-  }
-
-  async delete(key: string): Promise<void> {
-    await this.withStore("readwrite", async (store) => {
-      await this.req(store.delete(key));
-      return undefined;
-    });
-  }
-
-  async clear(): Promise<void> {
-    await this.withStore("readwrite", async (store) => {
-      await this.req(store.clear());
-      return undefined;
-    });
-  }
-
-  async keys(): Promise<string[]> {
-    return this.withStore("readonly", async (store) => {
-      const keys = await this.req<Array<IDBValidKey>>(store.getAllKeys());
-      const normalized: string[] = [];
-      for (const key of keys) {
-        normalized.push(String(key));
-      }
-
-      return normalized;
-    });
-  }
 }
 
 async function actionFallback<T>(
-  fallback: StorageAdapter,
-  mode: IDBTransactionMode,
-  action: (store: IDBObjectStore) => Promise<T>,
+    fallback: Adapter,
+    mode: IDBTransactionMode,
+    action: (store: IDBObjectStore) => Promise<T>,
 ): Promise<T> {
-  // Keep call sites small: map IDB actions to the same short storage contract.
-  if (mode === "readonly") {
-    const store = createReadonlyProxy(fallback);
-    return action(store as unknown as IDBObjectStore);
-  }
+    // Keep call sites small: map IDB actions to the same short storage contract.
+    if (mode === "readonly") {
+        const store = createReadonlyProxy(fallback);
+        return action(store as unknown as IDBObjectStore);
+    }
 
-  const store = createReadWriteProxy(fallback);
-  return action(store as unknown as IDBObjectStore);
+    const store = createReadWriteProxy(fallback);
+    return action(store as unknown as IDBObjectStore);
 }
 
-function createReadonlyProxy(fallback: StorageAdapter): Partial<IDBObjectStore> {
-  return {
-    get: (key: IDBValidKey) => wrapPromiseRequest(fallback.get(String(key))),
-    count: (key?: IDBValidKey | IDBKeyRange) =>
-      wrapPromiseRequest(
-        fallback.has(String(key as IDBValidKey)).then((exists) => (exists ? 1 : 0)),
-      ),
-    getAllKeys: () =>
-      wrapPromiseRequest(fallback.keys().then((keys) => keys as Array<IDBValidKey>)),
-  };
+function createReadonlyProxy(fallback: Adapter): Partial<IDBObjectStore> {
+    return {
+        get: (key: IDBValidKey) =>
+            wrapPromiseRequest(fallback.get(String(key))),
+        count: (key?: IDBValidKey | IDBKeyRange) =>
+            wrapPromiseRequest(
+                fallback
+                    .has(String(key as IDBValidKey))
+                    .then((exists) => (exists ? 1 : 0)),
+            ),
+        getAllKeys: () =>
+            wrapPromiseRequest(
+                fallback.keys().then((keys) => keys as Array<IDBValidKey>),
+            ),
+    };
 }
 
-function createReadWriteProxy(fallback: StorageAdapter): Partial<IDBObjectStore> {
-  return {
-    ...createReadonlyProxy(fallback),
-    put: (value: unknown, key?: IDBValidKey) =>
-      wrapPromiseRequest(fallback.set(String(key as IDBValidKey), value)),
-    delete: (key: IDBValidKey | IDBKeyRange) =>
-      wrapPromiseRequest(fallback.delete(String(key as IDBValidKey))),
-    clear: () => wrapPromiseRequest(fallback.clear()),
-  };
+function createReadWriteProxy(fallback: Adapter): Partial<IDBObjectStore> {
+    return {
+        ...createReadonlyProxy(fallback),
+        put: (value: unknown, key?: IDBValidKey) =>
+            wrapPromiseRequest(fallback.set(String(key as IDBValidKey), value)),
+        delete: (key: IDBValidKey | IDBKeyRange) =>
+            wrapPromiseRequest(fallback.delete(String(key as IDBValidKey))),
+        clear: () => wrapPromiseRequest(fallback.clear()),
+    };
 }
 
 function wrapPromiseRequest<T>(promise: Promise<T>): IDBRequest<T> {
-  const request: Partial<IDBRequest<T>> = {
-    onsuccess: null,
-    onerror: null,
-  };
-
-  promise.then(
-    (result) => {
-      request.result = result;
-      request.onsuccess?.call(request as IDBRequest<T>, new Event("success"));
-    },
-    (error) => {
-      request.error = error as DOMException;
-      request.onerror?.call(request as IDBRequest<T>, new Event("error"));
-    },
-  );
-
-  return request as IDBRequest<T>;
+    const request: Partial<IDBRequest<T>> = {
+        onsuccess: null,
+        onerror: null,
+    };
+
+    promise.then(
+        (result) => {
+            request.result = result;
+            request.onsuccess?.call(
+                request as IDBRequest<T>,
+                new Event("success"),
+            );
+        },
+        (error) => {
+            request.error = error as DOMException;
+            request.onerror?.call(request as IDBRequest<T>, new Event("error"));
+        },
+    );
+
+    return request as IDBRequest<T>;
 }

package/src/storage/adapters/local-storage.ts

@@ -1,46 +1,46 @@
-import type { StorageAdapter } from "../storage";
+import type { Adapter } from "@/storage/adapters/contract";
 
-export default class LocalStorageAdapter implements StorageAdapter {
-  protected storage: Storage;
+export default class LocalStorageAdapter implements Adapter {
+    protected storage: Storage;
 
-  constructor(storage: Storage = window.localStorage) {
-    this.storage = storage;
-  }
-
-  async get<T = unknown>(key: string): Promise<T | null> {
-    const value = this.storage.getItem(key);
-    if (value === null) {
-      return null;
+    constructor(storage: Storage = window.localStorage) {
+        this.storage = storage;
     }
 
-    return JSON.parse(value) as T;
-  }
+    async get<T = unknown>(key: string): Promise<T | null> {
+        const value = this.storage.getItem(key);
+        if (value === null) {
+            return null;
+        }
 
-  async set<T = unknown>(key: string, value: T): Promise<void> {
-    this.storage.setItem(key, JSON.stringify(value));
-  }
+        return JSON.parse(value) as T;
+    }
 
-  async has(key: string): Promise<boolean> {
-    return this.storage.getItem(key) !== null;
-  }
+    async set<T = unknown>(key: string, value: T): Promise<void> {
+        this.storage.setItem(key, JSON.stringify(value));
+    }
 
-  async delete(key: string): Promise<void> {
-    this.storage.removeItem(key);
-  }
+    async has(key: string): Promise<boolean> {
+        return this.storage.getItem(key) !== null;
+    }
 
-  async clear(): Promise<void> {
-    this.storage.clear();
-  }
+    async delete(key: string): Promise<void> {
+        this.storage.removeItem(key);
+    }
 
-  async keys(): Promise<string[]> {
-    const keys: string[] = [];
-    for (let i = 0; i < this.storage.length; i += 1) {
-      const key = this.storage.key(i);
-      if (key !== null) {
-        keys.push(key);
-      }
+    async clear(): Promise<void> {
+        this.storage.clear();
     }
 
-    return keys;
-  }
+    async keys(): Promise<string[]> {
+        const keys: string[] = [];
+        for (let i = 0; i < this.storage.length; i += 1) {
+            const key = this.storage.key(i);
+            if (key !== null) {
+                keys.push(key);
+            }
+        }
+
+        return keys;
+    }
 }

package/src/storage/adapters/memory.ts

@@ -1,35 +1,35 @@
-import type { StorageAdapter } from "../storage";
+import type { Adapter } from "@/storage/adapters/contract";
 
-export default class MemoryStorageAdapter implements StorageAdapter {
-  protected items = new Map<string, unknown>();
+export default class MemoryStorageAdapter implements Adapter {
+    protected items = new Map<string, unknown>();
 
-  constructor() {}
+    constructor() {}
 
-  async get<T = unknown>(key: string): Promise<T | null> {
-    if (!this.items.has(key)) {
-      return null;
-    }
+    async get<T = unknown>(key: string): Promise<T | null> {
+        if (!this.items.has(key)) {
+            return null;
+        }
 
-    return this.items.get(key) as T;
-  }
+        return this.items.get(key) as T;
+    }
 
-  async set<T = unknown>(key: string, value: T): Promise<void> {
-    this.items.set(key, value);
-  }
+    async set<T = unknown>(key: string, value: T): Promise<void> {
+        this.items.set(key, value);
+    }
 
-  async has(key: string): Promise<boolean> {
-    return this.items.has(key);
-  }
+    async has(key: string): Promise<boolean> {
+        return this.items.has(key);
+    }
 
-  async delete(key: string): Promise<void> {
-    this.items.delete(key);
-  }
+    async delete(key: string): Promise<void> {
+        this.items.delete(key);
+    }
 
-  async clear(): Promise<void> {
-    this.items.clear();
-  }
+    async clear(): Promise<void> {
+        this.items.clear();
+    }
 
-  async keys(): Promise<string[]> {
-    return Array.from(this.items.keys());
-  }
+    async keys(): Promise<string[]> {
+        return Array.from(this.items.keys());
+    }
 }