@proveanything/smartlinks 2.1.8 → 2.1.11

package/dist/persistentCache.js

@@ -5,10 +5,15 @@
 // isIdbAvailable() and wrapped in try/catch so that failures in private-
 // browsing, quota-exceeded situations, or server-side environments are always
 // silent — they never propagate errors to the caller.
+//
+// The connection itself is managed by idbConnection.ts, which re-opens it when
+// the browser closes it behind our back (iOS Safari does this when the tab is
+// backgrounded) instead of leaving the cache dead for the rest of the page.
+import { createIdbConnection } from './idbConnection.js';
 const DB_NAME = 'smartlinks-sdk-cache';
 const STORE_NAME = 'responses';
 const DB_VERSION = 1;
-let dbPromise = null;
+const connection = createIdbConnection(DB_NAME, STORE_NAME, DB_VERSION);
 /**
  * Returns true only in environments where IndexedDB is genuinely available.
  * False in Node.js, and in some private-browsing contexts that stub indexedDB
@@ -22,36 +27,13 @@ export function isIdbAvailable() {
         return false;
     }
 }
-function openDb() {
-    if (dbPromise)
-        return dbPromise;
-    dbPromise = new Promise((resolve, reject) => {
-        try {
-            const req = indexedDB.open(DB_NAME, DB_VERSION);
-            req.onupgradeneeded = (event) => {
-                const db = event.target.result;
-                if (!db.objectStoreNames.contains(STORE_NAME)) {
-                    db.createObjectStore(STORE_NAME);
-                }
-            };
-            req.onsuccess = (event) => {
-                resolve(event.target.result);
-            };
-            req.onerror = () => {
-                dbPromise = null;
-                reject(req.error);
-            };
-            req.onblocked = () => {
-                dbPromise = null;
-                reject(new Error('[smartlinks] IndexedDB open blocked'));
-            };
-        }
-        catch (err) {
-            dbPromise = null;
-            reject(err);
-        }
+/** Resolve when the transaction settles, whatever the outcome. */
+function settled(tx) {
+    return new Promise((resolve) => {
+        tx.oncomplete = () => resolve();
+        tx.onerror = () => resolve(); // quota exceeded etc — fail silently
+        tx.onabort = () => resolve();
     });
-    return dbPromise;
 }
 /**
  * Read an entry from IndexedDB.
@@ -62,18 +44,11 @@ export async function idbGet(key) {
     if (!isIdbAvailable())
         return null;
     try {
-        const db = await openDb();
-        return new Promise((resolve) => {
-            try {
-                const tx = db.transaction(STORE_NAME, 'readonly');
-                const req = tx.objectStore(STORE_NAME).get(key);
-                req.onsuccess = () => { var _a; return resolve((_a = req.result) !== null && _a !== void 0 ? _a : null); };
-                req.onerror = () => resolve(null);
-            }
-            catch (_a) {
-                resolve(null);
-            }
-        });
+        return await connection.run('readonly', (store) => new Promise((resolve) => {
+            const req = store.get(key);
+            req.onsuccess = () => { var _a; return resolve((_a = req.result) !== null && _a !== void 0 ? _a : null); };
+            req.onerror = () => resolve(null);
+        }));
     }
     catch (_a) {
         return null;
@@ -88,18 +63,9 @@ export async function idbSet(key, entry) {
     if (!isIdbAvailable())
         return;
     try {
-        const db = await openDb();
-        await new Promise((resolve) => {
-            try {
-                const tx = db.transaction(STORE_NAME, 'readwrite');
-                tx.objectStore(STORE_NAME).put(entry, key);
-                tx.oncomplete = () => resolve();
-                tx.onerror = () => resolve(); // quota exceeded etc — fail silently
-                tx.onabort = () => resolve();
-            }
-            catch (_a) {
-                resolve();
-            }
+        await connection.run('readwrite', (store, tx) => {
+            store.put(entry, key);
+            return settled(tx);
         });
     }
     catch (_a) {
@@ -114,18 +80,9 @@ export async function idbDelete(key) {
     if (!isIdbAvailable())
         return;
     try {
-        const db = await openDb();
-        await new Promise((resolve) => {
-            try {
-                const tx = db.transaction(STORE_NAME, 'readwrite');
-                tx.objectStore(STORE_NAME).delete(key);
-                tx.oncomplete = () => resolve();
-                tx.onerror = () => resolve();
-                tx.onabort = () => resolve();
-            }
-            catch (_a) {
-                resolve();
-            }
+        await connection.run('readwrite', (store, tx) => {
+            store.delete(key);
+            return settled(tx);
         });
     }
     catch (_a) { }
@@ -138,41 +95,25 @@ export async function idbClear(pattern) {
     if (!isIdbAvailable())
         return;
     try {
-        const db = await openDb();
         if (!pattern) {
-            await new Promise((resolve) => {
-                try {
-                    const tx = db.transaction(STORE_NAME, 'readwrite');
-                    tx.objectStore(STORE_NAME).clear();
-                    tx.oncomplete = () => resolve();
-                    tx.onerror = () => resolve();
-                    tx.onabort = () => resolve();
-                }
-                catch (_a) {
-                    resolve();
-                }
+            await connection.run('readwrite', (store, tx) => {
+                store.clear();
+                return settled(tx);
             });
             return;
         }
         // Pattern-based: enumerate all keys and delete matching ones.
-        await new Promise((resolve) => {
-            try {
-                const tx = db.transaction(STORE_NAME, 'readwrite');
-                const store = tx.objectStore(STORE_NAME);
-                const req = store.getAllKeys();
-                req.onsuccess = () => {
-                    for (const key of req.result) {
-                        if (key.includes(pattern))
-                            store.delete(key);
-                    }
-                    resolve();
-                };
-                req.onerror = () => resolve();
-            }
-            catch (_a) {
+        await connection.run('readwrite', (store) => new Promise((resolve) => {
+            const req = store.getAllKeys();
+            req.onsuccess = () => {
+                for (const key of req.result) {
+                    if (key.includes(pattern))
+                        store.delete(key);
+                }
                 resolve();
-            }
-        });
+            };
+            req.onerror = () => resolve();
+        }));
     }
     catch (_a) { }
 }

package/dist/theme.css

@@ -41,6 +41,26 @@
   --shadow-md: var(--sl-shadow-md, 0 0 #0000);
 }
 
+/* Dark mode without values. A host in dark mode should send a dark value-set (the --sl-* tokens); one
+ * that only sets the hook (.dark / data-theme="dark") left every colour on its light fallback — white
+ * cards and near-black text on a dark page. Under the hook the fallbacks are dark too; whatever the host
+ * does send still wins. (Re-declared on the hook's element, so it works wherever the host puts it.) */
+.dark,
+[data-theme="dark"] {
+  --color-background:    var(--sl-color-bg, #09090b);
+  --color-surface:       var(--sl-color-surface, #18181b);
+  --color-surface-raised:var(--sl-color-surface-raised, var(--sl-color-surface, #27272a));
+  --color-foreground:    var(--sl-color-fg, #fafafa);
+  --color-muted:         var(--sl-color-muted, #a1a1aa);
+  --color-border:        var(--sl-color-border, #3f3f46);
+  --color-primary:       var(--sl-color-accent, #6366f1);
+  --color-on-primary:    var(--sl-color-on-accent, #ffffff);
+  --color-primary-soft:  var(--sl-color-accent-soft, color-mix(in oklab, var(--sl-color-accent, #6366f1) 20%, transparent));
+  --color-success:       var(--sl-color-success, #22c55e);
+  --color-danger:        var(--sl-color-danger, #f87171);
+  color-scheme: dark;
+}
+
 /* shadcn bridge (optional): if the app uses shadcn's --primary/--background/etc. HSL variables,
  * uncomment to drive them from the SmartLinks tokens too. Left commented so it never overrides an
  * app that has deliberately customised its shadcn palette — opt in per app (see migration step 17).

package/dist/translationCache.js

@@ -1,8 +1,9 @@
+import { createIdbConnection } from './idbConnection.js';
 const DB_NAME = 'smartlinks-sdk-translations';
 const STORE_NAME = 'translations';
 const DB_VERSION = 1;
 const DEFAULT_LOCAL_TRANSLATION_TTL_MS = 90 * 24 * 60 * 60000;
-let dbPromise = null;
+const connection = createIdbConnection(DB_NAME, STORE_NAME, DB_VERSION);
 const memoryTranslationCache = new Map();
 export function getDefaultTranslationCacheTtlMs() {
     return DEFAULT_LOCAL_TRANSLATION_TTL_MS;
@@ -15,36 +16,13 @@ function isIndexedDbAvailable() {
         return false;
     }
 }
-function openDb() {
-    if (dbPromise)
-        return dbPromise;
-    dbPromise = new Promise((resolve, reject) => {
-        try {
-            const request = indexedDB.open(DB_NAME, DB_VERSION);
-            request.onupgradeneeded = (event) => {
-                const db = event.target.result;
-                if (!db.objectStoreNames.contains(STORE_NAME)) {
-                    db.createObjectStore(STORE_NAME);
-                }
-            };
-            request.onsuccess = (event) => {
-                resolve(event.target.result);
-            };
-            request.onerror = () => {
-                dbPromise = null;
-                reject(request.error);
-            };
-            request.onblocked = () => {
-                dbPromise = null;
-                reject(new Error('[smartlinks] Translation IndexedDB open blocked'));
-            };
-        }
-        catch (error) {
-            dbPromise = null;
-            reject(error);
-        }
+/** Resolve when the transaction settles, whatever the outcome. */
+function settled(tx) {
+    return new Promise((resolve) => {
+        tx.oncomplete = () => resolve();
+        tx.onerror = () => resolve();
+        tx.onabort = () => resolve();
     });
-    return dbPromise;
 }
 function stableContextKey(context) {
     if (!context)
@@ -123,33 +101,26 @@ async function getEntry(key) {
     if (!isIndexedDbAvailable())
         return null;
     try {
-        const db = await openDb();
-        return await new Promise((resolve) => {
-            try {
-                const tx = db.transaction(STORE_NAME, 'readonly');
-                const request = tx.objectStore(STORE_NAME).get(key);
-                request.onsuccess = () => {
-                    var _a;
-                    const result = (_a = request.result) !== null && _a !== void 0 ? _a : null;
-                    if (!result) {
-                        resolve(null);
-                        return;
-                    }
-                    if (isExpired(result)) {
-                        memoryTranslationCache.delete(key);
-                        void deleteEntries([key]);
-                        resolve(null);
-                        return;
-                    }
-                    memoryTranslationCache.set(key, result);
-                    resolve(result);
-                };
-                request.onerror = () => resolve(null);
-            }
-            catch (_a) {
-                resolve(null);
-            }
-        });
+        return await connection.run('readonly', (store) => new Promise((resolve) => {
+            const request = store.get(key);
+            request.onsuccess = () => {
+                var _a;
+                const result = (_a = request.result) !== null && _a !== void 0 ? _a : null;
+                if (!result) {
+                    resolve(null);
+                    return;
+                }
+                if (isExpired(result)) {
+                    memoryTranslationCache.delete(key);
+                    void deleteEntries([key]);
+                    resolve(null);
+                    return;
+                }
+                memoryTranslationCache.set(key, result);
+                resolve(result);
+            };
+            request.onerror = () => resolve(null);
+        }));
     }
     catch (_a) {
         return null;
@@ -170,21 +141,11 @@ async function setEntries(entries) {
     if (!isIndexedDbAvailable())
         return;
     try {
-        const db = await openDb();
-        await new Promise((resolve) => {
-            try {
-                const tx = db.transaction(STORE_NAME, 'readwrite');
-                const store = tx.objectStore(STORE_NAME);
-                for (const [key, entry] of entries) {
-                    store.put(entry, key);
-                }
-                tx.oncomplete = () => resolve();
-                tx.onerror = () => resolve();
-                tx.onabort = () => resolve();
-            }
-            catch (_a) {
-                resolve();
+        await connection.run('readwrite', (store, tx) => {
+            for (const [key, entry] of entries) {
+                store.put(entry, key);
             }
+            return settled(tx);
         });
     }
     catch (_a) {
@@ -226,21 +187,11 @@ async function deleteEntries(keys) {
     if (!isIndexedDbAvailable() || keys.length === 0)
         return;
     try {
-        const db = await openDb();
-        await new Promise((resolve) => {
-            try {
-                const tx = db.transaction(STORE_NAME, 'readwrite');
-                const store = tx.objectStore(STORE_NAME);
-                for (const key of keys) {
-                    store.delete(key);
-                }
-                tx.oncomplete = () => resolve();
-                tx.onerror = () => resolve();
-                tx.onabort = () => resolve();
-            }
-            catch (_a) {
-                resolve();
+        await connection.run('readwrite', (store, tx) => {
+            for (const key of keys) {
+                store.delete(key);
             }
+            return settled(tx);
         });
     }
     catch (_a) {
@@ -256,41 +207,25 @@ export async function clearCachedTranslations(collectionId) {
     if (!isIndexedDbAvailable())
         return;
     try {
-        const db = await openDb();
         if (!collectionId) {
-            await new Promise((resolve) => {
-                try {
-                    const tx = db.transaction(STORE_NAME, 'readwrite');
-                    tx.objectStore(STORE_NAME).clear();
-                    tx.oncomplete = () => resolve();
-                    tx.onerror = () => resolve();
-                    tx.onabort = () => resolve();
-                }
-                catch (_a) {
-                    resolve();
-                }
+            await connection.run('readwrite', (store, tx) => {
+                store.clear();
+                return settled(tx);
             });
             return;
         }
-        await new Promise((resolve) => {
-            try {
-                const tx = db.transaction(STORE_NAME, 'readwrite');
-                const store = tx.objectStore(STORE_NAME);
-                const request = store.getAllKeys();
-                request.onsuccess = () => {
-                    for (const key of request.result) {
-                        if (key.startsWith(`${collectionId}::`)) {
-                            store.delete(key);
-                        }
+        await connection.run('readwrite', (store) => new Promise((resolve) => {
+            const request = store.getAllKeys();
+            request.onsuccess = () => {
+                for (const key of request.result) {
+                    if (key.startsWith(`${collectionId}::`)) {
+                        store.delete(key);
                     }
-                    resolve();
-                };
-                request.onerror = () => resolve();
-            }
-            catch (_a) {
+                }
                 resolve();
-            }
-        });
+            };
+            request.onerror = () => resolve();
+        }));
     }
     catch (_a) {
         // Ignore deletion failures.

package/dist/types/claimSet.d.ts

@@ -122,3 +122,188 @@ export interface CreateClaimSetTagResponse {
     /** Arbitrary extra fields */
     data?: Record<string, unknown>;
 }
+/** Who a range call acts as: a collection on its own sets, or a partner on the partner's sets. */
+export type ClaimSetScope = {
+    collectionId: string;
+} | {
+    partnerId: string;
+};
+export type ClaimSetTagType = 'ntag424' | 'ntag21x' | 'qr';
+export type ClaimSetRangeStatus = 'minting' | 'minted' | 'sent' | 'received' | 'assigned';
+export interface ClaimSetRange {
+    id: string;
+    claimSetId: string;
+    namespace: string;
+    name: string;
+    notes: string | null;
+    startIndex: number;
+    endIndex: number;
+    quantity: number;
+    tagType: ClaimSetTagType;
+    fulfilment: 'printer' | 'sidekick';
+    /** The stored step: minting | minted | sent | received */
+    stage: 'minting' | 'minted' | 'sent' | 'received';
+    /** What to show: the stage, or 'assigned' once every tag is assigned */
+    status: ClaimSetRangeStatus;
+    intendedCollectionId: string | null;
+    intendedProductId: string | null;
+    intendedBatchId: string | null;
+    manufacturer: string | null;
+    orderRef: string | null;
+    counts: {
+        programmed: number;
+        assigned: number;
+        claimed: number;
+    };
+    sentAt: string | null;
+    receivedAt: string | null;
+    createdBy: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreateClaimSetRangeRequest {
+    name: string;
+    /** 1 to 10,000 */
+    quantity: number;
+    /** Pre-assign every tag at mint time (you must administer the collection) */
+    intendedCollectionId?: string;
+    intendedProductId?: string;
+    intendedBatchId?: string;
+    fulfilment?: 'printer' | 'sidekick';
+    notes?: string;
+    manufacturer?: string;
+    orderRef?: string;
+}
+export interface UpdateClaimSetRangeRequest {
+    name?: string;
+    notes?: string | null;
+    manufacturer?: string | null;
+    orderRef?: string | null;
+    fulfilment?: 'printer' | 'sidekick';
+    stage?: 'minted' | 'sent' | 'received';
+}
+export interface ClaimSetRangeTag {
+    code: string;
+    /** The printed code: 3-character set id + code */
+    printed: string;
+    index: number;
+    uid: string | null;
+    /** Only for owners/admins, and only when asked for */
+    key?: string;
+    collectionId: string | null;
+    productId: string | null;
+    batchId: string | null;
+    proofId: string | null;
+    programmedAt: string | null;
+    scans: number;
+}
+export interface ClaimSetRangeTagsPage {
+    tags: ClaimSetRangeTag[];
+    /** The index to pass as `from` for the next page, or null */
+    next: number | null;
+}
+/** The next tag to program on a phone, with what to write. */
+export interface ClaimSetRangeNextTag extends ClaimSetRangeTag {
+    url: string;
+    piccOffset?: number;
+    mirrorOffset?: number;
+    remaining: number;
+}
+export type ClaimSetImportResult = 'ok' | 'unchanged' | 'unknown_code' | 'duplicate_row' | 'index_mismatch' | 'no_uid' | 'bad_uid' | 'duplicate_uid' | 'uid_in_use' | 'uid_conflict';
+export interface ImportClaimSetRangeUidsRequest {
+    /** The manufacturer's file as CSV text (the file we sent, with UID filled in) */
+    csv?: string;
+    /** …or already-parsed rows: [{ Code, Index?, UID }] */
+    rows?: Array<Record<string, string | number>>;
+    /** false (default) only checks; true writes the UIDs that matched */
+    commit?: boolean;
+}
+export interface ImportClaimSetRangeUidsResponse {
+    summary: {
+        rows: number;
+        ok: number;
+        unchanged: number;
+        problems: number;
+        notInFile: number;
+        committed: boolean;
+    };
+    rows: Array<{
+        line: number;
+        code: string;
+        index: number | null;
+        uid: string;
+        result: ClaimSetImportResult;
+        message?: string;
+    }>;
+    range: ClaimSetRange;
+}
+export interface AssignClaimSetRangeRequest {
+    /** Required unless clear */
+    collectionId?: string;
+    productId?: string;
+    batchId?: string;
+    /** Default: the whole range */
+    start?: number;
+    end?: number;
+    /** Unassign instead (tags bound to a proof are never cleared) */
+    clear?: boolean;
+    data?: Record<string, unknown>;
+}
+export interface AssignClaimSetRangeResponse {
+    changed: number;
+    skipped: Array<{
+        code: string;
+        index: number;
+        reason: 'other_range' | 'has_proof' | 'assigned_elsewhere';
+        collectionId?: string;
+    }>;
+    range: ClaimSetRange;
+}
+export interface ClaimSetRangeFile {
+    filename: string;
+    contentType: string;
+    /** export: the printer file */
+    csv?: string;
+    /** instructions as PDF: the file, base64 */
+    base64?: string;
+    /** instructions as Markdown */
+    markdown?: string;
+}
+export interface Partner {
+    id: string;
+    name: string;
+    status: 'active' | 'suspended';
+    tapDomains: string[];
+    features: Record<string, boolean>;
+    /** Your role (from partner.list / partner.get) */
+    role?: 'owner' | 'admin' | 'assigner';
+    /** Owners only */
+    members?: Array<{
+        userId: string;
+        role: 'owner' | 'admin' | 'assigner';
+        grantedBy: string | null;
+        grantedAt: string;
+    }>;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface PartnerClaimSet {
+    id: string;
+    namespace: string;
+    name: string | null;
+    tagType: ClaimSetTagType;
+    tapDomain: string;
+    owner: {
+        type: 'platform' | 'partner' | 'collection' | 'user';
+        id: string | null;
+    };
+    codes: number;
+    deleted: boolean;
+    createdAt: string | null;
+}
+export interface CreatePartnerClaimSetRequest {
+    name: string;
+    tagType: ClaimSetTagType;
+    /** One of the partner's tap domains; default smartlinks.app */
+    tapDomain?: string;
+}