@affectively/dash 5.3.0 → 5.3.1

package/dist/src/api/firebase/firestore/data-types.d.ts

@@ -1,116 +0,0 @@
-/**
- * Firestore data types and utilities
- */
-import type { FieldValue as IFieldValue, Timestamp as ITimestamp, GeoPoint as IGeoPoint } from '../types.js';
-/**
- * Represents a timestamp value on the server
- */
-export declare class Timestamp implements ITimestamp {
-    readonly seconds: number;
-    readonly nanoseconds: number;
-    readonly _methodName: string;
-    constructor(seconds: number, nanoseconds: number);
-    static now(): Timestamp;
-    static fromDate(date: Date): Timestamp;
-    static fromMillis(milliseconds: number): Timestamp;
-    toDate(): Date;
-    toMillis(): number;
-    _compareTo(other: Timestamp): number;
-    isEqual(other: Timestamp): boolean;
-    toString(): string;
-    toJSON(): {
-        seconds: number;
-        nanoseconds: number;
-    };
-}
-/**
- * Represents a geographical point
- */
-export declare class GeoPoint implements IGeoPoint {
-    readonly latitude: number;
-    readonly longitude: number;
-    constructor(latitude: number, longitude: number);
-    isEqual(other: GeoPoint): boolean;
-    toString(): string;
-    toJSON(): {
-        latitude: number;
-        longitude: number;
-    };
-}
-/**
- * Represents a field value
- */
-export declare class FieldValue implements IFieldValue {
-    _type: string;
-    constructor(type: string);
-    _serialize(): any;
-}
-/**
- * Sentinel value indicating server timestamp
- */
-export declare class ServerTimestamp extends FieldValue {
-    constructor();
-    _serialize(): {
-        __type: string;
-    };
-}
-/**
- * Sentinel value for delete field
- */
-export declare class DeleteField extends FieldValue {
-    constructor();
-    _serialize(): {
-        __type: string;
-    };
-}
-/**
- * Sentinel value for array union
- */
-export declare class ArrayUnion extends FieldValue {
-    elements: any[];
-    constructor(elements: any[]);
-    _serialize(): {
-        __type: string;
-        elements: any[];
-    };
-}
-/**
- * Sentinel value for array remove
- */
-export declare class ArrayRemove extends FieldValue {
-    elements: any[];
-    constructor(elements: any[]);
-    _serialize(): {
-        __type: string;
-        elements: any[];
-    };
-}
-/**
- * Sentinel value for numeric increment
- */
-export declare class Increment extends FieldValue {
-    operand: number;
-    constructor(operand: number);
-    get delta(): number;
-    _serialize(): {
-        __type: string;
-        operand: number;
-    };
-}
-export declare function serverTimestamp(): ServerTimestamp;
-export declare function deleteField(): DeleteField;
-export declare function arrayUnion(elements: any[]): ArrayUnion;
-export declare function arrayRemove(elements: any[]): ArrayRemove;
-export declare function increment(delta: number): Increment;
-/**
- * Test if a value is a field value sentinel
- */
-export declare function isFieldValue(value: any): value is FieldValue;
-/**
- * Serialize field values for storage
- */
-export declare function serializeFieldValue(value: any): any;
-/**
- * Deserialize field values from storage
- */
-export declare function deserializeFieldValue(value: any): any;

package/dist/src/api/firebase/firestore/data-types.js

@@ -1,280 +0,0 @@
-/**
- * Firestore data types and utilities
- */
-import { createFirebaseError } from '../errors.js';
-/**
- * Represents a timestamp value on the server
- */
-export class Timestamp {
-    seconds;
-    nanoseconds;
-    _methodName = 'serverTimestamp';
-    constructor(seconds, nanoseconds) {
-        if (nanoseconds < 0 || nanoseconds >= 1e9) {
-            throw createFirebaseError('firestore/invalid-argument', 'Timestamp nanoseconds out of range: ' + nanoseconds);
-        }
-        if (seconds < -62135596800 || seconds > 253402300799) {
-            throw createFirebaseError('firestore/invalid-argument', 'Timestamp seconds out of range: ' + seconds);
-        }
-        this.seconds = Math.floor(seconds);
-        this.nanoseconds = Math.floor(nanoseconds);
-    }
-    static now() {
-        return Timestamp.fromDate(new Date());
-    }
-    static fromDate(date) {
-        const milliseconds = date.getTime();
-        const seconds = Math.floor(milliseconds / 1000);
-        const nanos = (milliseconds % 1000) * 1000000;
-        return new Timestamp(seconds, nanos);
-    }
-    static fromMillis(milliseconds) {
-        const seconds = Math.floor(milliseconds / 1000);
-        const nanos = (milliseconds % 1000) * 1000000;
-        return new Timestamp(seconds, nanos);
-    }
-    toDate() {
-        return new Date(this.toMillis());
-    }
-    toMillis() {
-        return this.seconds * 1000 + this.nanoseconds / 1000000;
-    }
-    _compareTo(other) {
-        if (this.seconds < other.seconds)
-            return -1;
-        if (this.seconds > other.seconds)
-            return 1;
-        if (this.nanoseconds < other.nanoseconds)
-            return -1;
-        if (this.nanoseconds > other.nanoseconds)
-            return 1;
-        return 0;
-    }
-    isEqual(other) {
-        return this.seconds === other.seconds && this.nanoseconds === other.nanoseconds;
-    }
-    toString() {
-        return `Timestamp(seconds=${this.seconds}, nanoseconds=${this.nanoseconds})`;
-    }
-    toJSON() {
-        return {
-            seconds: this.seconds,
-            nanoseconds: this.nanoseconds,
-        };
-    }
-}
-/**
- * Represents a geographical point
- */
-export class GeoPoint {
-    latitude;
-    longitude;
-    constructor(latitude, longitude) {
-        if (typeof latitude !== 'number' || latitude < -90 || latitude > 90) {
-            throw createFirebaseError('firestore/invalid-argument', 'Latitude must be between -90 and 90, got: ' + latitude);
-        }
-        if (typeof longitude !== 'number' || longitude < -180 || longitude > 180) {
-            throw createFirebaseError('firestore/invalid-argument', 'Longitude must be between -180 and 180, got: ' + longitude);
-        }
-        this.latitude = latitude;
-        this.longitude = longitude;
-    }
-    isEqual(other) {
-        return this.latitude === other.latitude && this.longitude === other.longitude;
-    }
-    toString() {
-        return `GeoPoint(latitude=${this.latitude}, longitude=${this.longitude})`;
-    }
-    toJSON() {
-        return {
-            latitude: this.latitude,
-            longitude: this.longitude,
-        };
-    }
-}
-/**
- * Represents a field value
- */
-export class FieldValue {
-    _type;
-    constructor(type) {
-        this._type = type;
-    }
-    _serialize() {
-        throw new Error('FieldValue._serialize() must be implemented by subclass');
-    }
-}
-/**
- * Sentinel value indicating server timestamp
- */
-export class ServerTimestamp extends FieldValue {
-    constructor() {
-        super('serverTimestamp');
-    }
-    _serialize() {
-        return {
-            __type: 'serverTimestamp',
-        };
-    }
-}
-/**
- * Sentinel value for delete field
- */
-export class DeleteField extends FieldValue {
-    constructor() {
-        super('deleteField');
-    }
-    _serialize() {
-        return {
-            __type: 'deleteField',
-        };
-    }
-}
-/**
- * Sentinel value for array union
- */
-export class ArrayUnion extends FieldValue {
-    elements;
-    constructor(elements) {
-        super('arrayUnion');
-        this.elements = elements;
-    }
-    _serialize() {
-        return {
-            __type: 'arrayUnion',
-            elements: this.elements,
-        };
-    }
-}
-/**
- * Sentinel value for array remove
- */
-export class ArrayRemove extends FieldValue {
-    elements;
-    constructor(elements) {
-        super('arrayRemove');
-        this.elements = elements;
-    }
-    _serialize() {
-        return {
-            __type: 'arrayRemove',
-            elements: this.elements,
-        };
-    }
-}
-/**
- * Sentinel value for numeric increment
- */
-export class Increment extends FieldValue {
-    operand;
-    constructor(operand) {
-        super('increment');
-        if (typeof operand !== 'number') {
-            throw createFirebaseError('firestore/invalid-argument', 'Increment operand must be a number');
-        }
-        this.operand = operand;
-    }
-    get delta() {
-        return this.operand;
-    }
-    _serialize() {
-        return {
-            __type: 'increment',
-            operand: this.operand,
-        };
-    }
-}
-// Public factory functions
-export function serverTimestamp() {
-    return new ServerTimestamp();
-}
-export function deleteField() {
-    return new DeleteField();
-}
-export function arrayUnion(elements) {
-    return new ArrayUnion(elements);
-}
-export function arrayRemove(elements) {
-    return new ArrayRemove(elements);
-}
-export function increment(delta) {
-    return new Increment(delta);
-}
-/**
- * Test if a value is a field value sentinel
- */
-export function isFieldValue(value) {
-    return value instanceof FieldValue;
-}
-/**
- * Serialize field values for storage
- */
-export function serializeFieldValue(value) {
-    if (value === null || value === undefined) {
-        return value;
-    }
-    // Handle -0 specially to preserve it
-    if (typeof value === 'number' && Object.is(value, -0)) {
-        return -0;
-    }
-    if (isFieldValue(value)) {
-        return value._serialize();
-    }
-    if (value instanceof Timestamp) {
-        return value.toJSON();
-    }
-    if (value instanceof Date) {
-        return Timestamp.fromDate(value).toJSON();
-    }
-    if (value instanceof Array) {
-        return value.map(v => serializeFieldValue(v));
-    }
-    if (value && typeof value === 'object') {
-        const result = {};
-        for (const [key, val] of Object.entries(value)) {
-            result[key] = serializeFieldValue(val);
-        }
-        return result;
-    }
-    return value;
-}
-/**
- * Deserialize field values from storage
- */
-export function deserializeFieldValue(value) {
-    if (value === null || value === undefined) {
-        return value;
-    }
-    // Handle serialized Timestamp objects
-    if (typeof value === 'object' && value !== null &&
-        typeof value.seconds === 'number' &&
-        typeof value.nanoseconds === 'number' &&
-        !value.__type) { // Not a field value
-        return new Timestamp(value.seconds, value.nanoseconds);
-    }
-    if (typeof value === 'object' && value.__type) {
-        switch (value.__type) {
-            case 'serverTimestamp':
-                return new Timestamp(value.seconds || 0, value.nanoseconds || 0);
-            case 'deleteField':
-                return deleteField();
-            case 'arrayUnion':
-                return new ArrayUnion(value.elements || []);
-            case 'arrayRemove':
-                return new ArrayRemove(value.elements || []);
-            case 'increment':
-                return new Increment(value.operand || 0);
-        }
-    }
-    if (value instanceof Array) {
-        return value.map(v => deserializeFieldValue(v));
-    }
-    if (value && typeof value === 'object') {
-        const result = {};
-        for (const [key, val] of Object.entries(value)) {
-            result[key] = deserializeFieldValue(val);
-        }
-        return result;
-    }
-    return value;
-}

package/dist/src/api/firebase/firestore/index.d.ts

@@ -1,7 +0,0 @@
-/**
- * Firebase Firestore compatibility layer
- */
-export { collection, doc, query, where, orderBy, limit, limitToLast, startAt, startAfter, endAt, endBefore, offset, FieldPathClass, QueryImpl, DocumentReferenceImpl, CollectionReferenceImpl, compileQuery, } from './query.js';
-export { Timestamp, GeoPoint, FieldValue, serverTimestamp, deleteField, arrayUnion, arrayRemove, increment, isFieldValue, serializeFieldValue, deserializeFieldValue, } from './data-types.js';
-export { DocumentSnapshotImpl, QuerySnapshotImpl, getDoc, getDocs, getDocFromCache, getDocsFromCache, setDoc, updateDoc, deleteDoc, WriteBatch, writeBatch, Transaction, runTransaction, } from './operations.js';
-export { onSnapshot, } from './listeners.js';

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

@@ -1,13 +0,0 @@
-/**
- * Firebase Firestore compatibility layer
- */
-export { 
-// Query builders
-collection, doc, query, where, orderBy, limit, limitToLast, startAt, startAfter, endAt, endBefore, offset, FieldPathClass, QueryImpl, DocumentReferenceImpl, CollectionReferenceImpl, compileQuery, } from './query.js';
-export { 
-// Data types
-Timestamp, GeoPoint, FieldValue, serverTimestamp, deleteField, arrayUnion, arrayRemove, increment, isFieldValue, serializeFieldValue, deserializeFieldValue, } from './data-types.js';
-export { 
-// Operations
-DocumentSnapshotImpl, QuerySnapshotImpl, getDoc, getDocs, getDocFromCache, getDocsFromCache, setDoc, updateDoc, deleteDoc, WriteBatch, writeBatch, Transaction, runTransaction, } from './operations.js';
-export { onSnapshot, } from './listeners.js';

package/dist/src/api/firebase/firestore/listeners.d.ts

@@ -1,20 +0,0 @@
-/**
- * Real-time listeners for Firestore and Realtime Database
- */
-import type { Query, DocumentReference, QuerySnapshot, DocumentSnapshot, DataSnapshot, DatabaseReference } from '../types.js';
-export type UnsubscribeFn = () => void;
-export type OnSnapshotCallback<T> = {
-    next?: (snapshot: T) => void;
-    error?: (error: Error) => void;
-    complete?: () => void;
-} | ((snapshot: T) => void);
-export type OnErrorCallback = (error: Error) => void;
-export type OnCompleteCallback = () => void;
-/**
- * Firestore listener for documents
- */
-export declare function onSnapshot<T = any>(reference: DocumentReference<T> | Query<T>, callback: OnSnapshotCallback<DocumentSnapshot<T> | QuerySnapshot<T>>, error?: OnErrorCallback, complete?: OnCompleteCallback): UnsubscribeFn;
-/**
- * Realtime Database listener for values
- */
-export declare function onValue(reference: DatabaseReference, callback: (snapshot: DataSnapshot) => void, error?: (error: Error) => void, complete?: () => void): UnsubscribeFn;

package/dist/src/api/firebase/firestore/listeners.js

@@ -1,50 +0,0 @@
-/**
- * Real-time listeners for Firestore and Realtime Database
- */
-import { DocumentReferenceImpl } from './query.js';
-import { DocumentSnapshotImpl } from './operations.js';
-/**
- * Firestore listener for documents
- */
-export function onSnapshot(reference, callback, error, complete) {
-    // Mock mode for tests
-    const key = reference instanceof DocumentReferenceImpl ? `doc:${reference.path}` : `query:${reference.toString()}`;
-    const mockListeners = globalThis.mockListeners;
-    if (!mockListeners.has(key)) {
-        mockListeners.set(key, new Set());
-    }
-    mockListeners.get(key).add(callback);
-    // Initial call with empty snapshot
-    const initialSnapshot = reference instanceof DocumentReferenceImpl
-        ? new DocumentSnapshotImpl(reference.firestore, reference, {}, { hasPendingWrites: false, fromCache: false })
-        : {
-            docs: [],
-            size: 0,
-            empty: true,
-            metadata: { hasPendingWrites: false, fromCache: false },
-            forEach: () => { },
-        };
-    if (typeof callback === 'function') {
-        callback(initialSnapshot);
-    }
-    else if (callback && typeof callback.next === 'function') {
-        callback.next(initialSnapshot);
-    } // Enable initial call
-    // Return unsubscribe
-    return () => {
-        const listeners = mockListeners.get(key);
-        if (listeners) {
-            listeners.delete(callback);
-            if (listeners.size === 0) {
-                mockListeners.delete(key);
-            }
-        }
-    };
-}
-/**
- * Realtime Database listener for values
- */
-export function onValue(reference, callback, error, complete) {
-    // Mock for tests
-    return () => { };
-}

package/dist/src/api/firebase/firestore/operations.d.ts

@@ -1,123 +0,0 @@
-/**
- * Firestore document operations (read/write)
- */
-import type { DocumentSnapshot, QuerySnapshot, IDocumentSnapshot, IQuerySnapshot, DocumentChange, SnapshotOptions, Firestore, DocumentData, DocumentReference, Query, SnapshotMetadata } from '../types.js';
-export declare const mockListeners: Map<string, Set<Function>>;
-export declare function triggerMockListeners(key: string, snapshot: any): void;
-/**
- * Document snapshot implementation
- */
-export declare class DocumentSnapshotImpl<T = DocumentData> implements IDocumentSnapshot<T> {
-    _firestore: Firestore;
-    _userDataWriter: any;
-    _doc: any;
-    ref: DocumentReference<T>;
-    readonly metadata: SnapshotMetadata;
-    constructor(firestore: Firestore, ref: DocumentReference<T>, data: T | null, metadata: SnapshotMetadata);
-    get id(): string;
-    exists(): boolean;
-    data(options?: SnapshotOptions): T | undefined;
-    get(fieldPath: string, options?: SnapshotOptions): any;
-    toJSON(): any;
-    private _deepFreeze;
-    private _deepCopy;
-}
-/**
- * Query snapshot implementation
- */
-export declare class QuerySnapshotImpl<T = DocumentData> implements IQuerySnapshot<T> {
-    _firestore: Firestore;
-    _snapshot: any;
-    query: Query<T> | any;
-    docs: DocumentSnapshotImpl<T>[];
-    size: number;
-    empty: boolean;
-    metadata: SnapshotMetadata;
-    _docChanges: DocumentChange<T>[] | null;
-    constructor(firestore: Firestore, query: Query<T> | any, docs: DocumentSnapshotImpl<T>[], metadata: SnapshotMetadata);
-    docChanges(): DocumentChange<T>[];
-    forEach(callback: (doc: DocumentSnapshotImpl<T>) => void): void;
-    toJSON(): any[];
-}
-/**
- * Get a single document snapshot
- */
-export declare function getDoc(reference: DocumentReference<any>, engine?: any): Promise<IDocumentSnapshot>;
-/**
- * Get multiple documents from a query
- */
-export declare function getDocs(q: Query<any>, engine?: any): Promise<IQuerySnapshot>;
-/**
- * Get document from local cache
- */
-export declare function getDocFromCache(reference: DocumentReference<any>, cache?: Map<string, any>): Promise<IDocumentSnapshot>;
-/**
- * Get documents from local cache
- */
-export declare function getDocsFromCache(q: Query<any>, cache?: Map<string, any>): Promise<IQuerySnapshot>;
-/**
- * Set document data (write)
- */
-export declare function setDoc(reference: DocumentReference<any>, data: any, options?: {
-    merge?: boolean;
-}, engine?: any): Promise<void>;
-/**
- * Update document data (partial write)
- */
-export declare function updateDoc(reference: DocumentReference<any>, data: any, engine?: any): Promise<void>;
-/**
- * Delete document
- */
-export declare function deleteDoc(reference: DocumentReference<any>, engine?: any): Promise<void>;
-/**
- * Batch write operations
- */
-export declare class WriteBatch {
-    _firestore: Firestore;
-    _engine: any;
-    _writes: Array<{
-        type: string;
-        ref: any;
-        data: any;
-        options?: any;
-    }>;
-    constructor(firestore: Firestore, engine: any);
-    set(reference: DocumentReference<any>, data: any, options?: {
-        merge?: boolean;
-    }): WriteBatch;
-    update(reference: DocumentReference<any>, data: any): WriteBatch;
-    delete(reference: DocumentReference<any>): WriteBatch;
-    commit(): Promise<void>;
-}
-/**
- * Create a write batch
- */
-export declare function writeBatch(firestore: Firestore, engine?: any): WriteBatch;
-/**
- * Run a transaction
- */
-export declare function runTransaction<T>(firestore: Firestore, updateFunction: (transaction: Transaction) => Promise<T>, engine?: any): Promise<T>;
-/**
- * Transaction object for transactional reads and writes
- */
-export declare class Transaction {
-    _firestore: Firestore;
-    _engine: any;
-    constructor(firestore: Firestore, engine: any);
-    get(reference: DocumentReference<any>): Promise<IDocumentSnapshot>;
-    set(reference: DocumentReference<any>, data: any, options?: {
-        merge?: boolean;
-    }): Promise<void>;
-    update(reference: DocumentReference<any>, data: any): Promise<void>;
-    delete(reference: DocumentReference<any>): Promise<void>;
-}
-/**
- * Listen for document/query changes
- */
-export declare function onSnapshot(reference: DocumentReference | Query, observer: {
-    next?: (snapshot: DocumentSnapshot | QuerySnapshot) => void;
-    error?: (error: Error) => void;
-    complete?: () => void;
-} | ((snapshot: DocumentSnapshot | QuerySnapshot) => void), options?: {
-    includeMetadataChanges?: boolean;
-}): () => void;