@plantops/web-kit 0.1.0

package/dist/token-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-store.d.ts","sourceRoot":"","sources":["../src/token-store.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAErE,gFAAgF;AAChF,eAAO,MAAM,iBAAiB,oBAAoB,CAAC;AAEnD;;;;;;;;GAQG;AACH,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,YAAY,CAAC;IACrB,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;CAC/B;AAED,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,KAAK,IAAI,CAAC;AAoCzE;;;;;;GAMG;AACH,qBAAa,iBAAkB,YAAW,UAAU;IAItC,OAAO,CAAC,QAAQ,CAAC,UAAU;IAHvC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAiC;IAC3D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgC;gBAE7B,UAAU,GAAE,MAA0B;IAQnE;;;;;;;;;OASG;IACH,SAAS,CAAC,QAAQ,EAAE,kBAAkB,GAAG,MAAM,IAAI;IAcnD,gEAAgE;IAChE,OAAO,IAAI,IAAI;IAKf,IAAI,IAAI,YAAY,GAAG,IAAI;IAI3B,KAAK,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,GAAG,IAAI;IAUxC,WAAW,IAAI,aAAa,GAAG,IAAI;IAQnC,+EAA+E;IAC/E,aAAa,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI,GAAG,IAAI;IAMlD,KAAK,IAAI,IAAI;IASb,OAAO,CAAC,YAAY;IAWpB,OAAO,CAAC,OAAO;IAQf,OAAO,CAAC,IAAI;CAGb"}

package/dist/token-store.js

@@ -0,0 +1,144 @@
+'use client';
+/** Default slot. Namespaced so two PlantOps consoles on one host can differ. */
+export const TOKEN_STORAGE_KEY = 'plantops.tokens';
+function safeParse(raw) {
+    if (raw === null)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== 'object' || parsed === null)
+            return null;
+        const { tokens, identity } = parsed;
+        if (typeof tokens !== 'object' ||
+            tokens === null ||
+            typeof tokens.accessToken !== 'string') {
+            return null;
+        }
+        return {
+            tokens: {
+                accessToken: tokens.accessToken,
+                refreshToken: typeof tokens.refreshToken === 'string' ? tokens.refreshToken : null,
+                expiresAt: typeof tokens.expiresAt === 'number' ? tokens.expiresAt : null,
+            },
+            identity: identity != null &&
+                typeof identity.email === 'string' &&
+                typeof identity.clientSlug === 'string'
+                ? { email: identity.email, clientSlug: identity.clientSlug }
+                : null,
+        };
+    }
+    catch {
+        // A hand-edited or half-written entry is treated as "signed out" rather
+        // than crashing the shell. The user signs in again; nothing is lost that
+        // was not already unusable.
+        return null;
+    }
+}
+/**
+ * A `TokenStore` backed by `localStorage`, with change notification.
+ *
+ * Safe to construct during server rendering: every method tolerates the absence
+ * of `window`, answering "no session", which is the correct answer on a server
+ * that has no user.
+ */
+export class BrowserTokenStore {
+    storageKey;
+    listeners = new Set();
+    onStorage;
+    constructor(storageKey = TOKEN_STORAGE_KEY) {
+        this.storageKey = storageKey;
+        this.onStorage = (event) => {
+            if (event.storageArea !== this.storage())
+                return;
+            if (event.key !== null && event.key !== this.storageKey)
+                return;
+            this.emit(this.readSession());
+        };
+    }
+    /**
+     * Notified on every change, in this tab and in others.
+     *
+     * The `storage` listener is attached with the first subscriber and detached
+     * with the last, rather than in the constructor. That is what makes the store
+     * survive React's development double-mount: a listener attached at
+     * construction and removed on unmount is gone for good after the first
+     * remount — cross-tab sign-out then silently stops working, in development
+     * only, which is the worst place for it to hide.
+     */
+    subscribe(listener) {
+        if (this.listeners.size === 0) {
+            globalThis.addEventListener?.('storage', this.onStorage);
+        }
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+            if (this.listeners.size === 0) {
+                globalThis.removeEventListener?.('storage', this.onStorage);
+            }
+        };
+    }
+    /** Drops every subscriber and the window listener with them. */
+    dispose() {
+        this.listeners.clear();
+        globalThis.removeEventListener?.('storage', this.onStorage);
+    }
+    read() {
+        return this.readSession()?.tokens ?? null;
+    }
+    write(tokens) {
+        if (tokens === null) {
+            this.clear();
+            return;
+        }
+        // A refresh rotates the tokens and knows nothing about the identity hint,
+        // so the hint is carried across rather than dropped on every renewal.
+        this.writeSession({ tokens, identity: this.readSession()?.identity ?? null });
+    }
+    readSession() {
+        try {
+            return safeParse(this.storage()?.getItem(this.storageKey) ?? null);
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Records who signed in, for the header. Never used to authorise anything. */
+    writeIdentity(identity) {
+        const current = this.readSession();
+        if (current === null)
+            return;
+        this.writeSession({ ...current, identity });
+    }
+    clear() {
+        try {
+            this.storage()?.removeItem(this.storageKey);
+        }
+        catch {
+            /* storage unavailable — nothing was written to remove */
+        }
+        this.emit(null);
+    }
+    writeSession(session) {
+        try {
+            this.storage()?.setItem(this.storageKey, JSON.stringify(session));
+        }
+        catch {
+            // Quota, private mode, or a policy that blocks storage. The session still
+            // works for this page's lifetime through the client's in-memory copy; it
+            // simply will not survive a reload.
+        }
+        this.emit(session);
+    }
+    storage() {
+        try {
+            return globalThis.localStorage ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    emit(session) {
+        for (const listener of this.listeners)
+            listener(session);
+    }
+}