@affectively/dash 5.1.0 → 5.2.0

package/dist/src/api/firebase/storage/index.js

@@ -0,0 +1,286 @@
+/**
+ * Firebase Cloud Storage API
+ */
+import { createFirebaseError } from '../errors.js';
+/**
+ * Storage reference implementation
+ */
+export class StorageReferenceImpl {
+    storage;
+    _location;
+    bucket;
+    fullPath;
+    name;
+    parent;
+    root;
+    constructor(storage, bucket, path) {
+        this.storage = storage;
+        this.bucket = bucket;
+        this.fullPath = path;
+        this._location = { bucket, path };
+        // Extract file name
+        const segments = path.split('/');
+        this.name = segments[segments.length - 1] || '';
+        // Set parent
+        if (segments.length > 1) {
+            const parentPath = segments.slice(0, -1).join('/');
+            this.parent = new StorageReferenceImpl(storage, bucket, parentPath);
+        }
+        else {
+            this.parent = null;
+        }
+        // Set root
+        this.root = this;
+        let current = this.parent;
+        while (current) {
+            this.root = current;
+            current = current.parent;
+        }
+    }
+    toString() {
+        return `StorageReference(${this.bucket}/${this.fullPath})`;
+    }
+}
+/**
+ * Upload task implementation
+ */
+export class UploadTaskImpl {
+    _ref;
+    _data;
+    _metadata;
+    _paused = false;
+    _cancelled = false;
+    _progress = 0;
+    _listeners = new Set();
+    _errorListeners = new Set();
+    _completeListeners = new Set();
+    constructor(ref, data, metadata) {
+        this._ref = ref;
+        this._data = data;
+        this._metadata = metadata || {};
+    }
+    on(event, nextOrObserver, error, complete) {
+        if (event === 'state_changed') {
+            if (typeof nextOrObserver === 'function') {
+                this._listeners.add(nextOrObserver);
+            }
+            else if (nextOrObserver && typeof nextOrObserver.next === 'function') {
+                this._listeners.add(nextOrObserver.next);
+            }
+            if (error) {
+                this._errorListeners.add(error);
+            }
+            if (complete) {
+                this._completeListeners.add(complete);
+            }
+            return () => {
+                this._listeners.clear();
+                this._errorListeners.clear();
+                this._completeListeners.clear();
+            };
+        }
+        return () => { };
+    }
+    async then(onFulfilled, onRejected) {
+        try {
+            const snapshot = await this._performUpload();
+            return onFulfilled?.(snapshot);
+        }
+        catch (error) {
+            return onRejected?.(error);
+        }
+    }
+    catch(onRejected) {
+        return this.then(undefined, onRejected);
+    }
+    pause() {
+        if (!this._cancelled) {
+            this._paused = true;
+            return true;
+        }
+        return false;
+    }
+    resume() {
+        if (!this._cancelled) {
+            this._paused = false;
+            return true;
+        }
+        return false;
+    }
+    cancel() {
+        if (!this._cancelled) {
+            this._cancelled = true;
+            return true;
+        }
+        return false;
+    }
+    async _performUpload() {
+        // Simulate upload progress
+        for (let i = 0; i <= 100; i += 10) {
+            if (this._cancelled) {
+                throw createFirebaseError('storage/cancelled', 'Upload was cancelled');
+            }
+            if (!this._paused) {
+                this._progress = i;
+                this._notifyProgress();
+                await new Promise(resolve => setTimeout(resolve, 100));
+            }
+        }
+        // Complete upload
+        this._progress = 100;
+        return this._createSnapshot();
+    }
+    _createSnapshot() {
+        const size = this._data instanceof Blob ? this._data.size : this._data.length;
+        return {
+            ref: this._ref,
+            metadata: {
+                bucket: this._ref.bucket,
+                fullPath: this._ref.fullPath,
+                name: this._ref.name,
+                downloadURLs: [`https://${this._ref.bucket}/${this._ref.fullPath}`],
+                generation: '1',
+                metageneration: '1',
+                size,
+                timeCreated: new Date().toISOString(),
+                updated: new Date().toISOString(),
+                ...this._metadata,
+            },
+            bytesTransferred: Math.floor((size * this._progress) / 100),
+            totalBytes: size,
+            state: this._cancelled ? 'cancelled' : 'success',
+            task: this,
+        };
+    }
+    _notifyProgress() {
+        const snapshot = this._createSnapshot();
+        this._listeners.forEach(listener => listener(snapshot));
+    }
+}
+/**
+ * Get storage reference
+ */
+export function ref(storage, path) {
+    const bucket = storage.bucket || 'default-bucket';
+    const refPath = path || '/';
+    return new StorageReferenceImpl(storage, bucket, refPath);
+}
+/**
+ * Get reference from URL
+ */
+export function refFromURL(storage, url) {
+    try {
+        const urlObj = new URL(url);
+        const pathParts = urlObj.pathname.split('/').filter(p => p.length > 0);
+        // Extract bucket and path from URL
+        const bucket = pathParts[0] || storage.bucket || 'default-bucket';
+        const path = pathParts.slice(1).join('/');
+        return new StorageReferenceImpl(storage, bucket, path);
+    }
+    catch (error) {
+        throw createFirebaseError('storage/invalid-argument', `Invalid URL: ${url}`);
+    }
+}
+/**
+ * Get child reference
+ */
+export function child(parent, path) {
+    const childPath = `${parent.fullPath}/${path}`.replace(/\/{2,}/g, '/');
+    return new StorageReferenceImpl(parent.storage, parent.bucket, childPath);
+}
+/**
+ * Upload bytes
+ */
+export async function uploadBytes(reference, data, metadata) {
+    const task = new UploadTaskImpl(reference, data, metadata);
+    return task.then();
+}
+/**
+ * Upload resumable (with progress tracking)
+ */
+export function uploadBytesResumable(reference, data, metadata) {
+    return new UploadTaskImpl(reference, data, metadata);
+}
+/**
+ * Upload string
+ */
+export async function uploadString(reference, value, format, metadata) {
+    let data = value;
+    if (format === 'base64') {
+        // Decode base64
+        data = atob(value);
+    }
+    else if (format === 'base64url') {
+        // Decode base64url
+        data = atob(value.replace(/-/g, '+').replace(/_/g, '/'));
+    }
+    else if (format === 'data_url') {
+        // Extract data from data URL
+        const matches = value.match(/,(.*)$/);
+        if (matches) {
+            data = atob(matches[1]);
+        }
+    }
+    return uploadBytes(reference, new Blob([data]), metadata);
+}
+/**
+ * Download bytes
+ */
+export async function getBytes(reference, maxDownloadSizeBytes) {
+    // Mock: return empty buffer
+    return new ArrayBuffer(0);
+}
+/**
+ * Get download URL
+ */
+export async function getDownloadURL(reference) {
+    return `https://${reference.bucket}.storage.googleapis.com/${reference.fullPath}`;
+}
+/**
+ * Get metadata
+ */
+export async function getMetadata(reference) {
+    return {
+        bucket: reference.bucket,
+        fullPath: reference.fullPath,
+        name: reference.name,
+        downloadURLs: [await getDownloadURL(reference)],
+        generation: '1',
+        metageneration: '1',
+        size: 0,
+        timeCreated: new Date().toISOString(),
+        updated: new Date().toISOString(),
+    };
+}
+/**
+ * Update metadata
+ */
+export async function updateMetadata(reference, metadata) {
+    const current = await getMetadata(reference);
+    return { ...current, ...metadata };
+}
+/**
+ * Delete object
+ */
+export async function deleteObject(reference) {
+    // Mock delete
+}
+/**
+ * List files (with pagination)
+ */
+export async function list(reference, options) {
+    return {
+        prefixes: [],
+        items: [],
+        nextPageToken: undefined,
+    };
+}
+/**
+ * List all files
+ */
+export async function listAll(reference) {
+    return {
+        prefixes: [],
+        items: [],
+    };
+}

package/dist/src/api/firebase/types.d.ts

@@ -0,0 +1,341 @@
+/**
+ * Firebase-compatible type definitions
+ */
+export interface FirebaseApp {
+    name: string;
+    config: FirebaseConfig;
+}
+export interface FirebaseConfig {
+    apiKey?: string;
+    authDomain?: string;
+    projectId?: string;
+    storageBucket?: string;
+    messagingSenderId?: string;
+    appId?: string;
+}
+export interface Firestore {
+    app: FirebaseApp;
+    type: 'firestore';
+    _app?: FirebaseApp;
+}
+export interface RealtimeDatabase {
+    app: FirebaseApp;
+    type: 'database';
+    url?: string;
+}
+export interface FirebaseAuth {
+    app: FirebaseApp;
+    type: 'auth';
+    currentUser: User | null;
+    _currentUser: User | null;
+    onAuthStateChanged?(callback: (user: User | null) => void): () => void;
+}
+export interface FirebaseStorage {
+    app: FirebaseApp;
+    type: 'storage';
+    bucket?: string;
+}
+export interface DocumentReference<T = DocumentData> {
+    firestore: Firestore;
+    _key: string;
+    parent: CollectionReference<T>;
+    id: string;
+    path: string;
+    type: 'document';
+}
+export interface CollectionReference<T = DocumentData> {
+    firestore: Firestore;
+    _key: string;
+    path: string;
+    id: string;
+    parent: DocumentReference<DocumentData> | null;
+    type: 'collection';
+    _query?: QueryConstraint[];
+}
+export interface Query<T = DocumentData> {
+    firestore: Firestore;
+    _query: QueryConstraint[];
+    type: 'query';
+}
+export interface DocumentSnapshot<T = DocumentData> {
+    _firestore: Firestore;
+    _userDataWriter: any;
+    _doc: any;
+    ref: DocumentReference<T>;
+    id: string;
+    metadata: SnapshotMetadata;
+    exists(): boolean;
+    data(options?: SnapshotOptions): T | undefined;
+    get(fieldPath: string | FieldPath, options?: SnapshotOptions): any;
+}
+export interface QuerySnapshot<T = DocumentData> {
+    _firestore: Firestore;
+    _snapshot: any;
+    query: Query<T> | CollectionReference<T>;
+    docs: DocumentSnapshot<T>[];
+    size: number;
+    empty: boolean;
+    metadata: SnapshotMetadata;
+    docChanges(options?: SnapshotListenOptions): DocumentChange<T>[];
+    forEach(callback: (doc: DocumentSnapshot<T>) => void): void;
+}
+export interface DocumentChange<T = DocumentData> {
+    type: 'added' | 'removed' | 'modified';
+    doc: DocumentSnapshot<T>;
+    oldIndex: number;
+    newIndex: number;
+}
+export interface SnapshotMetadata {
+    hasPendingWrites: boolean;
+    fromCache: boolean;
+}
+export interface SnapshotOptions {
+    serverTimestamps?: 'estimate' | 'previous' | 'none';
+}
+export interface SnapshotListenOptions {
+    includeMetadataChanges?: boolean;
+}
+export interface QueryConstraint {
+    type: 'where' | 'orderBy' | 'limit' | 'limitToLast' | 'startAt' | 'startAfter' | 'endAt' | 'endBefore' | 'offset';
+    field?: string | FieldPath;
+    operator?: WhereFilterOp;
+    value?: any;
+    direction?: 'asc' | 'desc';
+    count?: number;
+    values?: any[];
+}
+export type WhereFilterOp = '<' | '<=' | '==' | '!=' | '>=' | '>' | 'array-contains' | 'in' | 'not-in' | 'array-contains-any';
+export interface FieldPath {
+    _segments: string[];
+}
+export interface FieldValue {
+    _type: string;
+    _serialize(): any;
+}
+export interface Timestamp {
+    seconds: number;
+    nanoseconds: number;
+    _methodName: string;
+    toDate(): Date;
+    toMillis(): number;
+    isEqual(other: Timestamp): boolean;
+}
+export interface GeoPoint {
+    latitude: number;
+    longitude: number;
+}
+export type DocumentData = {
+    [key: string]: any;
+};
+export interface DatabaseReference {
+    database: RealtimeDatabase;
+    _key: string;
+    _path: string[];
+    key: string | null;
+    parent: DatabaseReference | null;
+    root: DatabaseReference;
+    path: string;
+}
+export interface DataSnapshot {
+    ref: DatabaseReference;
+    _database: RealtimeDatabase;
+    _node: any;
+    key: string | null;
+    size: number;
+    child(path: string): DataSnapshot;
+    exists(): boolean;
+    exportVal(): any;
+    getPriority(): string | number | null;
+    toJSON(): any;
+    val(): any;
+}
+export interface OnDisconnect {
+    ref: DatabaseReference;
+    cancel(onComplete?: (error: Error | null) => void): Promise<void>;
+    remove(onComplete?: (error: Error | null) => void): Promise<void>;
+    set(value: any, onComplete?: (error: Error | null) => void): Promise<void>;
+    setWithPriority(value: any, priority: string | number | null, onComplete?: (error: Error | null) => void): Promise<void>;
+    update(updates: {
+        [key: string]: any;
+    }, onComplete?: (error: Error | null) => void): Promise<void>;
+}
+export interface User {
+    uid: string;
+    email?: string | null;
+    emailVerified: boolean;
+    displayName?: string | null;
+    photoURL?: string | null;
+    phoneNumber?: string | null;
+    isAnonymous: boolean;
+    metadata: UserMetadata;
+    providerData: ProviderData[];
+    password?: string;
+    toJSON(): object;
+    getIdToken(forceRefresh?: boolean): Promise<string>;
+    getIdTokenResult(forceRefresh?: boolean): Promise<IdTokenResult>;
+    refresh(): Promise<void>;
+    delete(): Promise<void>;
+    linkWithCredential(credential: AuthCredential): Promise<UserCredential>;
+    unlink(providerId: string): Promise<UserCredential>;
+    reauthenticateWithCredential(credential: AuthCredential): Promise<UserCredential>;
+    updateProfile(profile: {
+        displayName?: string;
+        photoURL?: string;
+    }): Promise<void>;
+    updateEmail(newEmail: string): Promise<void>;
+    updatePassword(newPassword: string): Promise<void>;
+    updatePhoneNumber(credential: AuthCredential): Promise<void>;
+}
+export interface UserMetadata {
+    creationTime?: number;
+    lastSignInTime?: number;
+    _createdAt?: number;
+    _updatedAt?: number;
+}
+export interface ProviderData {
+    uid: string;
+    displayName: string | null;
+    email: string | null;
+    phoneNumber: string | null;
+    photoURL: string | null;
+    providerId: string;
+}
+export interface UserCredential {
+    user: User;
+    operationType: 'signIn' | 'link' | 'reauthenticate';
+    providerId: string | null;
+}
+export interface IdTokenResult {
+    token: string;
+    expirationTime: string;
+    authTime: string;
+    issuedAtTime: string;
+    signInProvider: string | null;
+    signInSecondFactor?: string | null;
+    claims: {
+        [key: string]: any;
+    };
+}
+export interface AuthProvider {
+    providerId: string;
+    setCustomParameters(customOAuthParameters: {
+        [key: string]: string;
+    }): AuthProvider;
+}
+export interface AuthCredential {
+    providerId: string;
+    signInMethod: string;
+    _idToken?: string;
+    _accessToken?: string;
+    _secret?: string;
+    _refreshToken?: string;
+    toJSON(): object;
+}
+export interface OAuthCredential {
+    providerId: string;
+    provider?: string;
+    signInMethod?: string;
+    idToken?: string;
+    accessToken?: string;
+    secret?: string;
+    refreshToken?: string;
+    identityToken?: string;
+    rawNonce?: string;
+    toJSON?(): object;
+}
+export interface MultiFactorInfo {
+    factorId: string;
+    uid: string;
+    displayName?: string;
+    enrollmentTime: string;
+    phoneNumber?: string;
+}
+export interface MultiFactorSession {
+    credential?: string;
+    _serverResponse?: any;
+}
+export interface PhoneAuthCredential extends AuthCredential {
+    verificationId: string;
+    verificationCode: string;
+}
+export interface ActionCodeInfo {
+    data: {
+        email?: string;
+        newEmail?: string;
+        multiFactorInfo?: any;
+        previousEmail?: string;
+    };
+    operation: 'PASSWORD_RESET' | 'VERIFY_EMAIL' | 'RECOVER_EMAIL' | 'REVERT_SECOND_FACTOR_ADDITION';
+}
+export interface StorageReference {
+    storage: FirebaseStorage;
+    _location: StorageLocation;
+    bucket: string;
+    fullPath: string;
+    name: string;
+    parent: StorageReference | null;
+    root: StorageReference;
+}
+export interface StorageLocation {
+    bucket: string;
+    path: string;
+}
+export interface UploadMetadata {
+    cacheControl?: string;
+    contentDisposition?: string;
+    contentEncoding?: string;
+    contentLanguage?: string;
+    contentType?: string;
+    customMetadata?: {
+        [key: string]: string;
+    };
+}
+export interface FullMetadata extends UploadMetadata {
+    bucket: string;
+    downloadURLs: string[];
+    fullPath: string;
+    generation: string;
+    metageneration: string;
+    name: string;
+    size: number;
+    timeCreated: string;
+    updated: string;
+    md5Hash?: string;
+}
+export interface ListOptions {
+    maxResults?: number;
+    pageToken?: string;
+}
+export interface ListResult {
+    prefixes: StorageReference[];
+    items: StorageReference[];
+    nextPageToken?: string;
+}
+export interface UploadTaskSnapshot {
+    ref: StorageReference;
+    metadata: FullMetadata;
+    bytesTransferred: number;
+    totalBytes: number;
+    state: 'running' | 'paused' | 'success' | 'cancelled' | 'error';
+    task: UploadTask;
+}
+export interface UploadTask {
+    cancel(): boolean;
+    catch(onRejected: (error: Error) => any): Promise<any>;
+    on(event: string, nextOrObserver?: any, error?: (error: Error) => void, complete?: () => void): Function;
+    pause(): boolean;
+    resume(): boolean;
+    then(onFulfilled?: (snapshot: UploadTaskSnapshot) => any, onRejected?: (error: Error) => any): Promise<any>;
+}
+export type IDatabaseReference = DatabaseReference;
+export type IDataSnapshot = DataSnapshot;
+export type IOnDisconnect = OnDisconnect;
+export type IDocumentReference<T = DocumentData> = DocumentReference<T>;
+export type ICollectionReference<T = DocumentData> = CollectionReference<T>;
+export type IDocumentSnapshot<T = DocumentData> = DocumentSnapshot<T>;
+export type IQuerySnapshot<T = DocumentData> = QuerySnapshot<T>;
+export type IQuery<T = DocumentData> = Query<T>;
+export interface FirebaseError extends Error {
+    code: string;
+    customData?: any;
+}

package/dist/src/api/firebase/types.js

@@ -0,0 +1,4 @@
+/**
+ * Firebase-compatible type definitions
+ */
+export {};

package/dist/src/auth/manager.d.ts

@@ -84,7 +84,11 @@ export declare class AuthManager {
     /**
      * Clear local identity (logout)
      */
-    clearIdentity(): Promise<void>;
+    /**
+     * Clear local identity (logout)
+     * @param injectedDb (for testing only) - pass a mock IndexedDB instance
+     */
+    clearIdentity(injectedDb?: any): Promise<void>;
     /**
      * Parse a UCAN token and extract its structure without verification
      * This is for inspection/debugging purposes

package/dist/src/auth/manager.js

@@ -391,23 +391,36 @@ export class AuthManager {
     /**
      * Clear local identity (logout)
      */
-    async clearIdentity() {
+    /**
+     * Clear local identity (logout)
+     * @param injectedDb (for testing only) - pass a mock IndexedDB instance
+     */
+    async clearIdentity(injectedDb) {
         this.keypair = null;
         this.did = null;
         this.oauthIdentities = [];
         this.initialized = false;
         try {
-            const db = await openAuthDB();
+            const db = injectedDb || await openAuthDB();
             if (!db) {
                 return; // IndexedDB not available
             }
             await new Promise((resolve, reject) => {
-                const tx = db.transaction(STORE_NAME, 'readwrite');
-                const store = tx.objectStore(STORE_NAME);
-                const request = store.delete(IDENTITY_KEY);
+                let tx, store, request;
+                try {
+                    tx = db.transaction(STORE_NAME, 'readwrite');
+                    store = tx.objectStore(STORE_NAME);
+                    request = store.delete(IDENTITY_KEY);
+                }
+                catch (err) {
+                    reject(err);
+                    return;
+                }
                 request.onerror = () => reject(request.error);
                 request.onsuccess = () => resolve();
-                tx.oncomplete = () => db.close();
+                if (tx && typeof tx.oncomplete === 'function') {
+                    tx.oncomplete = () => db.close();
+                }
             });
         }
         catch (error) {