@shaferllc/keel 0.36.0 → 0.58.0

package/dist/core/storage.js

@@ -0,0 +1,98 @@
+/**
+ * File storage over a pluggable `Disk` — like the database and mail layers, the
+ * core imports no filesystem or SDK, so it runs on Node and the edge. Point a
+ * disk at the local filesystem (Node), S3 (`fetch`), or a Cloudflare R2 binding;
+ * `MemoryDisk` is the built-in default for tests.
+ *
+ *   setDisk(new MemoryDisk());                 // or setDisk(r2Disk(env.BUCKET))
+ *   await storage().put("avatars/1.png", bytes);
+ *   const bytes = await storage().get("avatars/1.png");
+ *   const url = storage().url("avatars/1.png");
+ *
+ * Register several disks by name and select one with `storage("s3")`.
+ */
+function toBytes(contents) {
+    if (typeof contents === "string")
+        return new TextEncoder().encode(contents);
+    if (contents instanceof Uint8Array)
+        return contents;
+    return new Uint8Array(contents);
+}
+/* ------------------------------ memory disk ------------------------------- */
+/** An in-memory `Disk` — the default; ideal for tests. Not shared across processes. */
+export class MemoryDisk {
+    baseUrl;
+    files = new Map();
+    constructor(baseUrl = "/storage") {
+        this.baseUrl = baseUrl;
+    }
+    async put(path, bytes) {
+        this.files.set(path, bytes);
+    }
+    async get(path) {
+        return this.files.get(path) ?? null;
+    }
+    async exists(path) {
+        return this.files.has(path);
+    }
+    async delete(path) {
+        this.files.delete(path);
+    }
+    async list(prefix = "") {
+        return [...this.files.keys()].filter((p) => p.startsWith(prefix)).sort();
+    }
+    url(path) {
+        return `${this.baseUrl}/${path}`;
+    }
+}
+/* -------------------------------- storage --------------------------------- */
+export class Storage {
+    disk;
+    constructor(disk) {
+        this.disk = disk;
+    }
+    /** Write a file (string, bytes, or ArrayBuffer — strings are UTF-8 encoded). */
+    put(path, contents) {
+        return this.disk.put(path, toBytes(contents));
+    }
+    /** Read a file's raw bytes, or null if it doesn't exist. */
+    get(path) {
+        return this.disk.get(path);
+    }
+    /** Read a file as UTF-8 text, or null if it doesn't exist. */
+    async getText(path) {
+        const bytes = await this.disk.get(path);
+        return bytes == null ? null : new TextDecoder().decode(bytes);
+    }
+    exists(path) {
+        return this.disk.exists(path);
+    }
+    delete(path) {
+        return this.disk.delete(path);
+    }
+    list(prefix) {
+        return this.disk.list(prefix);
+    }
+    url(path) {
+        return this.disk.url(path);
+    }
+    /** The underlying driver, for backend-specific operations. */
+    get driver() {
+        return this.disk;
+    }
+}
+/* -------------------------------- global ---------------------------------- */
+const disks = new Map([["default", new Storage(new MemoryDisk())]]);
+/** Register a disk, optionally under a name (default: `"default"`). */
+export function setDisk(disk, name = "default") {
+    const store = new Storage(disk);
+    disks.set(name, store);
+    return store;
+}
+/** The default disk, or a named one registered with `setDisk(disk, name)`. */
+export function storage(name = "default") {
+    const store = disks.get(name);
+    if (!store)
+        throw new Error(`No storage disk named "${name}". Register it with setDisk().`);
+    return store;
+}

package/dist/core/template.d.ts

@@ -0,0 +1,50 @@
+/**
+ * A string templating engine in the spirit of AdonisJS Edge — `{{ }}`
+ * interpolation and `@`-prefixed tags for logic, includes, layouts, and
+ * components.
+ *
+ *   const t = new TemplateEngine();
+ *   t.register("hello", "Hello, {{ name }}!");
+ *   await t.render("hello", { name: "Ada" }); // "Hello, Ada!"
+ *
+ * Unlike engines that compile templates to a function via `eval`/`new
+ * Function`, this one *interprets* them against a small, safe expression
+ * evaluator — no dynamic code generation — so it runs unchanged on Node and on
+ * Cloudflare Workers (where `eval` is forbidden). The expression language is a
+ * practical subset of JS: literals, property/index access, method and helper
+ * calls, the usual operators, ternaries, arrays/objects, and `|` filters.
+ */
+/** HTML-escape a value for safe interpolation. */
+export declare function escapeHtml(value: unknown): string;
+export type Filter = (value: unknown, ...args: unknown[]) => unknown;
+export interface RenderContext {
+    sections: Record<string, string>;
+    slots: Record<string, string>;
+}
+export declare class TemplateEngine {
+    private templates;
+    private globals;
+    private filters;
+    constructor();
+    /** Register a template by name from its source string. */
+    register(name: string, source: string): this;
+    /** Register many templates at once (e.g. a Node loader reads files and passes them here). */
+    registerAll(sources: Record<string, string>): this;
+    /** True if a template is registered. */
+    has(name: string): boolean;
+    /** Expose a value/function to every template as a global. */
+    global(name: string, value: unknown): this;
+    /** Register a `{{ value | name }}` filter. */
+    filter(name: string, fn: Filter): this;
+    /** Render a registered template with the given state. */
+    render(name: string, state?: Record<string, unknown>): Promise<string>;
+    private ev;
+    private renderNodes;
+    private renderNode;
+}
+/** The default template engine (register templates/globals/filters on it). */
+export declare function templates(): TemplateEngine;
+/** Replace the default template engine. */
+export declare function setTemplateEngine(e: TemplateEngine): TemplateEngine;
+/** Render a registered template on the default engine. */
+export declare function render(name: string, state?: Record<string, unknown>): Promise<string>;