@evolu/common 5.4.8 → 6.0.0

package/dist/src/Db.js

@@ -1,443 +0,0 @@
-import * as S from "@effect/schema/Schema";
-import * as Arr from "effect/Array";
-import * as Console from "effect/Console";
-import * as Context from "effect/Context";
-import * as Deferred from "effect/Deferred";
-import * as Effect from "effect/Effect";
-import { constVoid, pipe } from "effect/Function";
-import * as Option from "effect/Option";
-import * as Predicate from "effect/Predicate";
-import * as Ref from "effect/Ref";
-import * as Schedule from "effect/Schedule";
-import * as String from "effect/String";
-import * as SynchronizedRef from "effect/SynchronizedRef";
-import { Time, diffMerkleTrees, initialMerkleTree, insertIntoMerkleTree, makeInitialTimestamp, makeSyncTimestamp, merkleTreeToString, receiveTimestamp, sendTimestamp, timestampToString, unsafeTimestampFromString, } from "./Crdt.js";
-import { NanoIdGenerator } from "./Crypto.js";
-import { makePatches } from "./Diff.js";
-import { ensureTransferableError, makeUnexpectedError, } from "./Error.js";
-import { cast } from "./Model.js";
-import { Owner, makeOwner } from "./Owner.js";
-import { SyncLock } from "./Platform.js";
-import * as Sql from "./Sql.js";
-import { Sqlite, SqliteFactory, drawSqliteQueryPlan, isJsonObjectOrArray, } from "./Sqlite.js";
-import { Sync, SyncFactory, } from "./Sync.js";
-export const Index = S.Struct({
-    name: S.String,
-    sql: S.String,
-});
-export class DbFactory extends Context.Tag("DbFactory")() {
-}
-export const createDb = Effect.gen(function* () {
-    const { createSqlite } = yield* SqliteFactory;
-    const { createSync } = yield* SyncFactory;
-    const initContext = Context.empty().pipe(Context.add(NanoIdGenerator, yield* NanoIdGenerator), Context.add(Time, yield* Time), Context.add(SyncLock, yield* SyncLock));
-    const afterInitContext = yield* Deferred.make();
-    const afterInit = (options) => (effect) => Effect.flatMap(Deferred.await(afterInitContext), (context) => Effect.flatMap(Sqlite, (sqlite) => sqlite.transaction(options.transaction)(effect)).pipe(Effect.provide(context)));
-    const queryRowsRef = yield* SynchronizedRef.make(new Map());
-    const db = {
-        init: (schema, initialData, onError, onSyncStateChange, onReceive, mnemonic) => Effect.gen(function* () {
-            yield* Effect.logDebug(["Db init", { schema }]);
-            const sqlite = yield* createSqlite;
-            const contextWithSqlite = Context.add(initContext, Sqlite, sqlite);
-            const owner = yield* getSchema.pipe(Effect.tap(ensureSchema(schema)), Effect.flatMap((currentSchema) => {
-                if (currentSchema.tables.map((t) => t.name).includes("evolu_owner"))
-                    return readOwner;
-                return createOwner(mnemonic).pipe(Effect.tap(applyMutations(initialData)));
-            }), sqlite.transaction("exclusive"), Effect.provide(contextWithSqlite));
-            const sync = yield* createSync.pipe(Effect.provide(initContext));
-            yield* sync.init(owner);
-            Deferred.unsafeDone(afterInitContext, Effect.succeed(contextWithSqlite.pipe(Context.add(Owner, owner), Context.add(Sync, sync), Context.add(Callbacks, { onError, onSyncStateChange, onReceive }))));
-            return owner;
-        }),
-        loadQueries: (queries) => Effect.logDebug(["Db loadQueries", { queries }]).pipe(Effect.zipRight(loadQueries(queries, queryRowsRef)), afterInit({ transaction: "shared" })),
-        mutate: (mutations, queriesToRefresh) => Effect.gen(function* () {
-            yield* Effect.logDebug(["Db mutate", { mutations, queriesToRefresh }]);
-            const time = yield* Time;
-            const sqlite = yield* Sqlite;
-            const [toSyncMutations, localOnlyMutations] = Arr.partition(mutations, 
-            /** Table name starting with '_' is local only (not synced). */
-            (mutation) => mutation.table.startsWith("_"));
-            for (const mutation of localOnlyMutations) {
-                const isDeleteMutation = mutationToNewMessages(mutation).some(({ column, value }) => column === "isDeleted" && value === 1);
-                if (isDeleteMutation) {
-                    yield* sqlite.exec({
-                        sql: `delete from "${mutation.table}" where "id" = ?;`,
-                        parameters: [mutation.id],
-                    });
-                }
-                else {
-                    const messages = mutationToNewMessages(mutation);
-                    for (const message of messages) {
-                        const now = yield* time.now;
-                        yield* upsertValueIntoTableRowColumn(message, messages, now);
-                    }
-                }
-            }
-            if (toSyncMutations.length > 0) {
-                yield* Effect.tap(applyMutations(toSyncMutations), forkSync);
-            }
-            return yield* loadQueries(queriesToRefresh, queryRowsRef);
-        }).pipe(afterInit({ transaction: "exclusive" })),
-        resetOwner: () => Effect.logTrace("Db resetOwner").pipe(Effect.tap(dropAllTables), afterInit({ transaction: "last" })),
-        restoreOwner: (schema, mnemonic) => Effect.logTrace("Db restoreOwner").pipe(Effect.tap(dropAllTables), Effect.tap(Effect.flatMap(getSchema, ensureSchema(schema))), Effect.tap(createOwner(mnemonic)), afterInit({ transaction: "last" })),
-        ensureSchema: (schema) => getSchema.pipe(Effect.flatMap(ensureSchema(schema)), afterInit({ transaction: "exclusive" })),
-        sync: (queriesToRefresh) => Effect.logDebug(["Db sync", { queriesToRefresh }]).pipe(Effect.zipRight(forkSync()), Effect.zipRight(loadQueries(queriesToRefresh, queryRowsRef)), afterInit({ transaction: "shared" })),
-        exportDatabase: () => Effect.logTrace("Db exportDatabase").pipe(Effect.zipRight(Sqlite), Effect.flatMap((sqlite) => sqlite.export()), afterInit({ transaction: "exclusive" })),
-        // TODO:
-        // dispose: () =>
-        //   Effect.logTrace("Db dispose").pipe(
-        //     Effect.tap(Scope.close(scope, Exit.succeed("Db disposed"))),
-        //     afterInit({ transaction: "last" }),
-        //   ),
-    };
-    return db;
-});
-export const Callbacks = Context.GenericTag("Callbacks");
-const loadQueries = (queries, queryRowsRef) => Effect.gen(function* () {
-    const sqlite = yield* Sqlite;
-    const previousState = yield* SynchronizedRef.getAndUpdateEffect(queryRowsRef, (previousState) => Effect.map(Effect.forEach(queries, (query) => {
-        const sqliteQuery = deserializeQuery(query);
-        return sqlite.exec(sqliteQuery).pipe(Effect.tap(maybeExplainQueryPlan(sqliteQuery)), Effect.map(({ rows }) => [query, rows]));
-    }), (queriesRows) => new Map([...previousState, ...queriesRows])));
-    const currentState = yield* SynchronizedRef.get(queryRowsRef);
-    return queries.map((query) => ({
-        query,
-        patches: makePatches(previousState.get(query), currentState.get(query) || []),
-    }));
-});
-const maybeExplainQueryPlan = (sqliteQuery) => {
-    if (!sqliteQuery.options?.logExplainQueryPlan)
-        return Effect.void;
-    return Sqlite.pipe(Effect.flatMap((sqlite) => sqlite.exec({
-        ...sqliteQuery,
-        sql: `EXPLAIN QUERY PLAN ${sqliteQuery.sql}`,
-    })), Effect.tap(Console.log("ExplainQueryPlan", sqliteQuery)), Effect.tap(({ rows }) => Console.log(drawSqliteQueryPlan(rows))), Effect.map(constVoid));
-};
-const getSchema = Effect.gen(function* (_) {
-    yield* Effect.logTrace("Db getSchema");
-    const sqlite = yield* Sqlite;
-    const tables = yield* Effect.map(sqlite.exec({
-        // https://til.simonwillison.net/sqlite/list-all-columns-in-a-database
-        sql: `
-select
-  sqlite_master.name as tableName,
-  table_info.name as columnName
-from
-  sqlite_master
-  join pragma_table_info(sqlite_master.name) as table_info
-    `.trim(),
-    }), ({ rows }) => {
-        const map = new Map();
-        rows.forEach((row) => {
-            const { tableName, columnName } = row;
-            if (!map.has(tableName))
-                map.set(tableName, []);
-            map.get(tableName)?.push(columnName);
-        });
-        return globalThis.Array.from(map, ([name, columns]) => ({
-            name,
-            columns,
-        }));
-    });
-    const indexes = yield* Effect.map(sqlite.exec({
-        sql: `
-select
-  name, sql
-from
-  sqlite_master
-where
-  type='index' and
-  name not like 'sqlite_%' and
-  name not like 'index_evolu_%'
-`.trim(),
-    }), (result) => Arr.map(result.rows, (row) => ({
-        name: row.name,
-        /**
-         * SQLite returns "CREATE INDEX" for "create index" for some reason.
-         * Other keywords remain unchanged. We have to normalize the casing
-         * for `indexEquivalence` manually.
-         */
-        sql: row.sql.replace("CREATE INDEX", "create index"),
-    })));
-    return { tables, indexes };
-});
-const ensureSchema = (newSchema) => (currentSchema) => Effect.gen(function* () {
-    yield* Effect.logTrace("Db ensureSchema");
-    const sql = [];
-    newSchema.tables.forEach((table) => {
-        const currentTable = currentSchema.tables.find((t) => t.name === table.name);
-        if (!currentTable) {
-            sql.push(`
-  create table ${table.name} (
-    "id" text primary key,
-    ${table.columns
-                .filter((c) => c !== "id")
-                // "A column with affinity BLOB does not prefer one storage class over another
-                // and no attempt is made to coerce data from one storage class into another."
-                // https://www.sqlite.org/datatype3.html
-                .map((name) => `"${name}" blob`)
-                .join(", ")}
-  );`.trim());
-        }
-        else {
-            Arr.differenceWith(String.Equivalence)(table.columns, currentTable.columns).forEach((newColumn) => {
-                sql.push(`alter table "${table.name}" add column "${newColumn}" blob;`);
-            });
-        }
-    });
-    // Remove old indexes.
-    Arr.differenceWith(indexEquivalence)(currentSchema.indexes, Arr.intersectionWith(indexEquivalence)(currentSchema.indexes, newSchema.indexes)).forEach((indexToDrop) => {
-        sql.push(`drop index "${indexToDrop.name}";`);
-    });
-    // Add new indexes.
-    Arr.differenceWith(indexEquivalence)(newSchema.indexes, currentSchema.indexes).forEach((newIndex) => {
-        sql.push(`${newIndex.sql};`);
-    });
-    if (sql.length > 0) {
-        const sqlite = yield* Sqlite;
-        yield* sqlite.exec({ sql: sql.join("\n") });
-    }
-});
-const indexEquivalence = (self, that) => self.name === that.name && self.sql === that.sql;
-const readOwner = Effect.logTrace("Db readOwner").pipe(Effect.zipRight(Sqlite), Effect.flatMap((sqlite) => sqlite.exec(Sql.selectOwner)), Effect.map(({ rows: [row] }) => ({
-    id: row.id,
-    mnemonic: row.mnemonic,
-    encryptionKey: row.encryptionKey,
-})));
-const createOwner = (mnemonic) => Effect.logTrace("Db createOwner").pipe(Effect.zipRight(Effect.all([makeOwner(mnemonic), Sqlite, makeInitialTimestamp])), Effect.tap(([owner, sqlite, initialTimestampString]) => Effect.all([
-    sqlite.exec(Sql.createMessageTable),
-    sqlite.exec(Sql.createMessageTableIndex),
-    sqlite.exec(Sql.createOwnerTable),
-    sqlite.exec({
-        ...Sql.insertOwner,
-        parameters: [
-            owner.id,
-            owner.mnemonic,
-            owner.encryptionKey,
-            timestampToString(initialTimestampString),
-            merkleTreeToString(initialMerkleTree),
-        ],
-    }),
-])), Effect.map(([owner]) => owner));
-const applyMutations = (mutations) => Effect.gen(function* (_) {
-    const { timestamp, merkleTree } = yield* readTimestampAndMerkleTree;
-    const [nextTimestamp, messages] = yield* Effect.mapAccum(mutations.flatMap(mutationToNewMessages), timestamp, (currentTimestamp, newMessage) => Effect.map(sendTimestamp(currentTimestamp), (nextTimestamp) => {
-        const message = {
-            ...newMessage,
-            timestamp: timestampToString(nextTimestamp),
-        };
-        return [nextTimestamp, message];
-    }));
-    const nextMerkleTree = yield* applyMessages(merkleTree, messages);
-    yield* writeTimestampAndMerkleTree(nextTimestamp, nextMerkleTree);
-    return messages;
-});
-const readTimestampAndMerkleTree = Sqlite.pipe(Effect.flatMap((sqlite) => sqlite.exec(Sql.selectOwnerTimestampAndMerkleTree)), Effect.map(({ rows: [{ timestamp, merkleTree }] }) => ({
-    timestamp: unsafeTimestampFromString(timestamp),
-    merkleTree: merkleTree,
-})));
-const mutationToNewMessages = (mutation) => pipe(Object.entries(mutation.values), Arr.filterMap(([column, value]) => 
-// The value can be undefined if exactOptionalPropertyTypes isn't true.
-// Don't insert nulls because null is the default value.
-value === undefined || (mutation.isInsert && value == null)
-    ? Option.none()
-    : Option.some([column, value])), Arr.map(([column, value]) => ({
-    table: mutation.table,
-    row: mutation.id,
-    column,
-    value: typeof value === "boolean"
-        ? cast(value)
-        : value instanceof Date
-            ? cast(value)
-            : value,
-})));
-const applyMessages = (merkleTree, messages) => Effect.gen(function* () {
-    const sqlite = yield* Sqlite;
-    for (const message of messages) {
-        const messageTimestamp = unsafeTimestampFromString(message.timestamp);
-        const lastTimestamp = yield* Effect.map(sqlite.exec({
-            ...Sql.selectLastTimestampForTableRowColumn,
-            parameters: [message.table, message.row, message.column, 1],
-        }), ({ rows }) => rows.length > 0 ? rows[0].timestamp : null);
-        if (lastTimestamp == null || lastTimestamp < message.timestamp) {
-            yield* upsertValueIntoTableRowColumn(message, messages, messageTimestamp.millis);
-        }
-        if (lastTimestamp == null || lastTimestamp !== message.timestamp) {
-            const { changes } = yield* sqlite.exec({
-                ...Sql.insertIntoMessagesIfNew,
-                parameters: [
-                    message.timestamp,
-                    message.table,
-                    message.row,
-                    message.column,
-                    message.value,
-                ],
-            });
-            if (changes === 1)
-                merkleTree = insertIntoMerkleTree(merkleTree, messageTimestamp);
-        }
-    }
-    return merkleTree;
-});
-export const upsertValueIntoTableRowColumn = (message, messages, millis) => Sqlite.pipe(Effect.map((sqlite) => {
-    const now = cast(new Date(millis));
-    return sqlite.exec({
-        sql: `
-    insert into
-      "${message.table}" ("id", "${message.column}", "createdAt", "updatedAt")
-    values
-      (?, ?, ?, ?)
-    on conflict do update set
-      "${message.column}" = ?,
-      "updatedAt" = ?
-        `.trim(),
-        parameters: [message.row, message.value, now, now, message.value, now],
-    });
-}), Effect.flatMap((insert) => Effect.catchSomeDefect(insert, (error) => S.is(SqliteNoSuchTableOrColumnError)(error)
-    ? Option.some(
-    // If one message fails, we ensure schema for all messages.
-    ensureSchemaByNewMessages(messages).pipe(Effect.zipRight(insert)))
-    : Option.none())));
-const SqliteNoSuchTableOrColumnError = S.Struct({
-    message: S.Union(S.String.pipe(S.includes("no such table")), S.String.pipe(S.includes("no such column")), S.String.pipe(S.includes("has no column"))),
-});
-const ensureSchemaByNewMessages = (messages) => Effect.gen(function* () {
-    const tablesMap = new Map();
-    messages.forEach((message) => {
-        const table = tablesMap.get(message.table);
-        if (table == null) {
-            tablesMap.set(message.table, {
-                name: message.table,
-                columns: [message.column, "createdAt", "updatedAt"],
-            });
-            return;
-        }
-        if (table.columns.includes(message.column))
-            return;
-        tablesMap.set(message.table, {
-            name: message.table,
-            columns: table.columns.concat(message.column),
-        });
-    });
-    const tables = Arr.fromIterable(tablesMap.values());
-    yield* Effect.flatMap(getSchema, ensureSchema({ tables, indexes: [] }));
-});
-const writeTimestampAndMerkleTree = (timestamp, merkleTree) => Effect.flatMap(Sqlite, (sqlite) => sqlite.exec({
-    ...Sql.updateOwnerTimestampAndMerkleTree,
-    parameters: [
-        merkleTreeToString(merkleTree),
-        timestampToString(timestamp),
-    ],
-}));
-const dropAllTables = Effect.gen(function* () {
-    yield* Effect.logTrace("Db dropAllTables");
-    const sqlite = yield* Sqlite;
-    const schema = yield* getSchema;
-    yield* Effect.forEach(schema.tables, (table) => 
-    // The dropped table is completely removed from the database schema and
-    // the disk file. The table can not be recovered.
-    // All indices and triggers associated with the table are also deleted.
-    // https://sqlite.org/lang_droptable.html
-    sqlite.exec({ sql: `drop table "${table.name}"` }));
-});
-const forkSync = (messages = []) => SyncLock.pipe(Effect.flatMap((syncLock) => syncLock.tryAcquire), Effect.matchEffect({
-    onFailure: () => Effect.void,
-    onSuccess: () => syncLoop(messages),
-}), Effect.scoped, Effect.forkDaemon);
-const syncLoop = (messages = []) => Effect.gen(function* (_) {
-    const sqlite = yield* Sqlite;
-    const sync = yield* Sync;
-    const callbacks = yield* Callbacks;
-    const time = yield* Time;
-    const syncDataRef = yield* readTimestampAndMerkleTree.pipe(sqlite.transaction("shared"), Effect.map((a) => ({ ...a, messages })), Effect.flatMap(Ref.make));
-    callbacks.onSyncStateChange({ _tag: "SyncStateIsSyncing" });
-    yield* Ref.get(syncDataRef).pipe(Effect.flatMap(sync.sync), Effect.flatMap(handleSyncResult), Effect.repeat({
-        // TODO: Schedule.jittered(Schedule.exponential("10 millis"))
-        schedule: Schedule.recurs(50),
-        until: Option.match({
-            onNone: () => Effect.gen(function* () {
-                callbacks.onSyncStateChange({
-                    _tag: "SyncStateIsSynced",
-                    time: yield* time.now,
-                });
-                return true;
-            }),
-            onSome: (syncData) => Effect.gen(function* () {
-                yield* Ref.set(syncDataRef, syncData);
-                return false;
-            }),
-        }),
-    }), Effect.catchAllDefect((error) => 
-    // Db can run in a Web Worker, so we must ensure transferable error.
-    Effect.fail(makeUnexpectedError(ensureTransferableError(error)))), Effect.catchTag("SyncStateIsNotSynced", (state) => Effect.succeed(callbacks.onSyncStateChange(state))), Effect.catchAll((error) => Effect.succeed(callbacks.onError(error))));
-});
-const handleSyncResult = (result) => Effect.flatMap(Sqlite, (sqlite) => Effect.gen(function* (_) {
-    const { onReceive } = yield* Callbacks;
-    const current = yield* readTimestampAndMerkleTree;
-    const nextTimestamp = yield* Effect.reduce(result.messages, current.timestamp, (local, message) => receiveTimestamp({
-        local,
-        remote: unsafeTimestampFromString(message.timestamp),
-    }));
-    const nextMerkleTree = yield* applyMessages(current.merkleTree, result.messages);
-    if (result.messages.length > 0) {
-        yield* writeTimestampAndMerkleTree(nextTimestamp, nextMerkleTree);
-        onReceive();
-    }
-    return yield* diffMerkleTrees(result.merkleTree, nextMerkleTree).pipe(Effect.flatMap((diff) => sqlite.exec({
-        ...Sql.selectMessagesToSync,
-        parameters: [timestampToString(makeSyncTimestamp(diff))],
-    })), Effect.map(({ rows }) => ({
-        messages: rows,
-        merkleTree: nextMerkleTree,
-        timestamp: nextTimestamp,
-    })), Effect.option);
-}).pipe(sqlite.transaction("exclusive")));
-// We use queries as keys, hence JSON.stringify.
-export const serializeQuery = ({ sql, parameters = [], options, }) => {
-    const query = {
-        sql,
-        parameters: parameters.map((p) => Predicate.isUint8Array(p)
-            ? Arr.fromIterable(p)
-            : isJsonObjectOrArray(p)
-                ? { json: p }
-                : p),
-        ...(options && { options }),
-    };
-    return JSON.stringify(query);
-};
-export const deserializeQuery = (query) => {
-    const serializedSqliteQuery = JSON.parse(query);
-    return {
-        ...serializedSqliteQuery,
-        parameters: serializedSqliteQuery.parameters.map((p) => Arr.isArray(p)
-            ? new Uint8Array(p)
-            : typeof p === "object" && p != null
-                ? p.json
-                : p),
-    };
-};
-// To preserve identity.
-const _emptyRows = [];
-export const emptyRows = () => _emptyRows;
-// To preserve identity.
-const queryResultCache = new WeakMap();
-export const queryResultFromRows = (rows) => {
-    let queryResult = queryResultCache.get(rows);
-    if (queryResult == null) {
-        queryResult = { rows, row: rows[0] };
-        queryResultCache.set(rows, queryResult);
-    }
-    return queryResult;
-};
-export const notSupportedPlatformWorker = {
-    init: () => Effect.fail({
-        _tag: "NotSupportedPlatformError",
-    }),
-    loadQueries: () => Effect.succeed([]),
-    mutate: () => Effect.succeed([]),
-    resetOwner: () => Effect.void,
-    restoreOwner: () => Effect.void,
-    ensureSchema: () => Effect.void,
-    sync: () => Effect.succeed([]),
-    exportDatabase: () => Effect.succeed(new Uint8Array()),
-};

package/dist/src/Diff.d.ts

@@ -1,27 +0,0 @@
-import type { Query, Row } from "./Db.js";
-import { Value } from "./Sqlite.js";
-export interface QueryPatches {
-    readonly query: Query;
-    readonly patches: ReadonlyArray<Patch>;
-}
-export type Patch = ReplaceAllPatch | ReplaceAtPatch;
-export interface ReplaceAllPatch {
-    readonly op: "replaceAll";
-    readonly value: ReadonlyArray<Row>;
-}
-export interface ReplaceAtPatch {
-    readonly op: "replaceAt";
-    readonly index: number;
-    readonly value: Row;
-}
-export declare const applyPatches: (patches: ReadonlyArray<Patch>, current: ReadonlyArray<Row>) => ReadonlyArray<Row>;
-/**
- * We detect only changes in the whole result and in-place edits. In the future,
- * we will add more heuristics. We will probably not implement the Myers diff
- * algorithm because it's faster to rerender all than to compute many detailed
- * patches. We will only implement logic a developer would implement manually,
- * if necessary.
- */
-export declare const makePatches: (previousRows: ReadonlyArray<Row> | undefined, nextRows: ReadonlyArray<Row>) => readonly Patch[];
-export declare const areEqual: (a: Value | Row | ReadonlyArray<Row>, b: Value | Row | ReadonlyArray<Row>) => boolean;
-//# sourceMappingURL=Diff.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Diff.d.ts","sourceRoot":"","sources":["../../src/Diff.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC;CACxC;AAED,MAAM,MAAM,KAAK,GAAG,eAAe,GAAG,cAAc,CAAC;AAErD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,EAAE,YAAY,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC;CACrB;AAED,eAAO,MAAM,YAAY,YACd,aAAa,CAAC,KAAK,CAAC,WACpB,aAAa,CAAC,GAAG,CAAC,KAC1B,aAAa,CAAC,GAAG,CASP,CAAC;AAEd;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,iBACR,aAAa,CAAC,GAAG,CAAC,GAAG,SAAS,YAClC,aAAa,CAAC,GAAG,CAAC,KAC3B,SAAS,KAAK,EA2BhB,CAAC;AAEF,eAAO,MAAM,QAAQ,MAChB,KAAK,GAAG,GAAG,GAAG,aAAa,CAAC,GAAG,CAAC,KAChC,KAAK,GAAG,GAAG,GAAG,aAAa,CAAC,GAAG,CAAC,KAClC,OAkCF,CAAC"}

package/dist/src/Diff.js

@@ -1,84 +0,0 @@
-import * as Arr from "effect/Array";
-import * as Predicate from "effect/Predicate";
-export const applyPatches = (patches, current) => patches.reduce((next, patch) => {
-    switch (patch.op) {
-        case "replaceAll":
-            return patch.value;
-        case "replaceAt": {
-            return Arr.replace(next, patch.index, patch.value);
-        }
-    }
-}, current);
-/**
- * We detect only changes in the whole result and in-place edits. In the future,
- * we will add more heuristics. We will probably not implement the Myers diff
- * algorithm because it's faster to rerender all than to compute many detailed
- * patches. We will only implement logic a developer would implement manually,
- * if necessary.
- */
-export const makePatches = (previousRows, nextRows) => {
-    if (previousRows === undefined)
-        return [{ op: "replaceAll", value: nextRows }];
-    // TODO: Detect prepend and append, it's cheap.
-    if (previousRows.length !== nextRows.length) {
-        return [{ op: "replaceAll", value: nextRows }];
-    }
-    const length = previousRows.length;
-    const replaceAtPatches = [];
-    for (let i = 0; i < length; i++) {
-        const previousRow = previousRows[i];
-        const nextRow = nextRows[i];
-        // We expect the same shape for both rows.
-        for (const key in previousRow)
-            if (!areEqual(previousRow[key], nextRow[key])) {
-                replaceAtPatches.push({ op: "replaceAt", value: nextRow, index: i });
-                break;
-            }
-    }
-    if (length > 0 && replaceAtPatches.length === length) {
-        return [{ op: "replaceAll", value: nextRows }];
-    }
-    return replaceAtPatches;
-};
-export const areEqual = (a, b) => {
-    // Compare string, number, null ASAP.
-    if (a === b)
-        return true;
-    // Different type works only for string and number, everything else is an object.
-    if (typeof a !== typeof b)
-        return false;
-    // Both are nonnullable objects.
-    if (typeof a === "object" && a !== null && b !== null) {
-        const aIsUint8Array = Predicate.isUint8Array(a);
-        const bIsUint8Array = Predicate.isUint8Array(b);
-        if (aIsUint8Array && bIsUint8Array) {
-            if (a.length !== b.length)
-                return false;
-            for (let i = 0; i < a.length; i++)
-                if (a[i] !== b[i])
-                    return false;
-            return true;
-        }
-        const aIsArray = Arr.isArray(a);
-        const bIsArray = Arr.isArray(b);
-        if (aIsArray && bIsArray) {
-            if (a.length !== b.length)
-                return false;
-            for (let i = 0; i < a.length; i++)
-                if (!areEqual(a[i], b[i]))
-                    return false;
-            return true;
-        }
-        if (!aIsUint8Array && !bIsUint8Array && !aIsArray && !bIsArray) {
-            const aKeys = Object.keys(a);
-            const bKeys = Object.keys(b);
-            if (aKeys.length !== bKeys.length)
-                return false;
-            for (const key of aKeys)
-                if (!areEqual(a[key], b[key]))
-                    return false;
-            return true;
-        }
-    }
-    return false;
-};