skillet-shared 0.4.0 → 0.5.0

package/dist/cloud.d.ts

@@ -0,0 +1,50 @@
+import type { RecentSession, SavedItem } from './saved-list.ts';
+import type { FirebaseApp, FirebaseOptions } from 'firebase/app';
+import type { Auth } from 'firebase/auth';
+import type { Firestore } from 'firebase/firestore/lite';
+export interface CloudUser {
+    uid: string;
+    name: string | null;
+    photo: string | null;
+}
+export interface HomeDoc {
+    items: SavedItem[];
+    recent: RecentSession[];
+}
+export interface Sdk {
+    app: FirebaseApp;
+    auth: Auth;
+    db: Firestore;
+    fs: typeof import('firebase/firestore/lite');
+    authMod: typeof import('firebase/auth');
+}
+export interface CloudOptions {
+    config: FirebaseOptions;
+    collection: string;
+    listField: string;
+    signedInHint: string;
+    appCheckSiteKey: string;
+    recentMax: number;
+    storage: {
+        read: (key: string) => string | null;
+        write: (key: string, value: string) => void;
+        forget: (key: string) => void;
+    };
+}
+export declare function createCloud(options: CloudOptions): {
+    wasSignedIn: () => boolean;
+    loadSdk: () => Promise<Sdk>;
+    userDoc: (uid: string) => Promise<{
+        db: Firestore;
+        fs: typeof import("firebase/firestore/lite");
+        ref: import("firebase/firestore/lite").DocumentReference<import("firebase/firestore/lite").DocumentData, import("firebase/firestore/lite").DocumentData>;
+    }>;
+    warmSignIn: () => void;
+    watchAuth: (onUser: (user: CloudUser | null) => void) => Promise<() => void>;
+    signIn: () => Promise<CloudUser>;
+    signOut: () => Promise<void>;
+    fetchHome: (uid: string) => Promise<HomeDoc>;
+    editItems: (uid: string, edit: (items: SavedItem[]) => SavedItem[]) => Promise<SavedItem[]>;
+    putSession: (uid: string, entry: RecentSession) => Promise<string[]>;
+    dropSession: (uid: string, id: string) => Promise<RecentSession[]>;
+};

package/dist/cloud.js

@@ -0,0 +1,140 @@
+import { ITEM_MAX, pushRecent, readItems, readRecent, removeRecent, } from './saved-list.js';
+const asCloudUser = (user) => ({
+    uid: user.uid,
+    name: user.displayName,
+    photo: user.photoURL,
+});
+const itemEntry = (item) => ({
+    name: item.name,
+    query: item.query,
+    ...(item.id === undefined ? {} : { id: item.id }),
+    ...(item.savedAt === undefined ? {} : { savedAt: item.savedAt }),
+});
+const sessionEntry = (s) => ({
+    id: s.id,
+    query: s.query,
+    at: s.at,
+});
+async function installAppCheck(app, siteKey) {
+    if (siteKey === '')
+        return;
+    const mod = await import('firebase/app-check');
+    mod.initializeAppCheck(app, {
+        provider: new mod.ReCaptchaEnterpriseProvider(siteKey),
+        isTokenAutoRefreshEnabled: true,
+    });
+}
+export function createCloud(options) {
+    const { config, collection, listField, signedInHint, recentMax, storage } = options;
+    const wasSignedIn = () => storage.read(signedInHint) === '1';
+    let sdk = null;
+    function loadSdk() {
+        if (sdk !== null)
+            return sdk;
+        const load = (async () => {
+            const [appMod, authMod, fs] = await Promise.all([
+                import('firebase/app'),
+                import('firebase/auth'),
+                import('firebase/firestore/lite'),
+            ]);
+            const app = appMod.initializeApp(config);
+            await installAppCheck(app, options.appCheckSiteKey);
+            return {
+                app,
+                auth: authMod.getAuth(app),
+                db: fs.getFirestore(app),
+                fs,
+                authMod,
+            };
+        })();
+        sdk = load;
+        load.catch(() => {
+            if (sdk === load)
+                sdk = null;
+        });
+        return load;
+    }
+    const warmSignIn = () => {
+        loadSdk().catch(() => undefined);
+    };
+    async function watchAuth(onUser) {
+        const { auth, authMod } = await loadSdk();
+        return authMod.onAuthStateChanged(auth, user => {
+            if (user === null)
+                storage.forget(signedInHint);
+            else
+                storage.write(signedInHint, '1');
+            onUser(user === null ? null : asCloudUser(user));
+        });
+    }
+    async function signIn() {
+        const { auth, authMod } = await loadSdk();
+        const provider = new authMod.GoogleAuthProvider();
+        const result = await authMod.signInWithPopup(auth, provider);
+        storage.write(signedInHint, '1');
+        return asCloudUser(result.user);
+    }
+    async function signOut() {
+        const { auth } = await loadSdk();
+        storage.forget(signedInHint);
+        await auth.signOut();
+    }
+    async function userDoc(uid) {
+        const { db, fs } = await loadSdk();
+        return { db, fs, ref: fs.doc(db, collection, uid) };
+    }
+    async function fetchHome(uid) {
+        const { fs, ref } = await userDoc(uid);
+        const snap = await fs.getDoc(ref);
+        if (!snap.exists())
+            return { items: [], recent: [] };
+        const data = snap.data();
+        return {
+            items: readItems(data[listField]),
+            recent: readRecent(data.recent, recentMax, data.current),
+        };
+    }
+    async function editItems(uid, edit) {
+        const { db, fs, ref } = await userDoc(uid);
+        return fs.runTransaction(db, async (tx) => {
+            const snap = await tx.get(ref);
+            const stored = snap.exists() ? readItems(snap.data()[listField]) : [];
+            const next = edit(stored).slice(0, ITEM_MAX);
+            tx.set(ref, { [listField]: next.map(itemEntry) }, { merge: true });
+            return next;
+        });
+    }
+    async function putSession(uid, entry) {
+        const { db, fs, ref } = await userDoc(uid);
+        return fs.runTransaction(db, async (tx) => {
+            const snap = await tx.get(ref);
+            const data = snap.exists() ? snap.data() : undefined;
+            const { recent, dropped } = pushRecent(readRecent(data?.recent, recentMax, data?.current), entry, recentMax);
+            tx.set(ref, { recent: recent.map(sessionEntry), current: fs.deleteField() }, { merge: true });
+            return dropped;
+        });
+    }
+    async function dropSession(uid, id) {
+        const { db, fs, ref } = await userDoc(uid);
+        return fs.runTransaction(db, async (tx) => {
+            const snap = await tx.get(ref);
+            const data = snap.exists() ? snap.data() : undefined;
+            const recent = removeRecent(readRecent(data?.recent, recentMax, data?.current), id);
+            tx.set(ref, { recent: recent.map(sessionEntry) }, { merge: true });
+            return recent;
+        });
+    }
+    return {
+        wasSignedIn,
+        loadSdk,
+        userDoc,
+        warmSignIn,
+        watchAuth,
+        signIn,
+        signOut,
+        fetchHome,
+        editItems,
+        putSession,
+        dropSession,
+    };
+}

package/dist/saved-list.d.ts

@@ -0,0 +1,30 @@
+export interface SavedItem {
+    name: string;
+    query: string;
+    id?: string;
+    savedAt?: number;
+}
+export interface CurrentSession {
+    query: string;
+    at: number;
+}
+export interface RecentSession extends CurrentSession {
+    id: string;
+}
+export declare const ITEM_MAX = 200;
+export declare const QUERY_MAX = 8000;
+export declare const ITEM_NAME_MAX = 40;
+export declare const newItemId: () => string;
+export declare const cleanItemName: (raw: string) => string;
+export declare const readItems: (raw: unknown) => SavedItem[];
+export declare function readCurrent(raw: unknown): CurrentSession | null;
+export declare function readRecent(raw: unknown, recentMax: number, legacy?: unknown): RecentSession[];
+export declare function pushRecent(recent: readonly RecentSession[], entry: RecentSession, recentMax: number): {
+    recent: RecentSession[];
+    dropped: string[];
+};
+export declare const removeRecent: (recent: readonly RecentSession[], id: string) => RecentSession[];
+export declare function upsertItem(items: readonly SavedItem[], name: string, query: string, at?: number): SavedItem[];
+export declare const removeItem: (items: readonly SavedItem[], name: string) => SavedItem[];
+export declare function renameItem(items: readonly SavedItem[], from: string, to: string): SavedItem[];
+export declare function suggestItemName(items: readonly SavedItem[], base: string, fallback: string): string;

package/dist/saved-list.js

@@ -0,0 +1,109 @@
+export const ITEM_MAX = 200;
+export const QUERY_MAX = 8000;
+export const ITEM_NAME_MAX = 40;
+export const newItemId = () => Math.random().toString(36).slice(2, 10);
+const num = (v) => typeof v === 'number' && Number.isFinite(v) ? v : undefined;
+export const cleanItemName = (raw) => raw.replaceAll(/\s+/g, ' ').trim().slice(0, ITEM_NAME_MAX).trim();
+function readItem(raw) {
+    if (typeof raw !== 'object' || raw === null)
+        return undefined;
+    const name = 'name' in raw ? raw.name : undefined;
+    const query = 'query' in raw ? raw.query : undefined;
+    if (typeof name !== 'string' || typeof query !== 'string')
+        return undefined;
+    if (query.length > QUERY_MAX)
+        return undefined;
+    const clean = cleanItemName(name);
+    if (clean === '')
+        return undefined;
+    const id = 'id' in raw && typeof raw.id === 'string' ? raw.id : undefined;
+    const savedAt = 'savedAt' in raw ? num(raw.savedAt) : undefined;
+    return {
+        name: clean,
+        query,
+        ...(id === undefined ? {} : { id }),
+        ...(savedAt === undefined ? {} : { savedAt }),
+    };
+}
+export const readItems = (raw) => (Array.isArray(raw) ? raw : [])
+    .flatMap(item => {
+    const parsed = readItem(item);
+    return parsed === undefined ? [] : [parsed];
+})
+    .slice(0, ITEM_MAX);
+export function readCurrent(raw) {
+    if (typeof raw !== 'object' || raw === null)
+        return null;
+    const query = 'query' in raw ? raw.query : undefined;
+    const at = 'at' in raw ? num(raw.at) : undefined;
+    if (typeof query !== 'string' || query.length > QUERY_MAX)
+        return null;
+    return at === undefined ? null : { query, at };
+}
+export function readRecent(raw, recentMax, legacy) {
+    if (!Array.isArray(raw)) {
+        const current = readCurrent(legacy);
+        return current === null ? [] : [{ id: '', ...current }];
+    }
+    const seen = new Set();
+    return raw
+        .flatMap(item => {
+        const session = readCurrent(item);
+        const id = typeof item === 'object' && item !== null && 'id' in item
+            ? item.id
+            : undefined;
+        if (session === null || typeof id !== 'string' || seen.has(id))
+            return [];
+        seen.add(id);
+        return [{ id, ...session }];
+    })
+        .slice(0, recentMax);
+}
+export function pushRecent(recent, entry, recentMax) {
+    const next = [
+        entry,
+        ...recent.filter(s => s.id !== entry.id && s.query !== entry.query),
+    ].slice(0, recentMax);
+    const kept = new Set(next.map(s => s.id));
+    return {
+        recent: next,
+        dropped: recent.flatMap(s => (kept.has(s.id) ? [] : [s.id])),
+    };
+}
+export const removeRecent = (recent, id) => recent.filter(item => item.id !== id);
+export function upsertItem(items, name, query, at) {
+    const clean = cleanItemName(name);
+    if (clean === '')
+        return [...items];
+    const index = items.findIndex(item => item.name === clean);
+    const prior = index === -1 ? undefined : items[index];
+    const entry = { name: clean, query };
+    if (prior?.id !== undefined)
+        entry.id = prior.id;
+    if (at !== undefined) {
+        entry.id ??= newItemId();
+        entry.savedAt = at;
+    }
+    if (index !== -1)
+        return items.map((item, i) => (i === index ? entry : item));
+    return [...items, entry].slice(-ITEM_MAX);
+}
+export const removeItem = (items, name) => items.filter(item => item.name !== name);
+export function renameItem(items, from, to) {
+    const clean = cleanItemName(to);
+    if (clean === '' || items.some(item => item.name === clean))
+        return [...items];
+    return items.map(item => item.name === from ? { ...item, name: clean } : item);
+}
+export function suggestItemName(items, base, fallback) {
+    const clean = cleanItemName(base);
+    const stem = clean === '' ? fallback : clean;
+    if (!items.some(item => item.name === stem))
+        return stem;
+    for (let n = 2; n < 1000; n++) {
+        const candidate = `${stem} ${n}`;
+        if (!items.some(item => item.name === candidate))
+            return candidate;
+    }
+    return stem;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skillet-shared",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Code shared by bender and videoskillet",
   "license": "MIT",
   "author": "Colin Diesh",
@@ -41,7 +41,15 @@
     "./components/SocialMeta.astro": "./components/SocialMeta.astro",
     "./components/SignedInHint.astro": "./components/SignedInHint.astro",
     "./site.css": "./css/site.css",
-    "./footer.css": "./css/footer.css"
+    "./footer.css": "./css/footer.css",
+    "./saved-list": {
+      "types": "./dist/saved-list.d.ts",
+      "default": "./dist/saved-list.js"
+    },
+    "./cloud": {
+      "types": "./dist/cloud.d.ts",
+      "default": "./dist/cloud.js"
+    }
   },
   "files": [
     "dist",
@@ -61,11 +69,13 @@
     "postversion": "git push --follow-tags"
   },
   "peerDependencies": {
-    "astro": "^7.4.2"
+    "astro": "^7.4.2",
+    "firebase": "^13.1.0"
   },
   "devDependencies": {
     "@types/node": "^26.6.5",
     "astro": "^7.4.2",
+    "firebase": "13.1.0",
     "typescript": "^7.0.2",
     "vitest": "^5.0.5"
   }