@evolu/common 8.4.0 → 8.6.0

package/src/Set.ts

@@ -13,6 +13,7 @@
  * ```ts
  * import {
  *   addToSet,
+ *   assertEqual,
  *   deleteFromSet,
  *   filterSet,
  *   firstInSet,
@@ -31,7 +32,7 @@
  * const difference = intersection.difference(new Set([4]));
  *
  * if (!isNonEmptySet(difference)) throw new Error("Expected values");
- * expect(firstInSet(difference)).toBe(6);
+ * assertEqual(firstInSet(difference), 6);
  * ```
  *
  * @module
@@ -58,14 +59,19 @@ export const emptySet: ReadonlySet<never> = /*#__PURE__*/ new Set();
  * ### Preserving non-empty inputs
  *
  * ```ts
- * import { createSet, type NonEmptyReadonlySet } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertType,
+ *   createSet,
+ *   type NonEmptyReadonlySet,
+ * } from "@evolu/common";
  *
  * const values = createSet([1, 2, 3]);
  * const empty = createSet([] as ReadonlyArray<number>);
  *
- * expectTypeOf(values).toEqualTypeOf<NonEmptyReadonlySet<number>>();
- * expectTypeOf(empty).toEqualTypeOf<ReadonlySet<number>>();
- * expect(values).toEqual(new Set([1, 2, 3]));
+ * assertType<NonEmptyReadonlySet<number>, typeof values>();
+ * assertType<ReadonlySet<number>, typeof empty>();
+ * assertEqual(values, new Set([1, 2, 3]));
  * ```
  *
  * @group Constructors
@@ -108,13 +114,18 @@ export type NonEmptyReadonlySet<T> = ReadonlySet<T> & Brand<"NonEmpty">;
  * ### Narrowing before access
  *
  * ```ts
- * import { isNonEmptySet, type NonEmptyReadonlySet } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertType,
+ *   isNonEmptySet,
+ *   type NonEmptyReadonlySet,
+ * } from "@evolu/common";
  *
  * const set: ReadonlySet<number> = new Set([1, 2, 3]);
  * if (!isNonEmptySet(set)) throw new Error("Expected a non-empty set");
  *
- * expectTypeOf(set).toEqualTypeOf<NonEmptyReadonlySet<number>>();
- * expect(set.size).toBe(3);
+ * assertType<NonEmptyReadonlySet<number>, typeof set>();
+ * assertEqual(set.size, 3);
  * ```
  *
  * @group Type guards
@@ -132,15 +143,21 @@ export const isNonEmptySet = <T>(
  * ### Adding without mutation
  *
  * ```ts
- * import { addToSet, type NonEmptyReadonlySet } from "@evolu/common";
+ * import {
+ *   addToSet,
+ *   assertEqual,
+ *   assertTrue,
+ *   assertType,
+ *   type NonEmptyReadonlySet,
+ * } from "@evolu/common";
  *
  * const original: ReadonlySet<number> = new Set([1, 2]);
  * const added = addToSet(original, 3);
  * const unchanged = addToSet(original, 2);
  *
- * expectTypeOf(added).toEqualTypeOf<NonEmptyReadonlySet<number>>();
- * expect(added).toEqual(new Set([1, 2, 3]));
- * expect(unchanged).not.toBe(original);
+ * assertType<NonEmptyReadonlySet<number>, typeof added>();
+ * assertEqual(added, new Set([1, 2, 3]));
+ * assertTrue(unchanged !== original);
  * ```
  *
  * @group Transformations
@@ -163,11 +180,11 @@ export const addToSet = <T>(
  * ### Deleting without mutation
  *
  * ```ts
- * import { deleteFromSet } from "@evolu/common";
+ * import { assertEqual, assertTrue, deleteFromSet } from "@evolu/common";
  *
  * const original = new Set([1, 2, 3]);
- * expect(deleteFromSet(original, 2)).toEqual(new Set([1, 3]));
- * expect(deleteFromSet(original, 5)).not.toBe(original);
+ * assertEqual(deleteFromSet(original, 2), new Set([1, 3]));
+ * assertTrue(deleteFromSet(original, 5) !== original);
  * ```
  *
  * @group Transformations
@@ -193,6 +210,8 @@ export const deleteFromSet = <T>(
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertType,
  *   createSet,
  *   mapSet,
  *   type NonEmptyReadonlySet,
@@ -202,9 +221,9 @@ export const deleteFromSet = <T>(
  * const doubled = mapSet(original, (x) => x * 2);
  * const parity = mapSet(original, (x) => x % 2);
  *
- * expectTypeOf(doubled).toEqualTypeOf<NonEmptyReadonlySet<number>>();
- * expect(doubled).toEqual(new Set([2, 4, 6]));
- * expect(parity).toEqual(new Set([1, 0]));
+ * assertType<NonEmptyReadonlySet<number>, typeof doubled>();
+ * assertEqual(doubled, new Set([2, 4, 6]));
+ * assertEqual(parity, new Set([1, 0]));
  * ```
  *
  * @group Transformations
@@ -239,18 +258,18 @@ export function mapSet<T, U>(
  * ### Filtering and refining
  *
  * ```ts
- * import { filterSet } from "@evolu/common";
+ * import { assertEqual, assertType, filterSet } from "@evolu/common";
  *
  * const evens = filterSet(new Set([1, 2, 3, 4, 5]), (x) => x % 2 === 0);
- * expect(evens).toEqual(new Set([2, 4]));
+ * assertEqual(evens, new Set([2, 4]));
  *
  * const mixed: ReadonlySet<string | number> = new Set([1, "a", 2, "b"]);
  * const strings = filterSet(
  *   mixed,
  *   (value): value is string => typeof value === "string",
  * );
- * expectTypeOf(strings).toEqualTypeOf<ReadonlySet<string>>();
- * expect(strings).toEqual(new Set(["a", "b"]));
+ * assertType<ReadonlySet<string>, typeof strings>();
+ * assertEqual(strings, new Set(["a", "b"]));
  * ```
  *
  * @group Transformations
@@ -284,10 +303,10 @@ export function filterSet<T>(
  * ### Reading the first value
  *
  * ```ts
- * import { createSet, firstInSet } from "@evolu/common";
+ * import { assertEqual, createSet, firstInSet } from "@evolu/common";
  *
  * const set = createSet(["a", "b", "c"]);
- * expect(firstInSet(set)).toBe("a");
+ * assertEqual(firstInSet(set), "a");
  * ```
  *
  * @group Accessors

package/src/Sqlite.ts

@@ -256,12 +256,13 @@ export const createSqlite =
             console.debug({ query });
 
             const label =
-              query.options?.logQueryExecutionTime &&
-              `SqliteQueryExecutionTime ${query.sql}`;
+              query.options?.logQueryExecutionTime === true
+                ? `SqliteQueryExecutionTime ${query.sql}`
+                : null;
 
-            if (label) console.time(label);
+            if (label !== null) console.time(label);
             const result = driver.exec(query);
-            if (label) console.timeEnd(label);
+            if (label !== null) console.timeEnd(label);
 
             if (query.options?.logExplainQueryPlan) {
               const result = driver.exec({
@@ -343,11 +344,12 @@ const drawSqliteQueryPlan = (rows: Array<SqliteQueryPlanRow>): string =>
       let indent = 0;
 
       do {
+        // oxlint-disable-next-line eslint/no-loop-func -- find invokes the callback synchronously before parentId changes.
         const parent = rows.find((r) => r.id === parentId);
         if (!parent) break;
         parentId = parent.parent;
         indent++;
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, no-constant-condition
+        // oxlint-disable-next-line eslint/no-constant-condition -- A missing parent terminates the traversal above.
       } while (true);
 
       return `${"  ".repeat(indent)}${row.detail}`;
@@ -395,7 +397,7 @@ export const createPreparedStatementsCache = <P>(
         if (alwaysPrepare !== true && !query.options?.prepare)
           return null as never;
         let statement = statementsBySql.get(query.sql);
-        if (!statement) {
+        if (statement === undefined) {
           statement = factory(query.sql);
           statementsBySql.set(query.sql, statement);
         }
@@ -432,7 +434,7 @@ export type SqlTemplateParam = SqliteValue | SqlIdentifier | RawSql;
  * ### Example
  *
  * ```ts
- * import { sql } from "@evolu/common";
+ * import { assertEqual, assertTrue, sql } from "@evolu/common";
  *
  * const id = 42;
  * const name = "Alice";
@@ -450,12 +452,13 @@ export type SqlTemplateParam = SqliteValue | SqlIdentifier | RawSql;
  * const orderBy = "created_at desc";
  * const ordered = sql`select * from users order by ${sql.raw(orderBy)};`;
  *
- * expect(select).toEqual({
+ * assertEqual(select, {
  *   sql: "select * from users where id = ? and name = ?;",
  *   parameters: [42, "Alice"],
  * });
- * expect(createTable.sql).toContain('create table "users"');
- * expect(ordered.sql).toBe(
+ * assertTrue(createTable.sql.includes('create table "users"'));
+ * assertEqual(
+ *   ordered.sql,
  *   "select * from users order by created_at desc;",
  * );
  * ```
@@ -492,7 +495,7 @@ export const sql = (
 sql.identifier = (identifier: string): SqlIdentifier => ({
   type: "SqlIdentifier",
   // From Kysely
-  sql: `"${identifier.replace(/"/g, '""')}"` as SafeSql,
+  sql: `"${identifier.replaceAll('"', '""')}"` as SafeSql,
 });
 
 /**
@@ -674,9 +677,9 @@ export const sqliteFalse = 0;
  * ### Example
  *
  * ```ts
- * import { booleanToSqliteBoolean } from "@evolu/common";
+ * import { assertEqual, booleanToSqliteBoolean } from "@evolu/common";
  *
- * expect(booleanToSqliteBoolean(true)).toBe(1);
+ * assertEqual(booleanToSqliteBoolean(true), 1);
  * ```
  */
 export const booleanToSqliteBoolean = (value: boolean): SqliteBoolean =>
@@ -688,9 +691,9 @@ export const booleanToSqliteBoolean = (value: boolean): SqliteBoolean =>
  * ### Example
  *
  * ```ts
- * import { sqliteBooleanToBoolean } from "@evolu/common";
+ * import { assertTrue, sqliteBooleanToBoolean } from "@evolu/common";
  *
- * expect(sqliteBooleanToBoolean(1)).toBe(true);
+ * assertTrue(sqliteBooleanToBoolean(1));
  * ```
  */
 export const sqliteBooleanToBoolean = (value: SqliteBoolean): boolean =>

package/src/Store.ts

@@ -70,7 +70,9 @@ export const createStore = <T>(initialState: T, eq?: Eq<T>): Store<T> => {
     get: ref.get,
     subscribe: (listener) => {
       listeners.add(listener);
-      return () => listeners.delete(listener);
+      return () => {
+        listeners.delete(listener);
+      };
     },
 
     set: (state) => {

package/src/String.ts

@@ -9,7 +9,7 @@
  * pattern.
  */
 export const escapeRegExp = (value: string): string =>
-  value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  value.replaceAll(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 
 /** Converts an unknown value to a compact, human-readable diagnostic string. */
 export const safelyStringifyUnknownValue = (value: unknown): string => {