@evolu/common 1.0.0

package/dist/src/Evolu.js

@@ -0,0 +1,235 @@
+import { Context, Effect, Either, Function, Layer, Number, Option, ReadonlyArray, absurd, pipe, } from "effect";
+import { Config, ConfigLive } from "./Config.js";
+import { Bip39, NanoId } from "./Crypto.js";
+import { makeCreateQuery, } from "./Db.js";
+import { DbWorker, } from "./DbWorker.js";
+import { applyPatches } from "./Diff.js";
+import { cast } from "./Model.js";
+import { AppState, FlushSync } from "./Platform.js";
+import { makeStore } from "./Store.js";
+import { Time, TimeLive } from "./Timestamp.js";
+export const Evolu = () => Context.Tag("evolu/Evolu");
+const QueryStore = Context.Tag("evolu/QueryStore");
+const Mutate = () => Context.Tag("evolu/Mutate");
+const OwnerActions = Context.Tag("evolu/OwnerActions");
+const SubscribedQueries = Context.Tag("evolu/SubscribedQueries");
+const OnCompletes = Context.Tag("evolu/OnCompletes");
+const LoadingPromises = Context.Tag("evolu/LoadingPromises");
+export const loadingPromisesPromiseProp = "rows";
+const LoadingPromisesLive = Layer.effect(LoadingPromises, Effect.sync(() => {
+    const promises = new Map();
+    const getPromise = (query) => {
+        const item = promises.get(query);
+        if (item)
+            return { promise: item.promise, isNew: false };
+        let resolve = Function.constVoid;
+        const promise = new Promise((_resolve) => {
+            resolve = _resolve;
+        });
+        promises.set(query, { promise, resolve });
+        return { promise, isNew: true };
+    };
+    const resolvePromise = (query, rows) => {
+        const item = promises.get(query);
+        if (!item)
+            return;
+        // It's similar to what React will do.
+        void Object.assign(item.promise, { [loadingPromisesPromiseProp]: rows });
+        item.resolve(rows);
+    };
+    const releasePromises = (ignoreQueries) => {
+        [...promises.keys()].forEach((query) => {
+            if (!ignoreQueries.includes(query))
+                promises.delete(query);
+        });
+    };
+    return { getPromise, resolvePromise, releasePromises };
+}));
+const QueryStoreLive = Layer.effect(QueryStore, Effect.gen(function* (_) {
+    const subscribedQueries = yield* _(SubscribedQueries);
+    const loadingPromises = yield* _(LoadingPromises);
+    const dbWorker = yield* _(DbWorker);
+    const flushSync = yield* _(FlushSync);
+    const onCompletes = yield* _(OnCompletes);
+    const rowsCacheStore = makeStore(new Map());
+    const queue = new Set();
+    const subscribe = (query) => (listen) => {
+        if (query == null)
+            return Function.constVoid;
+        subscribedQueries.set(query, Number.increment(subscribedQueries.get(query) ?? 0));
+        const unsubscribe = rowsCacheStore.subscribe(listen);
+        return () => {
+            // `as number`, because React mount/unmount are symmetric.
+            const count = subscribedQueries.get(query);
+            if (count > 1)
+                subscribedQueries.set(query, Number.decrement(count));
+            else
+                subscribedQueries.delete(query);
+            unsubscribe();
+        };
+    };
+    const getState = (query) => (query && rowsCacheStore.getState().get(query)) || null;
+    const loadQuery = (query) => {
+        const { promise, isNew } = loadingPromises.getPromise(query);
+        if (isNew)
+            queue.add(query);
+        if (queue.size === 1) {
+            queueMicrotask(() => {
+                const queries = [...queue];
+                queue.clear();
+                if (ReadonlyArray.isNonEmptyReadonlyArray(queries))
+                    dbWorker.postMessage({ _tag: "query", queries });
+            });
+        }
+        return promise;
+    };
+    const onQuery = ({ queriesPatches, onCompleteIds, }) => {
+        const state = rowsCacheStore.getState();
+        const nextState = pipe(queriesPatches, ReadonlyArray.map(({ query, patches }) => [query, applyPatches(patches)(state.get(query) || [])]), (a) => new Map([...state, ...a]));
+        // Resolve all Promises belonging to queries.
+        queriesPatches.forEach(({ query }) => {
+            const rows = nextState.get(query) || [];
+            loadingPromises.resolvePromise(query, rows);
+        });
+        // No mutation is using onComplete, so we don't need flushSync.
+        if (onCompleteIds.length === 0) {
+            rowsCacheStore.setState(nextState);
+            return;
+        }
+        flushSync(() => rowsCacheStore.setState(nextState));
+        ReadonlyArray.filterMap(onCompleteIds, (id) => {
+            const onComplete = onCompletes.get(id);
+            onCompletes.delete(id);
+            return Option.fromNullable(onComplete);
+        }).forEach((onComplete) => onComplete());
+    };
+    return { subscribe, getState, loadQuery, onQuery };
+}));
+const MutateLive = () => Layer.effect(Mutate(), Effect.gen(function* (_) {
+    const nanoid = yield* _(NanoId);
+    const onCompletes = yield* _(OnCompletes);
+    const time = yield* _(Time);
+    const subscribedQueries = yield* _(SubscribedQueries);
+    const loadingPromises = yield* _(LoadingPromises);
+    const dbWorker = yield* _(DbWorker);
+    const queue = [];
+    return Mutate().of((table, { id, ...values }, onComplete) => {
+        const isInsert = id == null;
+        if (isInsert)
+            id = Effect.runSync(nanoid.nanoid);
+        let onCompleteId = null;
+        if (onComplete) {
+            onCompleteId = Effect.runSync(nanoid.nanoid);
+            onCompletes.set(onCompleteId, onComplete);
+        }
+        queue.push({
+            table: table.toString(),
+            id: id,
+            values,
+            isInsert,
+            now: cast(new Date(Effect.runSync(time.now))),
+            onCompleteId,
+        });
+        if (queue.length === 1)
+            queueMicrotask(() => {
+                const items = [...queue];
+                queue.length = 0;
+                const queries = Array.from(subscribedQueries.keys());
+                // Just wipe-out LoadingPromises unused queries.
+                loadingPromises.releasePromises(queries);
+                if (ReadonlyArray.isNonEmptyReadonlyArray(items))
+                    dbWorker.postMessage({ _tag: "mutate", items, queries });
+            });
+        return { id: id };
+    });
+}));
+const OwnerActionsLive = Layer.effect(OwnerActions, Effect.gen(function* (_) {
+    const dbWorker = yield* _(DbWorker);
+    const bip39 = yield* _(Bip39);
+    const reset = () => {
+        dbWorker.postMessage({ _tag: "reset" });
+    };
+    const restore = (mnemonic) => bip39.parse(mnemonic).pipe(Effect.flatMap((mnemonic) => Effect.sync(() => {
+        dbWorker.postMessage({ _tag: "reset", mnemonic });
+        return Either.right(undefined);
+    })), Effect.catchTag("InvalidMnemonicError", () => Effect.succeed(Either.left({ _tag: "RestoreOwnerError" }))), Effect.runPromise);
+    return { reset, restore };
+}));
+export const EvoluLive = (tables) => Layer.effect(Evolu(), Effect.gen(function* (_) {
+    const dbWorker = yield* _(DbWorker);
+    const appState = yield* _(AppState);
+    const config = yield* _(Config);
+    const subscribedQueries = new Map();
+    const onCompletes = new Map();
+    const loadingPromises = Effect.provide(LoadingPromises, LoadingPromisesLive).pipe(Effect.runSync);
+    const errorStore = makeStore(null);
+    const ownerStore = makeStore(null);
+    const syncStateStore = makeStore({
+        _tag: "SyncStateInitial",
+    });
+    const Layers = Layer.mergeAll(Layer.succeed(DbWorker, dbWorker), Layer.succeed(SubscribedQueries, subscribedQueries), Layer.succeed(OnCompletes, onCompletes), Layer.succeed(LoadingPromises, loadingPromises), Layer.succeed(FlushSync, yield* _(FlushSync)), Layer.succeed(NanoId, yield* _(NanoId)), Layer.succeed(Time, yield* _(Time)), Layer.succeed(Bip39, yield* _(Bip39)));
+    const queryStore = Effect.provide(QueryStore, Layer.use(QueryStoreLive, Layers)).pipe(Effect.runSync);
+    const mutate = Effect.provide(Mutate(), Layer.use(MutateLive(), Layers)).pipe(Effect.runSync);
+    const ownerActions = Effect.provide(OwnerActions, Layer.use(OwnerActionsLive, Layers)).pipe(Effect.runSync);
+    const ensureSchema = (tables) => {
+        dbWorker.postMessage({ _tag: "ensureSchema", tables });
+    };
+    const getSubscribedQueries = () => Array.from(subscribedQueries.keys());
+    dbWorker.onMessage = (output) => {
+        // console.log(output);
+        switch (output._tag) {
+            case "onError":
+                if (process.env.NODE_ENV === "development")
+                    // JSON.stringify, because Expo console needs strings.
+                    // eslint-disable-next-line no-console
+                    console.warn(JSON.stringify(output.error, null, 2));
+                errorStore.setState(output.error);
+                break;
+            case "onOwner":
+                ownerStore.setState(output.owner);
+                break;
+            case "onQuery":
+                queryStore.onQuery(output);
+                break;
+            case "onReceive": {
+                const queries = getSubscribedQueries();
+                if (ReadonlyArray.isNonEmptyReadonlyArray(queries))
+                    dbWorker.postMessage({ _tag: "query", queries });
+                break;
+            }
+            case "onResetOrRestore":
+                Effect.runSync(appState.reset);
+                break;
+            case "onSyncState":
+                syncStateStore.setState(output.state);
+                break;
+            default:
+                absurd(output);
+        }
+    };
+    dbWorker.postMessage({ _tag: "init", config, tables });
+    appState.onFocus(() => {
+        // `queries` to refresh subscribed queries when a tab is changed.
+        dbWorker.postMessage({ _tag: "sync", queries: getSubscribedQueries() });
+    });
+    const sync = () => dbWorker.postMessage({ _tag: "sync", queries: [] });
+    appState.onReconnect(sync);
+    sync();
+    return Evolu().of({
+        subscribeError: errorStore.subscribe,
+        getError: errorStore.getState,
+        subscribeOwner: ownerStore.subscribe,
+        getOwner: ownerStore.getState,
+        createQuery: makeCreateQuery(),
+        subscribeQuery: queryStore.subscribe,
+        getQuery: queryStore.getState,
+        loadQuery: queryStore.loadQuery,
+        subscribeSyncState: syncStateStore.subscribe,
+        getSyncState: syncStateStore.getState,
+        create: mutate,
+        update: mutate,
+        ownerActions,
+        ensureSchema,
+    });
+}));
+export const makeEvoluForPlatform = (PlatformLayer, tables, config) => Effect.provide(Evolu(), Layer.use(EvoluLive(tables), Layer.mergeAll(PlatformLayer, ConfigLive(config), TimeLive))).pipe(Effect.runSync);

package/dist/src/MerkleTree.d.ts

@@ -0,0 +1,15 @@
+import { Brand, Option } from "effect";
+import { Millis, Timestamp, TimestampHash } from "./Timestamp.js";
+export interface MerkleTree {
+    readonly hash?: TimestampHash;
+    readonly "0"?: MerkleTree;
+    readonly "1"?: MerkleTree;
+    readonly "2"?: MerkleTree;
+}
+export type MerkleTreeString = string & Brand.Brand<"MerkleTreeString">;
+export declare const initialMerkleTree: MerkleTree;
+export declare const insertIntoMerkleTree: (timestamp: Timestamp) => (tree: MerkleTree) => MerkleTree;
+export declare const diffMerkleTrees: (tree1: MerkleTree, tree2: MerkleTree) => Option.Option<Millis>;
+export declare const merkleTreeToString: (m: MerkleTree) => MerkleTreeString;
+export declare const unsafeMerkleTreeFromString: (m: MerkleTreeString) => MerkleTree;
+//# sourceMappingURL=MerkleTree.d.ts.map

package/dist/src/MerkleTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MerkleTree.d.ts","sourceRoot":"","sources":["../../src/MerkleTree.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,EACL,MAAM,EACN,SAAS,EACT,aAAa,EAEd,MAAM,gBAAgB,CAAC;AAKxB,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,GAAG,CAAC,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,GAAG,CAAC,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,GAAG,CAAC,EAAE,UAAU,CAAC;CAC3B;AAED,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC;AAExE,eAAO,MAAM,iBAAiB,YAAoC,CAAC;AAwBnE,eAAO,MAAM,oBAAoB,cACnB,SAAS,YACd,UAAU,KAAG,UAKnB,CAAC;AAKJ,eAAO,MAAM,eAAe,UACnB,UAAU,SACV,UAAU,KAChB,aAAa,CAAC,MAAM,CAiBtB,CAAC;AAEF,eAAO,MAAM,kBAAkB,MAAO,UAAU,KAAG,gBACZ,CAAC;AAExC,eAAO,MAAM,0BAA0B,MAAO,gBAAgB,KAAG,UACpC,CAAC"}

package/dist/src/MerkleTree.js

@@ -0,0 +1,49 @@
+import { Option } from "effect";
+import { timestampToHash, } from "./Timestamp.js";
+export const initialMerkleTree = Object.create(null);
+const timestampToKey = (timestamp) => Math.floor(timestamp.millis / 1000 / 60).toString(3);
+const insertKey = (tree, key, hash) => {
+    if (key.length === 0)
+        return tree;
+    const childKey = key[0];
+    const child = tree[childKey] || {};
+    return {
+        ...tree,
+        [childKey]: {
+            ...child,
+            ...insertKey(child, key.slice(1), hash),
+            // @ts-expect-error undefined is OK
+            hash: child.hash ^ hash,
+        },
+    };
+};
+export const insertIntoMerkleTree = (timestamp) => (tree) => {
+    const key = timestampToKey(timestamp);
+    const hash = timestampToHash(timestamp);
+    // @ts-expect-error undefined is OK
+    return insertKey({ ...tree, hash: tree.hash ^ hash }, key, hash);
+};
+const keyToTimestamp = (key) => (parseInt(key.length > 0 ? key : "0", 3) * 1000 * 60);
+export const diffMerkleTrees = (tree1, tree2) => {
+    if (tree1.hash === tree2.hash)
+        return Option.none();
+    for1: for (let node1 = tree1, node2 = tree2, key = "";;) {
+        for (const k of ["0", "1", "2"]) {
+            const next1 = node1[k];
+            const next2 = node2[k];
+            if (!next1 && !next2)
+                continue;
+            if (!next1 || !next2)
+                break;
+            if (next1.hash !== next2.hash) {
+                key += k;
+                node1 = next1;
+                node2 = next2;
+                continue for1;
+            }
+        }
+        return Option.some(keyToTimestamp(key));
+    }
+};
+export const merkleTreeToString = (m) => JSON.stringify(m);
+export const unsafeMerkleTreeFromString = (m) => JSON.parse(m);

package/dist/src/Model.d.ts

@@ -0,0 +1,143 @@
+import * as Schema from "@effect/schema/Schema";
+import { Brand } from "effect";
+import { Row } from "./Sqlite.js";
+/**
+ * Branded Id Schema for any table Id.
+ * To create Id Schema for a specific table, use {@link id}.
+ */
+export declare const Id: Schema.BrandSchema<string, string & Brand.Brand<"Id">>;
+export type Id = Schema.Schema.To<typeof Id>;
+/**
+ * A factory function to create {@link Id} Schema for a specific table.
+ *
+ * ### Example
+ *
+ * ```
+ * import * as Schema from "@effect/schema/Schema";
+ * import * as Evolu from "@evolu/react";
+ *
+ * const TodoId = Evolu.id("Todo");
+ * type TodoId = Schema.Schema.To<typeof TodoId>;
+ *
+ * if (!Schema.is(TodoId)(value)) return;
+ * ```
+ */
+export declare const id: <T extends string>(table: T) => Schema.BrandSchema<string, string & Brand.Brand<"Id"> & Brand.Brand<T>>;
+/**
+ * SQLite doesn't support the Date type, so Evolu uses SqliteDate instead.
+ * Use the {@link cast} helper to cast SqliteDate from Date and back.
+ * https://www.sqlite.org/quirks.html#no_separate_datetime_datatype
+ */
+export declare const SqliteDate: Schema.BrandSchema<string, string & Brand.Brand<"SqliteDate">>;
+export type SqliteDate = Schema.Schema.To<typeof SqliteDate>;
+/**
+ * SQLite doesn't support the boolean type, so Evolu uses SqliteBoolean instead.
+ * Use the {@link cast} helper to cast SqliteBoolean from boolean and back.
+ * https://www.sqlite.org/quirks.html#no_separate_boolean_datatype
+ */
+export declare const SqliteBoolean: Schema.BrandSchema<number, number & Brand.Brand<"SqliteBoolean">>;
+export type SqliteBoolean = Schema.Schema.To<typeof SqliteBoolean>;
+/**
+ * SQLite doesn't support Date nor Boolean types, so Evolu emulates them
+ * with {@link SqliteBoolean} and {@link SqliteDate}.
+ *
+ * For {@link SqliteBoolean}, you can use JavaScript boolean.
+ * For {@link SqliteDate}, you can use JavaScript Date.
+ */
+export type CastableForMutate<T> = {
+    readonly [K in keyof T]: T[K] extends SqliteBoolean ? boolean | SqliteBoolean : T[K] extends null | SqliteBoolean ? null | boolean | SqliteBoolean : T[K] extends SqliteDate ? Date | SqliteDate : T[K] extends null | SqliteDate ? null | Date | SqliteDate : T[K];
+};
+/**
+ * A helper for casting types not supported by SQLite.
+ * SQLite doesn't support Date nor Boolean types, so Evolu emulates them
+ * with {@link SqliteBoolean} and {@link SqliteDate}.
+ *
+ * ### Example
+ *
+ * ```
+ * // isDeleted is SqliteBoolean
+ * .where("isDeleted", "is not", cast(true))
+ * ```
+ */
+export declare function cast(value: boolean): SqliteBoolean;
+export declare function cast(value: SqliteBoolean): boolean;
+export declare function cast(value: Date): SqliteDate;
+export declare function cast(value: SqliteDate): Date;
+/**
+ * String schema represents a string that is not stringified JSON. Using
+ * String schema for strings stored in SQLite is crucial to ensure a stored
+ * string is not automatically parsed to a JSON object or array when
+ * retrieved. Use String schema for all string-based schemas.
+ */
+export declare const String: Schema.BrandSchema<string, string & Brand.Brand<"String">>;
+export type String = Schema.Schema.To<typeof String>;
+/**
+ * A string with a maximum length of 1000 characters.
+ *
+ * ### Example
+ *
+ * ```
+ * import * as Schema from "@effect/schema/Schema";
+ * import * as Evolu from "@evolu/react";
+ *
+ * if (!Schema.is(Evolu.String1000)(value)) return;
+ * function foo(value: Evolu.String1000) {}
+ * ```
+ */
+export declare const String1000: Schema.BrandSchema<string, string & Brand.Brand<"String"> & Brand.Brand<"String1000">>;
+export type String1000 = Schema.Schema.To<typeof String1000>;
+/**
+ * A nonempty string with a maximum length of 1000 characters.
+ *
+ * ### Example
+ *
+ * ```
+ * import * as Schema from "@effect/schema/Schema";
+ * import * as Evolu from "@evolu/react";
+ *
+ * if (!Schema.is(Evolu.NonEmptyString1000)(value)) return;
+ * function foo(value: Evolu.NonEmptyString1000) {}
+ * ```
+ */
+export declare const NonEmptyString1000: Schema.BrandSchema<string, string & Brand.Brand<"String"> & Brand.Brand<"NonEmptyString1000">>;
+export type NonEmptyString1000 = Schema.Schema.To<typeof NonEmptyString1000>;
+/**
+ * A positive integer.
+ *
+ * ### Example
+ *
+ * ```
+ * import * as Schema from "@effect/schema/Schema";
+ * import * as Evolu from "@evolu/react";
+ *
+ * if (!Schema.is(Evolu.PositiveInt)(value)) return;
+ * function foo(value: Evolu.PositiveInt) {}
+ * ```
+ */
+export declare const PositiveInt: Schema.BrandSchema<number, number & Brand.Brand<"PositiveInt">>;
+export type PositiveInt = Schema.Schema.To<typeof PositiveInt>;
+/**
+ * Filter and map array items in one step with the correct return type and
+ * without unreliable TypeScript type guards.
+ *
+ * ### Examples
+ *
+ * ```
+ * useQuery(
+ *   (db) => db.selectFrom("todo").selectAll(),
+ *   // Filter and map nothing.
+ *   (row) => row,
+ * );
+ *
+ * useQuery(
+ *   (db) => db.selectFrom("todo").selectAll(),
+ *   // Filter items with title != null.
+ *   // Note the title type isn't nullable anymore in rows.
+ *   ({ title, ...rest }) => title != null && { title, ...rest },
+ * );
+ * ```
+ */
+export type FilterMap<QueryRow extends Row, FilterMapRow extends Row> = (row: QueryRow) => OrNullOrFalse<FilterMapRow>;
+export type OrNullOrFalse<T> = T | null | false;
+export type ExcludeNullAndFalse<T> = Exclude<T, null | false>;
+//# sourceMappingURL=Model.d.ts.map

package/dist/src/Model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Model.d.ts","sourceRoot":"","sources":["../../src/Model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAC/B,OAAO,EAAE,GAAG,EAAa,MAAM,aAAa,CAAC;AAE7C;;;GAGG;AACH,eAAO,MAAM,EAAE,wDAGd,CAAC;AACF,MAAM,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC;AAE7C;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,EAAE,yGAGe,CAAC;AAE/B;;;;GAIG;AACH,eAAO,MAAM,UAAU,gEAGtB,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,UAAU,CAAC,CAAC;AAE7D;;;;GAIG;AACH,eAAO,MAAM,aAAa,mEAIzB,CAAC;AACF,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,aAAa,CAAC,CAAC;AAEnE;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI;IACjC,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,aAAa,GAC/C,OAAO,GAAG,aAAa,GACvB,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,aAAa,GACjC,IAAI,GAAG,OAAO,GAAG,aAAa,GAC9B,CAAC,CAAC,CAAC,CAAC,SAAS,UAAU,GACvB,IAAI,GAAG,UAAU,GACjB,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,UAAU,GAC9B,IAAI,GAAG,IAAI,GAAG,UAAU,GACxB,CAAC,CAAC,CAAC,CAAC;CACT,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,CAAC;AACpD,wBAAgB,IAAI,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC;AACpD,wBAAgB,IAAI,CAAC,KAAK,EAAE,IAAI,GAAG,UAAU,CAAC;AAC9C,wBAAgB,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;AAW9C;;;;;GAKG;AACH,eAAO,MAAM,MAAM,4DAclB,CAAC;AACF,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,MAAM,CAAC,CAAC;AAErD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,UAAU,wFAGtB,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,UAAU,CAAC,CAAC;AAE7D;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB,gGAI9B,CAAC;AACF,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE7E;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,WAAW,iEAIvB,CAAC;AACF,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,WAAW,CAAC,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,SAAS,CAAC,QAAQ,SAAS,GAAG,EAAE,YAAY,SAAS,GAAG,IAAI,CACtE,GAAG,EAAE,QAAQ,KACV,aAAa,CAAC,YAAY,CAAC,CAAC;AAEjC,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC;AAEhD,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,EAAE,IAAI,GAAG,KAAK,CAAC,CAAC"}

package/dist/src/Model.js

@@ -0,0 +1,103 @@
+import * as Schema from "@effect/schema/Schema";
+import { maybeJson } from "./Sqlite.js";
+/**
+ * Branded Id Schema for any table Id.
+ * To create Id Schema for a specific table, use {@link id}.
+ */
+export const Id = Schema.string.pipe(Schema.pattern(/^[\w-]{21}$/), Schema.brand("Id"));
+/**
+ * A factory function to create {@link Id} Schema for a specific table.
+ *
+ * ### Example
+ *
+ * ```
+ * import * as Schema from "@effect/schema/Schema";
+ * import * as Evolu from "@evolu/react";
+ *
+ * const TodoId = Evolu.id("Todo");
+ * type TodoId = Schema.Schema.To<typeof TodoId>;
+ *
+ * if (!Schema.is(TodoId)(value)) return;
+ * ```
+ */
+export const id = (table) => Id.pipe(Schema.brand(table));
+/**
+ * SQLite doesn't support the Date type, so Evolu uses SqliteDate instead.
+ * Use the {@link cast} helper to cast SqliteDate from Date and back.
+ * https://www.sqlite.org/quirks.html#no_separate_datetime_datatype
+ */
+export const SqliteDate = Schema.string.pipe(Schema.filter((s) => !isNaN(Date.parse(s))), Schema.brand("SqliteDate"));
+/**
+ * SQLite doesn't support the boolean type, so Evolu uses SqliteBoolean instead.
+ * Use the {@link cast} helper to cast SqliteBoolean from boolean and back.
+ * https://www.sqlite.org/quirks.html#no_separate_boolean_datatype
+ */
+export const SqliteBoolean = Schema.number.pipe(Schema.int(), Schema.filter((s) => s === 0 || s === 1), Schema.brand("SqliteBoolean"));
+export function cast(value) {
+    if (typeof value === "boolean")
+        return (value === true ? 1 : 0);
+    if (typeof value === "number")
+        return value === 1;
+    if (value instanceof Date)
+        return value.toISOString();
+    return new Date(value);
+}
+/**
+ * String schema represents a string that is not stringified JSON. Using
+ * String schema for strings stored in SQLite is crucial to ensure a stored
+ * string is not automatically parsed to a JSON object or array when
+ * retrieved. Use String schema for all string-based schemas.
+ */
+export const String = Schema.string.pipe(Schema.filter((s) => {
+    if (!maybeJson(s))
+        return true;
+    try {
+        JSON.parse(s);
+    }
+    catch (e) {
+        return true;
+    }
+    return false;
+}, { message: () => "a string that is not stringified JSON" }), Schema.brand("String"));
+/**
+ * A string with a maximum length of 1000 characters.
+ *
+ * ### Example
+ *
+ * ```
+ * import * as Schema from "@effect/schema/Schema";
+ * import * as Evolu from "@evolu/react";
+ *
+ * if (!Schema.is(Evolu.String1000)(value)) return;
+ * function foo(value: Evolu.String1000) {}
+ * ```
+ */
+export const String1000 = String.pipe(Schema.maxLength(1000), Schema.brand("String1000"));
+/**
+ * A nonempty string with a maximum length of 1000 characters.
+ *
+ * ### Example
+ *
+ * ```
+ * import * as Schema from "@effect/schema/Schema";
+ * import * as Evolu from "@evolu/react";
+ *
+ * if (!Schema.is(Evolu.NonEmptyString1000)(value)) return;
+ * function foo(value: Evolu.NonEmptyString1000) {}
+ * ```
+ */
+export const NonEmptyString1000 = String.pipe(Schema.minLength(1), Schema.maxLength(1000), Schema.brand("NonEmptyString1000"));
+/**
+ * A positive integer.
+ *
+ * ### Example
+ *
+ * ```
+ * import * as Schema from "@effect/schema/Schema";
+ * import * as Evolu from "@evolu/react";
+ *
+ * if (!Schema.is(Evolu.PositiveInt)(value)) return;
+ * function foo(value: Evolu.PositiveInt) {}
+ * ```
+ */
+export const PositiveInt = Schema.number.pipe(Schema.int(), Schema.positive(), Schema.brand("PositiveInt"));

package/dist/src/Murmurhash.d.ts

@@ -0,0 +1,2 @@
+export declare const murmurhash: (key: string, seed?: number) => number;
+//# sourceMappingURL=Murmurhash.d.ts.map

package/dist/src/Murmurhash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Murmurhash.d.ts","sourceRoot":"","sources":["../../src/Murmurhash.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,UAAU,QAAS,MAAM,oBAAa,MAoElD,CAAC"}

package/dist/src/Murmurhash.js

@@ -0,0 +1,60 @@
+// https://github.com/garycourt/murmurhash-js/blob/master/murmurhash3_gc.js
+export const murmurhash = (key, seed = 0) => {
+    let h1, h1b, k1, i;
+    const remainder = key.length & 3; // key.length % 4
+    const bytes = key.length - remainder;
+    h1 = seed;
+    const c1 = 0xcc9e2d51;
+    const c2 = 0x1b873593;
+    i = 0;
+    while (i < bytes) {
+        k1 =
+            (key.charCodeAt(i) & 0xff) |
+                ((key.charCodeAt(++i) & 0xff) << 8) |
+                ((key.charCodeAt(++i) & 0xff) << 16) |
+                ((key.charCodeAt(++i) & 0xff) << 24);
+        ++i;
+        k1 =
+            ((k1 & 0xffff) * c1 + ((((k1 >>> 16) * c1) & 0xffff) << 16)) & 0xffffffff;
+        k1 = (k1 << 15) | (k1 >>> 17);
+        k1 =
+            ((k1 & 0xffff) * c2 + ((((k1 >>> 16) * c2) & 0xffff) << 16)) & 0xffffffff;
+        h1 ^= k1;
+        h1 = (h1 << 13) | (h1 >>> 19);
+        h1b =
+            ((h1 & 0xffff) * 5 + ((((h1 >>> 16) * 5) & 0xffff) << 16)) & 0xffffffff;
+        h1 = (h1b & 0xffff) + 0x6b64 + ((((h1b >>> 16) + 0xe654) & 0xffff) << 16);
+    }
+    k1 = 0;
+    switch (remainder) {
+        case 3:
+            k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
+        // eslint-disable-next-line no-fallthrough
+        case 2:
+            k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
+        // eslint-disable-next-line no-fallthrough
+        case 1:
+            k1 ^= key.charCodeAt(i) & 0xff;
+            k1 =
+                ((k1 & 0xffff) * c1 + ((((k1 >>> 16) * c1) & 0xffff) << 16)) &
+                    0xffffffff;
+            k1 = (k1 << 15) | (k1 >>> 17);
+            k1 =
+                ((k1 & 0xffff) * c2 + ((((k1 >>> 16) * c2) & 0xffff) << 16)) &
+                    0xffffffff;
+            h1 ^= k1;
+    }
+    h1 ^= key.length;
+    h1 ^= h1 >>> 16;
+    h1 =
+        ((h1 & 0xffff) * 0x85ebca6b +
+            ((((h1 >>> 16) * 0x85ebca6b) & 0xffff) << 16)) &
+            0xffffffff;
+    h1 ^= h1 >>> 13;
+    h1 =
+        ((h1 & 0xffff) * 0xc2b2ae35 +
+            ((((h1 >>> 16) * 0xc2b2ae35) & 0xffff) << 16)) &
+            0xffffffff;
+    h1 ^= h1 >>> 16;
+    return h1 >>> 0;
+};

package/dist/src/Platform.d.ts

@@ -0,0 +1,29 @@
+import { Context, Effect, Layer } from "effect";
+export interface Platform {
+    readonly name: "server" | "web-with-opfs" | "web-without-opfs" | "react-native";
+}
+export declare const Platform: Context.Tag<Platform, Platform>;
+export type FlushSync = (callback: () => void) => void;
+export declare const FlushSync: Context.Tag<FlushSync, FlushSync>;
+export interface SyncLock {
+    readonly acquire: Effect.Effect<never, never, boolean>;
+    readonly release: Effect.Effect<never, never, void>;
+}
+export declare const SyncLock: Context.Tag<SyncLock, SyncLock>;
+export type Fetch = (url: string, body: Uint8Array) => Effect.Effect<never, FetchError, Response>;
+export declare const Fetch: Context.Tag<Fetch, Fetch>;
+/**
+ * This error occurs when there is a problem with the network connection,
+ * or the server cannot be reached.
+ */
+export interface FetchError {
+    readonly _tag: "FetchError";
+}
+export declare const FetchLive: Layer.Layer<never, never, Fetch>;
+export interface AppState {
+    readonly onFocus: (callback: () => void) => void;
+    readonly onReconnect: (callback: () => void) => void;
+    readonly reset: Effect.Effect<never, never, void>;
+}
+export declare const AppState: Context.Tag<AppState, AppState>;
+//# sourceMappingURL=Platform.d.ts.map

package/dist/src/Platform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Platform.d.ts","sourceRoot":"","sources":["../../src/Platform.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAEhD,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EACT,QAAQ,GACR,eAAe,GACf,kBAAkB,GAClB,cAAc,CAAC;CACpB;AAED,eAAO,MAAM,QAAQ,iCAA0C,CAAC;AAEhE,MAAM,MAAM,SAAS,GAAG,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;AAEvD,eAAO,MAAM,SAAS,mCAA4C,CAAC;AAEnE,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;IACvD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;CACrD;AAED,eAAO,MAAM,QAAQ,iCAA0C,CAAC;AAEhE,MAAM,MAAM,KAAK,GAAG,CAClB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,UAAU,KACb,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC;AAEhD,eAAO,MAAM,KAAK,2BAAoC,CAAC;AAEvD;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;CAC7B;AAED,eAAO,MAAM,SAAS,kCAgBrB,CAAC;AAEF,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;IACjD,QAAQ,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;IACrD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;CACnD;AAED,eAAO,MAAM,QAAQ,iCAA0C,CAAC"}