firesmelt 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,355 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+
+interface Timestamp {
+    readonly seconds: number;
+    readonly nanoseconds: number;
+    toDate(): Date;
+    toMillis(): number;
+    isEqual(other: Timestamp): boolean;
+}
+declare function isTimestampLike(value: unknown): value is Timestamp;
+interface GeoPoint {
+    readonly latitude: number;
+    readonly longitude: number;
+    isEqual(other: GeoPoint): boolean;
+}
+interface DocumentReference {
+    readonly id: string;
+    readonly path: string;
+}
+interface VectorValue {
+    toArray(): number[];
+    isEqual(other: VectorValue): boolean;
+}
+declare abstract class Sentinel {
+    abstract readonly kind: string;
+}
+declare class ServerTimestampSentinel extends Sentinel {
+    readonly kind = "serverTimestamp";
+}
+declare class IncrementSentinel extends Sentinel {
+    readonly by: number;
+    readonly kind = "increment";
+    constructor(by: number);
+}
+declare class ArrayUnionSentinel<E = unknown> extends Sentinel {
+    readonly values: ReadonlyArray<E>;
+    readonly kind = "arrayUnion";
+    constructor(values: ReadonlyArray<E>);
+}
+declare class ArrayRemoveSentinel<E = unknown> extends Sentinel {
+    readonly values: ReadonlyArray<E>;
+    readonly kind = "arrayRemove";
+    constructor(values: ReadonlyArray<E>);
+}
+declare class DeleteFieldSentinel extends Sentinel {
+    readonly kind = "deleteField";
+}
+declare function serverTimestamp(): ServerTimestampSentinel;
+declare function increment(by: number): IncrementSentinel;
+declare function arrayUnion<E>(...values: Array<E>): ArrayUnionSentinel<E>;
+declare function arrayRemove<E>(...values: Array<E>): ArrayRemoveSentinel<E>;
+declare function deleteField(): DeleteFieldSentinel;
+declare class DocumentIdRef {
+    readonly kind = "documentId";
+}
+declare function documentId(): DocumentIdRef;
+
+interface CollectionDef<S extends StandardSchemaV1 = StandardSchemaV1> {
+    readonly name: string;
+    readonly schema: S;
+    readonly raw?: readonly string[];
+}
+type InferOutput<S extends StandardSchemaV1> = StandardSchemaV1.InferOutput<S>;
+type Doc<S extends StandardSchemaV1> = InferOutput<S> & {
+    id: string;
+};
+type Primitive = string | number | boolean | bigint | symbol | null | undefined | Date;
+type NeutralValue = Timestamp | GeoPoint | DocumentReference | VectorValue | Uint8Array;
+type WithFieldValue<T> = T extends Primitive | NeutralValue ? T : T extends Array<infer E> ? Array<E> : T extends object ? {
+    [K in keyof T]: WithFieldValue<T[K]> | SentinelFor<NonNullable<T[K]>>;
+} : T;
+type SentinelFor<V> = (V extends number ? IncrementSentinel : never) | (V extends Array<infer E> ? ArrayUnionSentinel<E> | ArrayRemoveSentinel<E> : never) | (V extends Date | Timestamp ? ServerTimestampSentinel : never);
+type UpdateValue<V> = Exclude<WithFieldValue<V>, undefined> | SentinelFor<NonNullable<V>> | (undefined extends V ? DeleteFieldSentinel : never);
+type UpdateData<T> = {
+    [K in keyof T]?: UpdateValue<T[K]>;
+};
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type PrefixPaths<P extends string, T> = {
+    [K in keyof T & string as `${P}.${K}`]?: T[K];
+};
+type NestedUpdatePaths<T> = UnionToIntersection<{
+    [K in keyof T & string]: NonNullable<T[K]> extends FieldPathLeaf ? {} : NonNullable<T[K]> extends object ? PrefixPaths<K, UpdatePaths<NonNullable<T[K]>>> : {};
+}[keyof T & string]>;
+type UpdatePaths<T> = UpdateData<T> & NestedUpdatePaths<T>;
+type MergeOptions<T> = {
+    merge: true;
+} | {
+    mergeFields: Array<FieldPath<T>>;
+};
+type WhereFilterOp = "==" | "!=" | "<" | "<=" | ">" | ">=" | "array-contains" | "in" | "not-in" | "array-contains-any";
+type OrderByDirection = "asc" | "desc";
+type ArrayElement<T> = T extends ReadonlyArray<infer E> ? E : never;
+type FieldPathLeaf = Primitive | NeutralValue | ReadonlyArray<unknown>;
+type FieldPath<T> = T extends object ? {
+    [K in keyof T & string]: K | (NonNullable<T[K]> extends FieldPathLeaf ? never : `${K}.${FieldPath<NonNullable<T[K]>>}`);
+}[keyof T & string] : never;
+type NumericFieldPath<T> = {
+    [P in FieldPath<T>]: NonNullable<ValueAtPath<T, P>> extends number ? P : never;
+}[FieldPath<T>];
+type ValueAtPath<T, P extends string> = P extends `${infer Head}.${infer Rest}` ? Head extends keyof T ? ValueAtPath<NonNullable<T[Head]>, Rest> : never : P extends keyof T ? T[P] : never;
+
+type DocumentData = Record<string, unknown>;
+type FieldRef = string | DocumentIdRef;
+interface DocLocation {
+    readonly kind: "doc";
+    readonly segments: readonly string[];
+}
+interface CollectionLocation {
+    readonly kind: "collection";
+    readonly segments: readonly string[];
+}
+interface CollectionGroupLocation {
+    readonly kind: "collectionGroup";
+    readonly collectionId: string;
+}
+type QuerySource = CollectionLocation | CollectionGroupLocation;
+type Constraint = {
+    type: "where";
+    field: FieldRef;
+    op: WhereFilterOp;
+    value: unknown;
+} | {
+    type: "orderBy";
+    field: FieldRef;
+    direction: "asc" | "desc";
+} | {
+    type: "limit";
+    limit: number;
+} | {
+    type: "startAt";
+    values: readonly unknown[];
+} | {
+    type: "startAfter";
+    values: readonly unknown[];
+} | {
+    type: "endAt";
+    values: readonly unknown[];
+} | {
+    type: "endBefore";
+    values: readonly unknown[];
+};
+interface RawSnapshot {
+    readonly id: string;
+    readonly exists: boolean;
+    readonly data: DocumentData | undefined;
+}
+interface WriteOptions {
+    readonly merge?: boolean;
+    readonly mergeFields?: readonly string[];
+}
+interface TransactionOptions {
+    readonly maxAttempts?: number;
+}
+type Unsubscribe = () => void;
+interface DocObserver {
+    next(snapshot: RawSnapshot): void;
+    error?(error: unknown): void;
+}
+interface QueryObserver {
+    next(snapshots: readonly RawSnapshot[]): void;
+    error?(error: unknown): void;
+}
+interface NativeAdapter {
+    timestampFromDate(date: Date): unknown;
+    fieldValue(sentinel: Sentinel): unknown;
+    bytesFromUint8Array(bytes: Uint8Array): unknown;
+}
+interface RawConverter {
+    toNative(data: DocumentData): DocumentData;
+    fromNative(id: string, data: DocumentData): unknown;
+}
+interface TxDriver {
+    get(path: DocLocation): Promise<RawSnapshot>;
+    set(path: DocLocation, data: DocumentData, options?: WriteOptions): void;
+    update(path: DocLocation, data: DocumentData): void;
+    delete(path: DocLocation): void;
+}
+interface BatchDriver {
+    set(path: DocLocation, data: DocumentData, options?: WriteOptions): void;
+    update(path: DocLocation, data: DocumentData): void;
+    delete(path: DocLocation): void;
+    commit(): Promise<void>;
+}
+interface Driver {
+    readonly native: NativeAdapter;
+    getDoc(path: DocLocation): Promise<RawSnapshot>;
+    setDoc(path: DocLocation, data: DocumentData, options?: WriteOptions): Promise<void>;
+    updateDoc(path: DocLocation, data: DocumentData): Promise<void>;
+    addDoc(path: CollectionLocation, data: DocumentData): Promise<string>;
+    deleteDoc(path: DocLocation): Promise<void>;
+    runQuery(source: QuerySource, constraints: readonly Constraint[]): Promise<RawSnapshot[]>;
+    count(source: QuerySource, constraints: readonly Constraint[]): Promise<number>;
+    sum(source: QuerySource, constraints: readonly Constraint[], field: string): Promise<number>;
+    average(source: QuerySource, constraints: readonly Constraint[], field: string): Promise<number | null>;
+    onSnapshotDoc(path: DocLocation, observer: DocObserver): Unsubscribe;
+    onSnapshotQuery(source: QuerySource, constraints: readonly Constraint[], observer: QueryObserver): Unsubscribe;
+    runTransaction<T>(fn: (tx: TxDriver) => Promise<T>, options?: TransactionOptions): Promise<T>;
+    batch(): BatchDriver;
+    docRef(path: DocLocation, converter: RawConverter): unknown;
+    collectionRef(path: CollectionLocation, converter: RawConverter): unknown;
+    queryRef(source: QuerySource, constraints: readonly Constraint[], converter: RawConverter): unknown;
+}
+
+interface QueryContext<S extends StandardSchemaV1> {
+    driver: Driver;
+    def: CollectionDef<S>;
+    source: QuerySource;
+}
+type WhereField<S extends StandardSchemaV1> = FieldPath<InferOutput<S>>;
+type WhereValue<S extends StandardSchemaV1, K extends WhereField<S>> = Exclude<ValueAtPath<InferOutput<S>, K>, undefined>;
+type NumericField<S extends StandardSchemaV1> = NumericFieldPath<InferOutput<S>>;
+type QuerySnapshotObserver<S extends StandardSchemaV1> = ((docs: Array<Doc<S>>) => void) | {
+    next: (docs: Array<Doc<S>>) => void;
+    error?: (error: unknown) => void;
+};
+declare class QueryBuilder<S extends StandardSchemaV1> {
+    #private;
+    constructor(ctx: QueryContext<S>, constraints?: readonly Constraint[]);
+    where<K extends WhereField<S>>(field: K, op: "in" | "not-in", value: Array<WhereValue<S, K>>): QueryBuilder<S>;
+    where<K extends WhereField<S>>(field: K, op: "array-contains", value: ArrayElement<WhereValue<S, K>>): QueryBuilder<S>;
+    where<K extends WhereField<S>>(field: K, op: "array-contains-any", value: Array<ArrayElement<WhereValue<S, K>>>): QueryBuilder<S>;
+    where<K extends WhereField<S>>(field: K, op: "==" | "!=" | "<" | "<=" | ">" | ">=", value: WhereValue<S, K>): QueryBuilder<S>;
+    where(field: DocumentIdRef, op: "in" | "not-in", value: string[]): QueryBuilder<S>;
+    where(field: DocumentIdRef, op: "==" | "!=" | "<" | "<=" | ">" | ">=", value: string): QueryBuilder<S>;
+    orderBy(field: WhereField<S>, direction?: OrderByDirection): QueryBuilder<S>;
+    orderBy(field: DocumentIdRef, direction?: OrderByDirection): QueryBuilder<S>;
+    limit(limit: number): QueryBuilder<S>;
+    startAt(...values: unknown[]): QueryBuilder<S>;
+    startAfter(...values: unknown[]): QueryBuilder<S>;
+    endAt(...values: unknown[]): QueryBuilder<S>;
+    endBefore(...values: unknown[]): QueryBuilder<S>;
+    get(): Promise<Array<Doc<S>>>;
+    list(): Promise<Array<Doc<S>>>;
+    count(): Promise<number>;
+    sum(field: NumericField<S>): Promise<number>;
+    average(field: NumericField<S>): Promise<number | null>;
+    onSnapshot(observer: QuerySnapshotObserver<S>): Unsubscribe;
+    get ref(): unknown;
+}
+
+declare class CollectionHandle<S extends StandardSchemaV1> {
+    #private;
+    constructor(driver: Driver, def: CollectionDef<S>, segments: readonly string[]);
+    doc(id: string): DocumentHandle<S>;
+    get(id: string): Promise<Doc<S> | null>;
+    set(id: string, data: WithFieldValue<InferOutput<S>>): Promise<void>;
+    set(id: string, data: UpdateData<InferOutput<S>>, options: MergeOptions<InferOutput<S>>): Promise<void>;
+    update(id: string, data: UpdatePaths<InferOutput<S>>): Promise<void>;
+    add(data: WithFieldValue<InferOutput<S>>): Promise<string>;
+    delete(id: string): Promise<void>;
+    query(): QueryBuilder<S>;
+    where<K extends WhereField<S>>(field: K, op: "in" | "not-in", value: Array<WhereValue<S, K>>): QueryBuilder<S>;
+    where<K extends WhereField<S>>(field: K, op: "array-contains", value: ArrayElement<WhereValue<S, K>>): QueryBuilder<S>;
+    where<K extends WhereField<S>>(field: K, op: "array-contains-any", value: Array<ArrayElement<WhereValue<S, K>>>): QueryBuilder<S>;
+    where<K extends WhereField<S>>(field: K, op: "==" | "!=" | "<" | "<=" | ">" | ">=", value: WhereValue<S, K>): QueryBuilder<S>;
+    where(field: DocumentIdRef, op: "in" | "not-in", value: string[]): QueryBuilder<S>;
+    where(field: DocumentIdRef, op: "==" | "!=" | "<" | "<=" | ">" | ">=", value: string): QueryBuilder<S>;
+    orderBy(field: WhereField<S>, direction?: OrderByDirection): QueryBuilder<S>;
+    orderBy(field: DocumentIdRef, direction?: OrderByDirection): QueryBuilder<S>;
+    limit(limit: number): QueryBuilder<S>;
+    count(): Promise<number>;
+    sum(field: NumericField<S>): Promise<number>;
+    average(field: NumericField<S>): Promise<number | null>;
+    onSnapshot(observer: QuerySnapshotObserver<S>): Unsubscribe;
+    get ref(): unknown;
+}
+declare class TxCollectionHandle<S extends StandardSchemaV1> {
+    #private;
+    constructor(tx: TxDriver, driver: Driver, def: CollectionDef<S>, segments: readonly string[]);
+    doc(id: string): TxDocumentHandle<S>;
+    get(id: string): Promise<Doc<S> | null>;
+    set(id: string, data: WithFieldValue<InferOutput<S>>): void;
+    set(id: string, data: UpdateData<InferOutput<S>>, options: MergeOptions<InferOutput<S>>): void;
+    update(id: string, data: UpdatePaths<InferOutput<S>>): void;
+    delete(id: string): void;
+}
+declare class BatchCollectionHandle<S extends StandardSchemaV1> {
+    #private;
+    constructor(batch: BatchDriver, driver: Driver, segments: readonly string[]);
+    doc(id: string): BatchDocumentHandle<S>;
+    set(id: string, data: WithFieldValue<InferOutput<S>>): void;
+    set(id: string, data: UpdateData<InferOutput<S>>, options: MergeOptions<InferOutput<S>>): void;
+    update(id: string, data: UpdatePaths<InferOutput<S>>): void;
+    delete(id: string): void;
+}
+type DocSnapshotObserver<S extends StandardSchemaV1> = ((doc: Doc<S> | null) => void) | {
+    next: (doc: Doc<S> | null) => void;
+    error?: (error: unknown) => void;
+};
+declare class DocumentHandle<S extends StandardSchemaV1> {
+    #private;
+    constructor(driver: Driver, def: CollectionDef<S>, segments: readonly string[]);
+    get id(): string;
+    collection<C extends StandardSchemaV1>(def: CollectionDef<C>): CollectionHandle<C>;
+    get(): Promise<Doc<S> | null>;
+    exists(): Promise<boolean>;
+    set(data: WithFieldValue<InferOutput<S>>): Promise<void>;
+    set(data: UpdateData<InferOutput<S>>, options: MergeOptions<InferOutput<S>>): Promise<void>;
+    update(data: UpdatePaths<InferOutput<S>>): Promise<void>;
+    delete(): Promise<void>;
+    onSnapshot(observer: DocSnapshotObserver<S>): Unsubscribe;
+    get ref(): unknown;
+}
+declare class TxDocumentHandle<S extends StandardSchemaV1> {
+    #private;
+    constructor(tx: TxDriver, driver: Driver, def: CollectionDef<S>, segments: readonly string[]);
+    get id(): string;
+    collection<C extends StandardSchemaV1>(def: CollectionDef<C>): TxCollectionHandle<C>;
+    get(): Promise<Doc<S> | null>;
+    set(data: WithFieldValue<InferOutput<S>>): void;
+    set(data: UpdateData<InferOutput<S>>, options: MergeOptions<InferOutput<S>>): void;
+    update(data: UpdatePaths<InferOutput<S>>): void;
+    delete(): void;
+}
+declare class BatchDocumentHandle<S extends StandardSchemaV1> {
+    #private;
+    constructor(batch: BatchDriver, driver: Driver, segments: readonly string[]);
+    get id(): string;
+    collection<C extends StandardSchemaV1>(def: CollectionDef<C>): BatchCollectionHandle<C>;
+    set(data: WithFieldValue<InferOutput<S>>): void;
+    set(data: UpdateData<InferOutput<S>>, options: MergeOptions<InferOutput<S>>): void;
+    update(data: UpdatePaths<InferOutput<S>>): void;
+    delete(): void;
+}
+
+declare class Transaction {
+    #private;
+    constructor(tx: TxDriver, driver: Driver);
+    collection<S extends StandardSchemaV1>(def: CollectionDef<S>): TxCollectionHandle<S>;
+}
+declare class Batch {
+    #private;
+    constructor(batch: BatchDriver, driver: Driver);
+    collection<S extends StandardSchemaV1>(def: CollectionDef<S>): BatchCollectionHandle<S>;
+    commit(): Promise<void>;
+}
+declare class Database {
+    #private;
+    constructor(driver: Driver);
+    collection<S extends StandardSchemaV1>(def: CollectionDef<S>): CollectionHandle<S>;
+    collectionGroup<S extends StandardSchemaV1>(def: CollectionDef<S>): QueryBuilder<S>;
+    runTransaction<T>(fn: (tx: Transaction) => Promise<T>, options?: TransactionOptions): Promise<T>;
+    batch(): Batch;
+}
+
+interface CollectionOptions {
+    raw?: readonly string[];
+}
+declare function collection<S extends StandardSchemaV1>(name: string, schema: S & ("id" extends keyof InferOutput<S> ? never : unknown), options?: CollectionOptions): CollectionDef<S>;
+
+declare class FiresmeltError extends Error {
+    readonly name: string;
+}
+
+export { type ArrayElement, ArrayRemoveSentinel, ArrayUnionSentinel, Batch, BatchCollectionHandle, BatchDocumentHandle, type CollectionDef, CollectionHandle, type CollectionOptions, Database, DeleteFieldSentinel, type Doc, type DocSnapshotObserver, DocumentHandle, DocumentIdRef, type DocumentReference, type FieldPath, FiresmeltError, type GeoPoint, IncrementSentinel, type InferOutput, type MergeOptions, type NumericField, type NumericFieldPath, type OrderByDirection, QueryBuilder, type QuerySnapshotObserver, type SentinelFor, ServerTimestampSentinel, type Timestamp, Transaction, type TransactionOptions, TxCollectionHandle, TxDocumentHandle, type Unsubscribe, type UpdateData, type UpdatePaths, type UpdateValue, type ValueAtPath, type VectorValue, type WhereField, type WhereFilterOp, type WhereValue, type WithFieldValue, arrayRemove, arrayUnion, collection, deleteField, documentId, increment, isTimestampLike, serverTimestamp };

package/dist/index.js

@@ -0,0 +1,3 @@
+export { Batch, BatchCollectionHandle, BatchDocumentHandle, CollectionHandle, Database, DocumentHandle, FiresmeltError, QueryBuilder, Transaction, TxCollectionHandle, TxDocumentHandle, arrayRemove, arrayUnion, collection, deleteField, documentId, increment, isTimestampLike, serverTimestamp } from './chunk-WEVOVXQQ.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/web.d.ts

@@ -0,0 +1,11 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { CollectionReference, Firestore, DocumentReference, Query } from 'firebase/firestore';
+import { CollectionHandle, Doc, Database, DocumentHandle, QueryBuilder } from './index.js';
+export { ArrayElement, ArrayRemoveSentinel, ArrayUnionSentinel, Batch, BatchCollectionHandle, BatchDocumentHandle, CollectionDef, CollectionOptions, DeleteFieldSentinel, DocSnapshotObserver, DocumentIdRef, DocumentReference, FieldPath, FiresmeltError, GeoPoint, IncrementSentinel, InferOutput, MergeOptions, NumericField, NumericFieldPath, OrderByDirection, QuerySnapshotObserver, SentinelFor, ServerTimestampSentinel, Timestamp, Transaction, TransactionOptions, TxCollectionHandle, TxDocumentHandle, Unsubscribe, UpdateData, UpdatePaths, UpdateValue, ValueAtPath, VectorValue, WhereField, WhereFilterOp, WhereValue, WithFieldValue, arrayRemove, arrayUnion, collection, deleteField, documentId, increment, isTimestampLike, serverTimestamp } from './index.js';
+
+declare function createDatabase(firestore: Firestore): Database;
+declare function docRef<S extends StandardSchemaV1>(handle: DocumentHandle<S>): DocumentReference<Doc<S>>;
+declare function collectionRef<S extends StandardSchemaV1>(handle: CollectionHandle<S>): CollectionReference<Doc<S>>;
+declare function queryRef<S extends StandardSchemaV1>(builder: QueryBuilder<S>): Query<Doc<S>>;
+
+export { CollectionHandle, Database, Doc, DocumentHandle, QueryBuilder, collectionRef, createDatabase, docRef, queryRef };

package/dist/web.js

@@ -0,0 +1,252 @@
+import { Database, ServerTimestampSentinel, IncrementSentinel, ArrayUnionSentinel, ArrayRemoveSentinel, DeleteFieldSentinel, FiresmeltError, toNative } from './chunk-WEVOVXQQ.js';
+export { Batch, BatchCollectionHandle, BatchDocumentHandle, CollectionHandle, Database, DocumentHandle, FiresmeltError, QueryBuilder, Transaction, TxCollectionHandle, TxDocumentHandle, arrayRemove, arrayUnion, collection, deleteField, documentId, increment, isTimestampLike, serverTimestamp } from './chunk-WEVOVXQQ.js';
+import { Bytes, Timestamp, serverTimestamp, increment, arrayUnion, arrayRemove, deleteField, doc, collection, collectionGroup, query, endBefore, endAt, startAfter, startAt, limit, orderBy, where, getDoc, setDoc, updateDoc, addDoc, deleteDoc, getDocs, getCountFromServer, getAggregateFromServer, sum, average, onSnapshot, runTransaction, writeBatch, documentId } from 'firebase/firestore';
+
+var SNAPSHOT_OPTIONS = { serverTimestamps: "estimate" };
+var WebDriver = class {
+  native;
+  #fs;
+  constructor(firestore) {
+    this.#fs = firestore;
+    this.native = {
+      timestampFromDate: (date) => Timestamp.fromDate(date),
+      fieldValue: (sentinel) => this.#fieldValue(sentinel),
+      bytesFromUint8Array: (bytes) => Bytes.fromUint8Array(bytes)
+    };
+  }
+  #fieldValue(sentinel) {
+    if (sentinel instanceof ServerTimestampSentinel) {
+      return serverTimestamp();
+    }
+    if (sentinel instanceof IncrementSentinel) {
+      return increment(sentinel.by);
+    }
+    if (sentinel instanceof ArrayUnionSentinel) {
+      return arrayUnion(...this.#values(sentinel.values));
+    }
+    if (sentinel instanceof ArrayRemoveSentinel) {
+      return arrayRemove(...this.#values(sentinel.values));
+    }
+    if (sentinel instanceof DeleteFieldSentinel) {
+      return deleteField();
+    }
+    throw new FiresmeltError("Unknown sentinel");
+  }
+  #values(values) {
+    return values.map((value) => toNative(value, this.native));
+  }
+  #setOptions(options) {
+    if (options?.mergeFields) {
+      return { mergeFields: [...options.mergeFields] };
+    }
+    if (options?.merge) {
+      return { merge: true };
+    }
+    return void 0;
+  }
+  #doc(segments) {
+    return doc(this.#fs, segments.join("/"));
+  }
+  #collection(segments) {
+    return collection(this.#fs, segments.join("/"));
+  }
+  #query(source, constraints) {
+    const base = source.kind === "collection" ? this.#collection(source.segments) : collectionGroup(this.#fs, source.collectionId);
+    return query(base, ...constraints.map((c) => this.#constraint(c)));
+  }
+  #constraint(constraint) {
+    switch (constraint.type) {
+      case "where":
+        return where(
+          fieldRef(constraint.field),
+          constraint.op,
+          toNative(constraint.value, this.native)
+        );
+      case "orderBy":
+        return orderBy(fieldRef(constraint.field), constraint.direction);
+      case "limit":
+        return limit(constraint.limit);
+      case "startAt":
+        return startAt(...this.#values(constraint.values));
+      case "startAfter":
+        return startAfter(...this.#values(constraint.values));
+      case "endAt":
+        return endAt(...this.#values(constraint.values));
+      case "endBefore":
+        return endBefore(...this.#values(constraint.values));
+    }
+  }
+  async getDoc(path) {
+    const snapshot = await getDoc(this.#doc(path.segments));
+    return {
+      id: snapshot.id,
+      exists: snapshot.exists(),
+      data: snapshot.data(SNAPSHOT_OPTIONS)
+    };
+  }
+  async setDoc(path, data, options) {
+    const ref = this.#doc(path.segments);
+    const setOptions = this.#setOptions(options);
+    await (setOptions ? setDoc(ref, data, setOptions) : setDoc(ref, data));
+  }
+  async updateDoc(path, data) {
+    await updateDoc(this.#doc(path.segments), data);
+  }
+  async addDoc(path, data) {
+    const ref = await addDoc(this.#collection(path.segments), data);
+    return ref.id;
+  }
+  async deleteDoc(path) {
+    await deleteDoc(this.#doc(path.segments));
+  }
+  async runQuery(source, constraints) {
+    const snapshot = await getDocs(this.#query(source, constraints));
+    return snapshot.docs.map((doc) => ({
+      id: doc.id,
+      exists: true,
+      data: doc.data(SNAPSHOT_OPTIONS)
+    }));
+  }
+  async count(source, constraints) {
+    const snapshot = await getCountFromServer(this.#query(source, constraints));
+    return snapshot.data().count;
+  }
+  async sum(source, constraints, field) {
+    const snapshot = await getAggregateFromServer(
+      this.#query(source, constraints),
+      { value: sum(field) }
+    );
+    return snapshot.data().value;
+  }
+  async average(source, constraints, field) {
+    const snapshot = await getAggregateFromServer(
+      this.#query(source, constraints),
+      { value: average(field) }
+    );
+    return snapshot.data().value;
+  }
+  onSnapshotDoc(path, observer) {
+    return onSnapshot(
+      this.#doc(path.segments),
+      (snapshot) => observer.next({
+        id: snapshot.id,
+        exists: snapshot.exists(),
+        data: snapshot.data(SNAPSHOT_OPTIONS)
+      }),
+      observer.error?.bind(observer)
+    );
+  }
+  onSnapshotQuery(source, constraints, observer) {
+    return onSnapshot(
+      this.#query(source, constraints),
+      (snapshot) => observer.next(
+        snapshot.docs.map((doc) => ({
+          id: doc.id,
+          exists: true,
+          data: doc.data(SNAPSHOT_OPTIONS)
+        }))
+      ),
+      observer.error?.bind(observer)
+    );
+  }
+  runTransaction(fn, options) {
+    return runTransaction(
+      this.#fs,
+      (transaction) => {
+        const tx = {
+          get: async (path) => {
+            const snapshot = await transaction.get(this.#doc(path.segments));
+            return {
+              id: snapshot.id,
+              exists: snapshot.exists(),
+              data: snapshot.data(SNAPSHOT_OPTIONS)
+            };
+          },
+          set: (path, data, options2) => {
+            const ref = this.#doc(path.segments);
+            const setOptions = this.#setOptions(options2);
+            if (setOptions) {
+              transaction.set(ref, data, setOptions);
+            } else {
+              transaction.set(ref, data);
+            }
+          },
+          update: (path, data) => {
+            transaction.update(this.#doc(path.segments), data);
+          },
+          delete: (path) => {
+            transaction.delete(this.#doc(path.segments));
+          }
+        };
+        return fn(tx);
+      },
+      options
+    );
+  }
+  batch() {
+    const batch = writeBatch(this.#fs);
+    return {
+      set: (path, data, options) => {
+        const ref = this.#doc(path.segments);
+        const setOptions = this.#setOptions(options);
+        if (setOptions) {
+          batch.set(ref, data, setOptions);
+        } else {
+          batch.set(ref, data);
+        }
+      },
+      update: (path, data) => {
+        batch.update(this.#doc(path.segments), data);
+      },
+      delete: (path) => {
+        batch.delete(this.#doc(path.segments));
+      },
+      commit: async () => {
+        await batch.commit();
+      }
+    };
+  }
+  docRef(path, converter) {
+    return this.#doc(path.segments).withConverter(adaptConverter(converter));
+  }
+  collectionRef(path, converter) {
+    return this.#collection(path.segments).withConverter(
+      adaptConverter(converter)
+    );
+  }
+  queryRef(source, constraints, converter) {
+    return this.#query(source, constraints).withConverter(
+      adaptConverter(converter)
+    );
+  }
+};
+function fieldRef(field) {
+  return typeof field === "string" ? field : documentId();
+}
+function adaptConverter(converter) {
+  return {
+    toFirestore: (model) => converter.toNative(model),
+    fromFirestore: (snapshot, options) => converter.fromNative(
+      snapshot.id,
+      snapshot.data(options.serverTimestamps ? options : SNAPSHOT_OPTIONS)
+    )
+  };
+}
+
+// src/web.ts
+function createDatabase(firestore) {
+  return new Database(new WebDriver(firestore));
+}
+function docRef(handle) {
+  return handle.ref;
+}
+function collectionRef(handle) {
+  return handle.ref;
+}
+function queryRef(builder) {
+  return builder.ref;
+}
+
+export { collectionRef, createDatabase, docRef, queryRef };
+//# sourceMappingURL=web.js.map
+//# sourceMappingURL=web.js.map