mates 0.3.0 → 0.3.2

package/dist/indexdb/index.d.ts

@@ -0,0 +1,3 @@
+export { indexDB } from "./indexdb";
+export type { DBInstanceType, DBTableAtom, DBTableType, IDBKey, IndexDBConfig, IndexQueryBuilderType, MigratorType, RangeBuilder, TransactionScopeType, } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/indexdb/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/indexdb/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,YAAY,EACV,cAAc,EACd,WAAW,EACX,WAAW,EACX,MAAM,EACN,aAAa,EACb,qBAAqB,EACrB,YAAY,EACZ,YAAY,EACZ,oBAAoB,GACrB,MAAM,SAAS,CAAC"}

package/dist/indexdb/indexdb.d.ts

@@ -0,0 +1,86 @@
+import type { DBInstanceType, IndexDBConfig } from "./types";
+/**
+ * Opens (or creates / upgrades) an IndexedDB database and returns a typed
+ * `DBInstanceType` handle.
+ *
+ * **SSR:** rejects immediately — IndexedDB is a browser-only API.
+ *
+ * @param name    Database name.
+ * @param config  `{ version, upgrade? }` — provide `upgrade(migrator, oldVersion)`
+ *                to define the schema and handle migrations.
+ *
+ * @example
+ * ```ts
+ * interface User { id: string; name: string; age: number; role: string; createdAt: number }
+ *
+ * const db = await indexDB("app-db", {
+ *   version: 2,
+ *   upgrade(migrator, oldVersion) {
+ *     if (oldVersion < 1) {
+ *       migrator.createTable("users", "id", ["age", "role", "createdAt"]);
+ *     }
+ *     if (oldVersion < 2) {
+ *       migrator.addIndex("users", "name");
+ *     }
+ *   },
+ * });
+ *
+ * const users = db.table<User>("users", "id");
+ *
+ * // ── Writes ───────────────────────────────────────────────────────────────
+ * await users.add({ id: "u1", name: "Alice", age: 30, role: "admin", createdAt: Date.now() });
+ * await users.set("u1", { ...updated });
+ * await users.update("u1", (u) => { u.age += 1; });
+ * await users.delete("u1");
+ * await users.clear();
+ *
+ * // ── Point reads ──────────────────────────────────────────────────────────
+ * await users.get("u1");    // User | undefined
+ * await users.has("u1");    // boolean
+ * await users.count();      // number
+ *
+ * // ── All rows ─────────────────────────────────────────────────────────────
+ * const all = await users.toArray();     // DBTableAtom<User>
+ * all();                                 // User[] — reactive
+ *
+ * // ── Direct pagination (cursor-based, efficient) ───────────────────────────
+ * const p1 = await users.page(1, 20);   // DBTableAtom<User>
+ *
+ * // ── Native index filter — only reads matching rows ────────────────────────
+ * const admins   = await users.filterByIndex("role", (r) => r.equals("admin")).toArray();
+ * const adults   = await users.filterByIndex("age",  (r) => r.greaterThan(18)).page(1, 20);
+ * const alices   = await users.filterByIndex("name", (r) => r.startsWith("Al")).toArray();
+ * const midRange = await users.filterByIndex("age",  (r) => r.between(20, 40)).toArray();
+ *
+ * // ── Native index sort — cursor-driven, no JS sort ────────────────────────
+ * const byDate   = await users.sortByIndex("createdAt", "desc").page(1, 20);
+ *
+ * // ── Combined: same index → single cursor pass ─────────────────────────────
+ * const adminsByDate = await users
+ *   .filterByIndex("role", (r) => r.equals("admin"))
+ *   .sortByIndex("role", "asc")          // same index → one cursor, zero JS
+ *   .page(1, 20);
+ *
+ * // ── Combined: different indexes → filter native, sort in JS ──────────────
+ * const adultsByDate = await users
+ *   .filterByIndex("age", (r) => r.greaterThan(18))
+ *   .sortByIndex("createdAt", "desc")    // different → JS sort on subset only
+ *   .page(1, 20);
+ *
+ * // ── Item-level atom mutations (write-through to IDB) ─────────────────────
+ * await byDate.updateItem("u1", (u) => { u.name = "Bob"; });
+ * await byDate.setItem("u1", newUser);
+ * await byDate.removeItem("u1");
+ * await byDate.refresh();               // re-run query, replace atom value
+ *
+ * // ── Atomic transaction ───────────────────────────────────────────────────
+ * await db.transaction(["users", "logs"], async (tx) => {
+ *   await tx.table<User>("users", "id").update("u1", (u) => { u.role = "mod"; });
+ *   await tx.table<Log>("logs",  "id").add({ id: "l1", userId: "u1", action: "role_change" });
+ * });
+ *
+ * db.close();
+ * ```
+ */
+export declare function indexDB(name: string, config: IndexDBConfig): Promise<DBInstanceType>;
+//# sourceMappingURL=indexdb.d.ts.map

package/dist/indexdb/indexdb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexdb.d.ts","sourceRoot":"","sources":["../../lib/indexdb/indexdb.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,cAAc,EAId,aAAa,EAKd,MAAM,SAAS,CAAC;AA8YjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkFG;AACH,wBAAgB,OAAO,CACrB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,cAAc,CAAC,CAgFzB"}

package/dist/indexdb/types.d.ts

@@ -0,0 +1,249 @@
+import type { AtomType } from "../Mutables/atom/atom";
+/** Alias for the browser's `IDBValidKey` union type. */
+export type IDBKey = IDBValidKey;
+/**
+ * Passed to the `upgrade` callback when a database version change is detected.
+ * Use this to define or evolve the schema — create stores, add/remove indexes,
+ * or drop obsolete stores.
+ *
+ * All methods are no-ops when the target already exists (or doesn't, for
+ * removals), so conditional guards like `if (oldVersion < 2)` are sufficient
+ * without extra existence checks.
+ */
+export type MigratorType = {
+    /**
+     * Creates a new object store with an inline primary key.
+     * No-op if the store already exists.
+     *
+     * @param name        Store name.
+     * @param primaryKey  Field name used as the keyPath (inline key).
+     * @param indexes     Optional secondary index field names to create.
+     */
+    createTable(name: string, primaryKey: string, indexes?: string[]): void;
+    /**
+     * Adds a secondary index to an existing store.
+     * No-op if the index already exists.
+     *
+     * @param storeName  Target object store name.
+     * @param indexName  Field name to index.
+     * @param options    Optional `IDBIndexParameters` (e.g. `{ unique: true }`).
+     */
+    addIndex(storeName: string, indexName: string, options?: IDBIndexParameters): void;
+    /**
+     * Removes a secondary index from an existing store.
+     * No-op if the index does not exist.
+     */
+    removeIndex(storeName: string, indexName: string): void;
+    /**
+     * Drops an entire object store.
+     * No-op if the store does not exist.
+     */
+    dropTable(name: string): void;
+};
+export type IndexDBConfig = {
+    /** Target database version. Increment this to trigger the `upgrade` callback. */
+    version: number;
+    /**
+     * Called when the database is created or upgraded to the new `version`.
+     *
+     * @param migrator   Schema helper — use `createTable`, `addIndex`, etc.
+     * @param oldVersion Previous version number (`0` for a brand-new database).
+     */
+    upgrade?: (migrator: MigratorType, oldVersion: number) => void;
+};
+/**
+ * Fluent helper passed to `filterByIndex()`.
+ * Wraps the static `IDBKeyRange` factory methods with readable names.
+ *
+ * @example
+ * ```ts
+ * users.filterByIndex("age",  (r) => r.greaterThan(18))
+ * users.filterByIndex("role", (r) => r.equals("admin"))
+ * users.filterByIndex("name", (r) => r.startsWith("Al"))
+ * users.filterByIndex("price",(r) => r.between(10, 100))
+ * ```
+ */
+export type RangeBuilder = {
+    /** Matches only the exact `value`. Wraps `IDBKeyRange.only`. */
+    equals(value: IDBValidKey): IDBKeyRange;
+    /** Matches keys strictly greater than `value`. Wraps `IDBKeyRange.lowerBound(value, true)`. */
+    greaterThan(value: IDBValidKey): IDBKeyRange;
+    /** Matches keys greater than or equal to `value`. Wraps `IDBKeyRange.lowerBound(value, false)`. */
+    greaterThanOrEqual(value: IDBValidKey): IDBKeyRange;
+    /** Matches keys strictly less than `value`. Wraps `IDBKeyRange.upperBound(value, true)`. */
+    lessThan(value: IDBValidKey): IDBKeyRange;
+    /** Matches keys less than or equal to `value`. Wraps `IDBKeyRange.upperBound(value, false)`. */
+    lessThanOrEqual(value: IDBValidKey): IDBKeyRange;
+    /**
+     * Matches keys between `lower` and `upper`.
+     * Bounds are **inclusive** by default.
+     * Wraps `IDBKeyRange.bound`.
+     *
+     * @param options.lowerOpen  Exclude the lower bound (default `false`).
+     * @param options.upperOpen  Exclude the upper bound (default `false`).
+     */
+    between(lower: IDBValidKey, upper: IDBValidKey, options?: {
+        lowerOpen?: boolean;
+        upperOpen?: boolean;
+    }): IDBKeyRange;
+    /**
+     * Matches all string keys that begin with `prefix`.
+     * Uses the range `[prefix, prefix + "\uffff"]`.
+     */
+    startsWith(prefix: string): IDBKeyRange;
+};
+/**
+ * Lazy, immutable native-IDB query chain returned by `filterByIndex()` and
+ * `sortByIndex()`.
+ *
+ * Nothing runs against IndexedDB until a terminal operation (`toArray` /
+ * `page`) is called.  Chaining methods always return a **new** builder so the
+ * original is never mutated.
+ *
+ * @template T  Row type.
+ */
+export type IndexQueryBuilderType<T> = {
+    /**
+     * Narrow results to a key range on a secondary index.
+     * Uses a native `IDBKeyRange` — no JS-side scanning.
+     *
+     * Replaces any previously set index filter on this chain.
+     *
+     * @param indexName  Secondary index name (must exist in the schema).
+     * @param fn         Receives a {@link RangeBuilder} and returns an
+     *                   `IDBKeyRange`.
+     */
+    filterByIndex(indexName: string, fn: (r: RangeBuilder) => IDBKeyRange): IndexQueryBuilderType<T>;
+    /**
+     * Return rows in the natural order of a secondary index.
+     * Uses a native IDB cursor — no JS-side sort.
+     *
+     * When combined with `filterByIndex` on the **same** index, a single cursor
+     * pass performs both operations.  When the indexes differ, the filter runs
+     * natively and the sort falls back to JS on the filtered subset only.
+     *
+     * @param indexName  Secondary index name.
+     * @param direction  `"asc"` (default) or `"desc"`.
+     */
+    sortByIndex(indexName: string, direction?: "asc" | "desc"): IndexQueryBuilderType<T>;
+    /**
+     * Execute the query and return a reactive `DBTableAtom<T>` of all matching
+     * rows.
+     */
+    toArray(): Promise<DBTableAtom<T>>;
+    /**
+     * Execute the query and return a reactive `DBTableAtom<T>` of one page.
+     *
+     * When `sortByIndex` is active, skipping is done via `cursor.advance()` —
+     * IDB never loads the skipped rows into memory.
+     *
+     * @param pageNum  1-based page number.
+     * @param perPage  Rows per page.
+     */
+    page(pageNum: number, perPage: number): Promise<DBTableAtom<T>>;
+};
+/**
+ * Reactive array atom returned by `.toArray()` / `.page()`.
+ *
+ * Behaves like a plain atom — callable (`result()`), participates in the
+ * reactive graph, has `__subscribe`, `__version__`, etc. — but replaces the
+ * generic `set` / `update` with item-level mutations that also write back to
+ * IndexedDB.
+ *
+ * @template T  Row type.
+ */
+export type DBTableAtom<T> = Omit<AtomType<T[]>, "set" | "update"> & {
+    /**
+     * Mutate one row in-place via a draft function, then persist to IDB.
+     * No-op when the key is not found in the current snapshot.
+     */
+    updateItem(key: IDBKey, fn: (item: T) => void): Promise<void>;
+    /**
+     * Replace one row entirely, then persist to IDB.
+     * No-op when the key is not found in the current snapshot.
+     */
+    setItem(key: IDBKey, item: T): Promise<void>;
+    /**
+     * Remove one row from the local snapshot and delete it from IDB.
+     * No-op when the key is not found in the current snapshot.
+     */
+    removeItem(key: IDBKey): Promise<void>;
+    /**
+     * Re-execute the original query (filters, sort, pagination included) and
+     * replace the atom's value with the fresh results.
+     */
+    refresh(): Promise<void>;
+    /** Discriminator tag — always `"dbTableAtom"`. */
+    readonly name: "dbTableAtom";
+};
+/**
+ * Typed handle to an IndexedDB object store.
+ *
+ * Extends `IndexQueryBuilderType` — `filterByIndex`, `sortByIndex`,
+ * `toArray`, and `page` are all available directly on the table.
+ *
+ * @template T  Row type.
+ */
+export type DBTableType<T> = IndexQueryBuilderType<T> & {
+    /**
+     * Insert a new row.
+     * Rejects when an item with the same primary key already exists.
+     *
+     * @returns The primary key of the newly inserted item.
+     */
+    add(item: T): Promise<IDBValidKey>;
+    /**
+     * Upsert a row — insert if absent, replace if present.
+     * The key is read from the item's `keyPath` field, so it must be correct.
+     *
+     * @param key   For call-site clarity; the actual IDB key comes from the
+     *              item's keyPath field.
+     * @param item  Full replacement item.
+     */
+    set(key: IDBKey, item: T): Promise<void>;
+    /**
+     * Read a row by key, apply a draft mutation, then write it back atomically.
+     * No-op when the key does not exist in the store.
+     */
+    update(key: IDBKey, fn: (item: T) => void): Promise<void>;
+    /** Delete a row by primary key. */
+    delete(key: IDBKey): Promise<void>;
+    /** Remove **all** rows from the store. */
+    clear(): Promise<void>;
+    /** Return the total number of rows in the store. */
+    count(): Promise<number>;
+    /** Fetch a single row by primary key, or `undefined` when absent. */
+    get(key: IDBKey): Promise<T | undefined>;
+    /** Return `true` when a row with the given primary key exists. */
+    has(key: IDBKey): Promise<boolean>;
+};
+/**
+ * Passed to the `db.transaction()` callback.
+ * All tables obtained from this scope share the same underlying
+ * `IDBTransaction`, ensuring atomicity across stores.
+ */
+export type TransactionScopeType = {
+    table<T>(storeName: string, primaryKey: string): DBTableType<T>;
+};
+/** Opened database handle returned by `indexDB()`. */
+export type DBInstanceType = {
+    /**
+     * Return a typed handle to an object store.
+     * The store must already exist — define it in the `upgrade` callback.
+     */
+    table<T>(storeName: string, primaryKey: string): DBTableType<T>;
+    /**
+     * Run multiple operations inside a single atomic `readwrite` transaction.
+     *
+     * If the callback throws or rejects, the transaction is automatically
+     * aborted and the error propagates to the caller.
+     *
+     * **IDB constraint:** avoid `await`-ing non-IDB promises (e.g. `fetch`)
+     * inside the callback — the transaction may auto-commit if no IDB request
+     * is pending when the microtask queue drains.
+     */
+    transaction(storeNames: string[], fn: (tx: TransactionScopeType) => Promise<void>): Promise<void>;
+    /** Close the database connection. */
+    close(): void;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/indexdb/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../lib/indexdb/types.ts"],"names":[],"mappings":"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"}

package/dist/minidb/index.d.ts

@@ -0,0 +1,3 @@
+export type { MiniDBInstance, MiniDBList, MiniDBMigrateFn, MiniDBMigrator, } from "./minidb";
+export { miniDB } from "./minidb";
+//# sourceMappingURL=index.d.ts.map

package/dist/minidb/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/minidb/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,cAAc,EACd,UAAU,EACV,eAAe,EACf,cAAc,GACf,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC"}

package/dist/minidb/minidb.d.ts

@@ -0,0 +1,105 @@
+export type MiniDBMigrator = {
+    /** Wipe all records from a list during migration. */
+    clear(listName: string): void;
+};
+export type MiniDBMigrateFn = (oldVersion: number, newVersion: number, migrator: MiniDBMigrator) => void;
+/**
+ * A reactive list backed by an IndexedDB object store.
+ *
+ * Calling `list()` returns a plain `T[]` and registers the list as a reactive
+ * dependency — components and effects re-run automatically when any item
+ * changes.  The returned array is a normal JS array so `.filter()`, `.sort()`,
+ * `.map()` etc. work directly.
+ *
+ * All write methods (`add`, `set`, `update`, `deleteRow`, `clear`) are async
+ * and persist to IndexedDB before resolving.  Every write is also broadcast to
+ * other tabs via `BroadcastChannel` so their atoms stay in sync.
+ */
+export type MiniDBList<T> = {
+    /** Reactive — returns all items as `T[]`. Tracks as a dependency. */
+    (): T[];
+    /** Reactive point lookup by id. */
+    get(id: string): T | undefined;
+    /** Reactive existence check by id. */
+    has(id: string): boolean;
+    /** Reactive item count. */
+    readonly size: number;
+    /**
+     * Add an item. Uses the item's `id` field as the key when present,
+     * otherwise auto-generates a UUID and assigns it.
+     * @returns The id used.
+     */
+    add(item: T): Promise<string>;
+    /** Upsert — insert if absent, replace if present. */
+    set(id: string, item: T): Promise<void>;
+    /** Draft-style mutation — modify the item in-place, then persist. */
+    update(id: string, fn: (item: T) => void): Promise<void>;
+    /** Delete one item by id. */
+    deleteRow(id: string): Promise<void>;
+    /** Remove all items from the list. */
+    clear(): Promise<void>;
+};
+export type MiniDBInstance = {
+    /**
+     * Returns a reactive list for the given name.
+     * The underlying IDB object store is created automatically on first call.
+     *
+     * Await calls sequentially when requesting multiple new lists — each new
+     * list may internally close and reopen the database to add the store.
+     */
+    list<T>(name: string): Promise<MiniDBList<T>>;
+};
+/**
+ * Opens (or creates) the opinionated `"mini-db"` IndexedDB database.
+ *
+ * - **Fixed name** — always `"mini-db"`, cannot be changed.
+ * - **No schema** — object stores are created automatically on first
+ *   `db.list()` call.
+ * - **Designed for ≤ 1 000 records per list** — all data is held in memory
+ *   as a reactive `mapAtom`.  Components re-render automatically on any write.
+ * - **No cursors, no indexes, no query builder** — use plain JS array methods
+ *   (`filter`, `sort`, `map`, …) on the result of `list()`.
+ * - **Cross-tab sync** — writes broadcast via `BroadcastChannel` so every
+ *   open tab's atoms reflect changes immediately without polling.
+ *
+ * @param version    App-level data version (default `1`).  Increment to
+ *                   trigger the `onMigrate` callback.
+ * @param onMigrate  Called once when `version` changes.  Use
+ *                   `migrator.clear("listName")` to wipe stale data.
+ *
+ * @example
+ * ```ts
+ * interface User { id: string; name: string; role: string }
+ *
+ * // One shared instance — open at module level, export and reuse everywhere.
+ * export const db = await miniDB(2, (oldV, newV, m) => {
+ *   if (oldV < 2) m.clear("users");
+ * });
+ *
+ * const users = await db.list<User>("users");
+ *
+ * // ── Reactive template ─────────────────────────────────────────────────────
+ * html`
+ *   ${users()
+ *     .filter(u => u.role === "admin")
+ *     .sort((a, b) => a.name.localeCompare(b.name))
+ *     .map(u => html`<li>${u.name}</li>`)}
+ * `
+ *
+ * // ── Writes (IDB + atom + broadcast to other tabs) ─────────────────────────
+ * await users.add({ id: "u1", name: "Alice", role: "admin" });
+ * await users.add({ name: "Bob", role: "user" });      // auto-generates id
+ * await users.set("u1", { id: "u1", name: "Alice B.", role: "admin" });
+ * await users.update("u1", u => { u.role = "mod"; });
+ * await users.deleteRow("u1");
+ * await users.clear();
+ *
+ * // ── Reactive reads ────────────────────────────────────────────────────────
+ * users();           // User[]
+ * users.get("u1");   // User | undefined
+ * users.has("u1");   // boolean
+ * users.size;        // number
+ * ```
+ */
+export declare function miniDB(version?: number, onMigrate?: MiniDBMigrateFn): Promise<MiniDBInstance>;
+//# sourceMappingURL=minidb.d.ts.map

package/dist/minidb/minidb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minidb.d.ts","sourceRoot":"","sources":["../../lib/minidb/minidb.ts"],"names":[],"mappings":"AAgDA,MAAM,MAAM,cAAc,GAAG;IAC3B,qDAAqD;IACrD,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,CAC5B,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,cAAc,KACrB,IAAI,CAAC;AAEV;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;IAC1B,qEAAqE;IACrE,IAAI,CAAC,EAAE,CAAC;IACR,mCAAmC;IACnC,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAAC;IAC/B,sCAAsC;IACtC,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IACzB,2BAA2B;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC9B,qDAAqD;IACrD,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxC,qEAAqE;IACrE,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzD,6BAA6B;IAC7B,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrC,sCAAsC;IACtC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B;;;;;;OAMG;IACH,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;CAC/C,CAAC;AAwNF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,wBAAsB,MAAM,CAC1B,OAAO,SAAI,EACX,SAAS,CAAC,EAAE,eAAe,GAC1B,OAAO,CAAC,cAAc,CAAC,CAqDzB"}

package/dist/portals/popup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"popup.d.ts","sourceRoot":"","sources":["../../lib/portals/popup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,cAAc,EAAE,MAAM,UAAU,CAAC;AACpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAG7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAWvD;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,OAAO,CAAC;IACZ,GAAG,IAAI,OAAO,CAAC;CAChB;AAED,2EAA2E;AAC3E,MAAM,MAAM,cAAc,GAAG,aAAa,GAAG,OAAO,CAAC;AAErD,YAAY,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,MAAM,WAAW,YAAY;IAC3B,6BAA6B;IAC7B,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,0DAA0D;IAC1D,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,kFAAkF;IAClF,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;;OAKG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;OAGG;IACH,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;IACtC;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,WAAW,KAAK,IAAI,CAAC;IAC/D;;;;;;;;;;;;;;;OAeG;IACH,IAAI,CAAC,EAAE,cAAc,CAAC;IACtB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAgQD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,KAAK,CACnB,OAAO,EAAE,cAAc,EACvB,iBAAiB,CAAC,EAAE,cAAc,GAAG,YAAY,GAChD,eAAe,CAMjB"}
+{"version":3,"file":"popup.d.ts","sourceRoot":"","sources":["../../lib/portals/popup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,cAAc,EAAE,MAAM,UAAU,CAAC;AACpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAG7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAKvD;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,OAAO,CAAC;IACZ,GAAG,IAAI,OAAO,CAAC;CAChB;AAED,2EAA2E;AAC3E,MAAM,MAAM,cAAc,GAAG,aAAa,GAAG,OAAO,CAAC;AAErD,YAAY,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,MAAM,WAAW,YAAY;IAC3B,6BAA6B;IAC7B,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,0DAA0D;IAC1D,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,kFAAkF;IAClF,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;;OAKG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;OAGG;IACH,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;IACtC;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,WAAW,KAAK,IAAI,CAAC;IAC/D;;;;;;;;;;;;;;;OAeG;IACH,IAAI,CAAC,EAAE,cAAc,CAAC;IACtB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAgQD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,KAAK,CACnB,OAAO,EAAE,cAAc,EACvB,iBAAiB,CAAC,EAAE,cAAc,GAAG,YAAY,GAChD,eAAe,CAMjB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mates",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "type": "module",
   "description": "Mates is a front end framework for building web applications",
   "main": "dist/index.esm.js",
@@ -8,16 +8,16 @@
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.esm.js",
-      "require": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "require": "./dist/index.js"
     }
   },
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "rollup -c",
+    "build": "rollup -c && tsc -p tsconfig.declarations.json",
     "dev": "rollup -c -w",
     "test": "vitest run",
     "test:watch": "vitest",
@@ -67,10 +67,10 @@
     "csstype": "^3.1.3",
     "esbuild": "^0.25.9",
     "eslint": "^8.54.0",
+    "fake-indexeddb": "^6.2.5",
     "happy-dom": "^20.5.0",
     "jest": "^29.7.0",
     "jest-environment-jsdom": "^30.0.5",
-    "lit-html": "3.2.1",
     "rimraf": "^5.0.5",
     "rollup": "^3.29.4",
     "rollup-plugin-css-only": "^4.5.5",
@@ -79,5 +79,8 @@
     "tslib": "^2.8.1",
     "typescript": "^5.3.2",
     "vitest": "^4.0.18"
+  },
+  "dependencies": {
+    "lit-html": "3.2.1"
   }
 }