@tanstack/db-sqlite-persistence-core 0.2.23 → 0.4.0

package/dist/cjs/remote-subset-wire.cjs

@@ -0,0 +1,681 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const db = require("@tanstack/db");
+class RemoteSubsetWireValueError extends TypeError {
+  constructor(path, reason) {
+    super(`Unsupported remote subset wire value at ${path}: ${reason}`);
+    this.path = path;
+    this.name = `RemoteSubsetWireValueError`;
+  }
+}
+const typedArrayConstructors = [
+  Int8Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array,
+  BigInt64Array,
+  BigUint64Array
+];
+const NativeDate = Date;
+const identifierPattern = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function toTransportedLoadSubsetOptions(options) {
+  assertPlainContainer(options, `options`);
+  assertAllowedProperties(options, `options`, [
+    `where`,
+    `orderBy`,
+    `limit`,
+    `cursor`,
+    `offset`,
+    `signal`,
+    `subscription`
+  ]);
+  const state = {
+    expressions: /* @__PURE__ */ new WeakMap(),
+    expressionArrays: /* @__PURE__ */ new WeakMap(),
+    stringArrays: /* @__PURE__ */ new WeakMap(),
+    orderByArrays: /* @__PURE__ */ new WeakMap(),
+    orderByClauses: /* @__PURE__ */ new WeakMap(),
+    compareOptions: /* @__PURE__ */ new WeakMap(),
+    cursors: /* @__PURE__ */ new WeakMap(),
+    wireValues: /* @__PURE__ */ new WeakMap()
+  };
+  const projected = {};
+  const where = readDataProperty(options, `where`, `options.where`);
+  const orderBy = readDataProperty(options, `orderBy`, `options.orderBy`);
+  const limit = readDataProperty(options, `limit`, `options.limit`);
+  const cursor = readDataProperty(options, `cursor`, `options.cursor`);
+  const offset = readDataProperty(options, `offset`, `options.offset`);
+  if (where.present && where.value !== void 0) {
+    projected.where = projectExpression(where.value, `options.where`, state);
+  }
+  if (orderBy.present && orderBy.value !== void 0) {
+    projected.orderBy = projectOrderBy(orderBy.value, `options.orderBy`, state);
+  }
+  if (limit.present && limit.value !== void 0) {
+    projected.limit = projectNumber(limit.value, `options.limit`);
+  }
+  if (cursor.present && cursor.value !== void 0) {
+    projected.cursor = projectCursor(cursor.value, `options.cursor`, state);
+  }
+  if (offset.present && offset.value !== void 0) {
+    projected.offset = projectNumber(offset.value, `options.offset`);
+  }
+  return projected;
+}
+function toProcessLocalLoadSubsetOptions(options, transported = toTransportedLoadSubsetOptions(options)) {
+  const projected = {
+    ...transported
+  };
+  const signal = readDataProperty(options, `signal`, `options.signal`);
+  const subscription = readDataProperty(
+    options,
+    `subscription`,
+    `options.subscription`
+  );
+  if (signal.present) {
+    projected.signal = signal.value;
+  }
+  if (subscription.present) {
+    projected.subscription = subscription.value;
+  }
+  return projected;
+}
+function projectExpression(value, path, state) {
+  const object = requireObject(value, path);
+  const existing = state.expressions.get(object);
+  if (existing) return existing;
+  const type = readDataProperty(object, `type`, `${path}.type`);
+  if (!type.present || typeof type.value !== `string`) {
+    throw new RemoteSubsetWireValueError(`${path}.type`, describe(type.value));
+  }
+  switch (type.value) {
+    case `ref`: {
+      assertExpressionPrototype(object, path, db.IR.PropRef.prototype);
+      assertAllowedProperties(object, path, [`type`, `path`, `sourceAlias`]);
+      const projected = {
+        type: `ref`,
+        path: []
+      };
+      state.expressions.set(object, projected);
+      const sourcePath = readRequiredDataProperty(
+        object,
+        `path`,
+        `${path}.path`
+      );
+      projected.path = projectStringArray(sourcePath, `${path}.path`, state);
+      const sourceAlias = readDataProperty(
+        object,
+        `sourceAlias`,
+        `${path}.sourceAlias`
+      );
+      if (sourceAlias.present) {
+        if (typeof sourceAlias.value !== `string` || projected.path[0] !== sourceAlias.value) {
+          throw new RemoteSubsetWireValueError(
+            `${path}.sourceAlias`,
+            `source alias must match the first path segment`
+          );
+        }
+        projected.sourceAlias = sourceAlias.value;
+      }
+      return projected;
+    }
+    case `val`: {
+      assertExpressionPrototype(object, path, db.IR.Value.prototype);
+      assertAllowedProperties(object, path, [`type`, `value`]);
+      const projected = {
+        type: `val`,
+        value: void 0
+      };
+      state.expressions.set(object, projected);
+      const sourceValue = readRequiredDataProperty(
+        object,
+        `value`,
+        `${path}.value`
+      );
+      projected.value = projectWireValue(sourceValue, `${path}.value`, state);
+      return projected;
+    }
+    case `func`: {
+      assertExpressionPrototype(object, path, db.IR.Func.prototype);
+      assertAllowedProperties(object, path, [`type`, `name`, `args`]);
+      const projected = {
+        type: `func`,
+        name: ``,
+        args: []
+      };
+      state.expressions.set(object, projected);
+      const name = readRequiredDataProperty(object, `name`, `${path}.name`);
+      if (typeof name !== `string`) {
+        throw new RemoteSubsetWireValueError(`${path}.name`, describe(name));
+      }
+      projected.name = name;
+      const args = readRequiredDataProperty(object, `args`, `${path}.args`);
+      projected.args = projectExpressionArray(args, `${path}.args`, state);
+      return projected;
+    }
+    default:
+      throw new RemoteSubsetWireValueError(`${path}.type`, String(type.value));
+  }
+}
+function projectExpressionArray(value, path, state) {
+  const array = requireArray(value, path);
+  const existing = state.expressionArrays.get(array);
+  if (existing) return existing;
+  assertArrayShape(array, path);
+  const projected = new Array(array.length);
+  state.expressionArrays.set(array, projected);
+  for (let index = 0; index < array.length; index++) {
+    if (!(index in array)) {
+      throw new RemoteSubsetWireValueError(
+        `${path}[${index}]`,
+        `missing expression`
+      );
+    }
+    projected[index] = projectExpression(
+      array[index],
+      `${path}[${index}]`,
+      state
+    );
+  }
+  return projected;
+}
+function projectStringArray(value, path, state) {
+  const array = requireArray(value, path);
+  const existing = state.stringArrays.get(array);
+  if (existing) return existing;
+  assertArrayShape(array, path);
+  const projected = new Array(array.length);
+  state.stringArrays.set(array, projected);
+  for (let index = 0; index < array.length; index++) {
+    const entry = array[index];
+    if (!(index in array) || typeof entry !== `string`) {
+      throw new RemoteSubsetWireValueError(`${path}[${index}]`, describe(entry));
+    }
+    projected[index] = entry;
+  }
+  return projected;
+}
+function projectOrderBy(value, path, state) {
+  const array = requireArray(value, path);
+  const existing = state.orderByArrays.get(array);
+  if (existing) return existing;
+  assertArrayShape(array, path);
+  const projected = new Array(array.length);
+  state.orderByArrays.set(array, projected);
+  for (let index = 0; index < array.length; index++) {
+    const clausePath = `${path}[${index}]`;
+    const clause = requirePlainRecord(array[index], clausePath);
+    const existingClause = state.orderByClauses.get(clause);
+    if (existingClause) {
+      projected[index] = existingClause;
+      continue;
+    }
+    assertAllowedProperties(clause, clausePath, [
+      `expression`,
+      `compareOptions`
+    ]);
+    const projectedClause = {
+      expression: void 0,
+      compareOptions: void 0
+    };
+    projected[index] = projectedClause;
+    state.orderByClauses.set(clause, projectedClause);
+    projectedClause.expression = projectExpression(
+      readRequiredDataProperty(
+        clause,
+        `expression`,
+        `${clausePath}.expression`
+      ),
+      `${clausePath}.expression`,
+      state
+    );
+    projectedClause.compareOptions = projectCompareOptions(
+      readRequiredDataProperty(
+        clause,
+        `compareOptions`,
+        `${clausePath}.compareOptions`
+      ),
+      `${clausePath}.compareOptions`,
+      state
+    );
+  }
+  return projected;
+}
+function projectCompareOptions(value, path, state) {
+  const source = requirePlainRecord(value, path);
+  const existing = state.compareOptions.get(source);
+  if (existing) return existing;
+  assertAllowedProperties(source, path, [
+    `direction`,
+    `nulls`,
+    `stringSort`,
+    `locale`,
+    `localeOptions`
+  ]);
+  const projected = {};
+  const direction = readRequiredDataProperty(
+    source,
+    `direction`,
+    `${path}.direction`
+  );
+  if (direction !== `asc` && direction !== `desc`) {
+    throw new RemoteSubsetWireValueError(
+      `${path}.direction`,
+      describe(direction)
+    );
+  }
+  projected.direction = direction;
+  const nulls = readRequiredDataProperty(source, `nulls`, `${path}.nulls`);
+  if (nulls !== `first` && nulls !== `last`) {
+    throw new RemoteSubsetWireValueError(`${path}.nulls`, describe(nulls));
+  }
+  projected.nulls = nulls;
+  const stringSort = readDataProperty(
+    source,
+    `stringSort`,
+    `${path}.stringSort`
+  );
+  if (stringSort.present && stringSort.value !== void 0) {
+    if (stringSort.value !== `lexical` && stringSort.value !== `locale`) {
+      throw new RemoteSubsetWireValueError(
+        `${path}.stringSort`,
+        describe(stringSort.value)
+      );
+    }
+    projected.stringSort = stringSort.value;
+  }
+  if (projected.stringSort !== `lexical`) {
+    const locale = readDataProperty(source, `locale`, `${path}.locale`);
+    if (locale.present && locale.value !== void 0) {
+      if (typeof locale.value !== `string`) {
+        throw new RemoteSubsetWireValueError(
+          `${path}.locale`,
+          describe(locale.value)
+        );
+      }
+      projected.locale = locale.value;
+    }
+    const localeOptions = readDataProperty(
+      source,
+      `localeOptions`,
+      `${path}.localeOptions`
+    );
+    if (localeOptions.present && localeOptions.value !== void 0) {
+      projected.localeOptions = projectWireRecord(
+        localeOptions.value,
+        `${path}.localeOptions`,
+        state
+      );
+    }
+  }
+  const result = projected;
+  state.compareOptions.set(source, result);
+  return result;
+}
+function projectCursor(value, path, state) {
+  const source = requirePlainRecord(value, path);
+  const existing = state.cursors.get(source);
+  if (existing) return existing;
+  assertAllowedProperties(source, path, [
+    `whereFrom`,
+    `whereCurrent`,
+    `lastKey`
+  ]);
+  const projected = {
+    whereFrom: void 0,
+    whereCurrent: void 0
+  };
+  state.cursors.set(source, projected);
+  projected.whereFrom = projectExpression(
+    readRequiredDataProperty(source, `whereFrom`, `${path}.whereFrom`),
+    `${path}.whereFrom`,
+    state
+  );
+  projected.whereCurrent = projectExpression(
+    readRequiredDataProperty(source, `whereCurrent`, `${path}.whereCurrent`),
+    `${path}.whereCurrent`,
+    state
+  );
+  const lastKey = readDataProperty(source, `lastKey`, `${path}.lastKey`);
+  if (lastKey.present && lastKey.value !== void 0) {
+    if (typeof lastKey.value !== `string` && typeof lastKey.value !== `number`) {
+      throw new RemoteSubsetWireValueError(
+        `${path}.lastKey`,
+        describe(lastKey.value)
+      );
+    }
+    projected.lastKey = lastKey.value;
+  }
+  return projected;
+}
+function projectWireValue(value, path, state) {
+  if (value === void 0 || value === null || typeof value === `boolean` || typeof value === `string` || typeof value === `number` || typeof value === `bigint`) {
+    return value;
+  }
+  if (typeof value !== `object`) {
+    throw new RemoteSubsetWireValueError(path, describe(value));
+  }
+  const existing = state.wireValues.get(value);
+  if (existing) return existing;
+  if (typeof SharedArrayBuffer !== `undefined` && value instanceof SharedArrayBuffer) {
+    throw new RemoteSubsetWireValueError(path, `SharedArrayBuffer`);
+  }
+  if (value instanceof NativeDate) {
+    assertExactPrototype(value, NativeDate.prototype, path);
+    assertNoOwnProperties(value, path);
+    const projected = new NativeDate(value.getTime());
+    state.wireValues.set(value, projected);
+    return projected;
+  }
+  if (value instanceof RegExp) {
+    assertExactPrototype(value, RegExp.prototype, path);
+    assertRegExpShape(value, path);
+    const projected = new RegExp(value.source, value.flags);
+    state.wireValues.set(value, projected);
+    return projected;
+  }
+  if (value instanceof ArrayBuffer) {
+    assertExactPrototype(value, ArrayBuffer.prototype, path);
+    assertNoOwnProperties(value, path);
+    assertFixedArrayBuffer(value, path);
+    let projected;
+    try {
+      projected = value.slice(0);
+    } catch {
+      throw new RemoteSubsetWireValueError(path, `detached ArrayBuffer`);
+    }
+    state.wireValues.set(value, projected);
+    return projected;
+  }
+  if (value instanceof DataView) {
+    assertExactPrototype(value, DataView.prototype, path);
+    assertNoOwnProperties(value, path);
+    let byteOffset;
+    let byteLength;
+    let buffer;
+    try {
+      byteOffset = value.byteOffset;
+      byteLength = value.byteLength;
+      buffer = value.buffer;
+    } catch {
+      throw new RemoteSubsetWireValueError(path, `detached DataView`);
+    }
+    const projectedBuffer = projectWireValue(buffer, path, state);
+    if (!(projectedBuffer instanceof ArrayBuffer)) {
+      throw new RemoteSubsetWireValueError(path, `shared DataView buffer`);
+    }
+    const projected = new DataView(projectedBuffer, byteOffset, byteLength);
+    state.wireValues.set(value, projected);
+    return projected;
+  }
+  const typedArrayConstructor = getTypedArrayConstructor(value);
+  if (typedArrayConstructor) {
+    const typedArray = value;
+    assertTypedArrayShape(typedArray, path);
+    let byteOffset;
+    let length;
+    let buffer;
+    try {
+      byteOffset = typedArray.byteOffset;
+      length = typedArray.length;
+      buffer = typedArray.buffer;
+    } catch {
+      throw new RemoteSubsetWireValueError(path, `detached typed array`);
+    }
+    if (!(buffer instanceof ArrayBuffer)) {
+      throw new RemoteSubsetWireValueError(path, `shared typed-array buffer`);
+    }
+    const projectedBuffer = projectWireValue(buffer, path, state);
+    if (!(projectedBuffer instanceof ArrayBuffer)) {
+      throw new RemoteSubsetWireValueError(path, `shared typed-array buffer`);
+    }
+    let projected;
+    try {
+      projected = new typedArrayConstructor(projectedBuffer, byteOffset, length);
+    } catch {
+      throw new RemoteSubsetWireValueError(path, `detached typed array`);
+    }
+    state.wireValues.set(value, projected);
+    return projected;
+  }
+  if (ArrayBuffer.isView(value)) {
+    throw new RemoteSubsetWireValueError(path, describe(value));
+  }
+  if (Array.isArray(value)) return projectWireArray(value, path, state);
+  if (value instanceof Map) return projectWireMap(value, path, state);
+  if (value instanceof Set) return projectWireSet(value, path, state);
+  return projectWireRecord(value, path, state);
+}
+function projectWireArray(value, path, state) {
+  assertArrayShape(value, path);
+  const projected = new Array(value.length);
+  state.wireValues.set(value, projected);
+  for (let index = 0; index < value.length; index++) {
+    if (index in value) {
+      projected[index] = projectWireValue(
+        value[index],
+        `${path}[${index}]`,
+        state
+      );
+    }
+  }
+  return projected;
+}
+function projectWireMap(value, path, state) {
+  assertExactPrototype(value, Map.prototype, path);
+  assertNoOwnProperties(value, path);
+  const projected = /* @__PURE__ */ new Map();
+  state.wireValues.set(value, projected);
+  let index = 0;
+  for (const [key, entry] of value) {
+    projected.set(
+      projectWireValue(key, `${path}.entries[${index}].key`, state),
+      projectWireValue(entry, `${path}.entries[${index}].value`, state)
+    );
+    index++;
+  }
+  return projected;
+}
+function projectWireSet(value, path, state) {
+  assertExactPrototype(value, Set.prototype, path);
+  assertNoOwnProperties(value, path);
+  const projected = /* @__PURE__ */ new Set();
+  state.wireValues.set(value, projected);
+  let index = 0;
+  for (const entry of value) {
+    projected.add(projectWireValue(entry, `${path}.values[${index}]`, state));
+    index++;
+  }
+  return projected;
+}
+function projectWireRecord(value, path, state) {
+  const source = requirePlainRecord(value, path);
+  const existing = state.wireValues.get(source);
+  if (existing) return existing;
+  const projected = {};
+  state.wireValues.set(source, projected);
+  for (const key of ownKeys(source, path)) {
+    const childPath = propertyPath(path, key);
+    if (typeof key === `symbol`) {
+      throw new RemoteSubsetWireValueError(childPath, `symbol property key`);
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(source, key);
+    if (!descriptor || !descriptor.enumerable || !(`value` in descriptor)) {
+      throw new RemoteSubsetWireValueError(childPath, `non-data property`);
+    }
+    Object.defineProperty(projected, key, {
+      value: projectWireValue(descriptor.value, childPath, state),
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+  return projected;
+}
+function projectNumber(value, path) {
+  if (typeof value !== `number` || !Number.isSafeInteger(value) || value < 0) {
+    throw new RemoteSubsetWireValueError(path, `non-negative safe integer`);
+  }
+  return value;
+}
+function readRequiredDataProperty(value, key, path) {
+  const property = readDataProperty(value, key, path);
+  if (!property.present) {
+    throw new RemoteSubsetWireValueError(path, `missing property`);
+  }
+  return property.value;
+}
+function readDataProperty(value, key, path) {
+  let descriptor;
+  try {
+    descriptor = Object.getOwnPropertyDescriptor(value, key);
+  } catch {
+    throw new RemoteSubsetWireValueError(path, `unreadable property`);
+  }
+  if (!descriptor) return { present: false };
+  if (!descriptor.enumerable || !(`value` in descriptor)) {
+    throw new RemoteSubsetWireValueError(path, `non-data property`);
+  }
+  return { present: true, value: descriptor.value };
+}
+function assertAllowedProperties(value, path, allowed) {
+  const allowedSet = new Set(allowed);
+  for (const key of ownKeys(value, path)) {
+    if (typeof key === `symbol` || !allowedSet.has(key)) {
+      throw new RemoteSubsetWireValueError(propertyPath(path, key), `property`);
+    }
+    readDataProperty(value, key, propertyPath(path, key));
+  }
+}
+function assertPlainContainer(value, path) {
+  assertExactPrototype(value, Object.prototype, path);
+}
+function assertExpressionPrototype(value, path, expressionPrototype) {
+  let prototype;
+  try {
+    prototype = Object.getPrototypeOf(value);
+  } catch {
+    throw new RemoteSubsetWireValueError(path, `unreadable prototype`);
+  }
+  if (prototype !== Object.prototype && prototype !== expressionPrototype) {
+    throw new RemoteSubsetWireValueError(path, describe(value));
+  }
+}
+function assertExactPrototype(value, expected, path) {
+  let prototype;
+  try {
+    prototype = Object.getPrototypeOf(value);
+  } catch {
+    throw new RemoteSubsetWireValueError(path, `unreadable prototype`);
+  }
+  if (prototype !== expected) {
+    throw new RemoteSubsetWireValueError(path, describe(value));
+  }
+}
+function assertNoOwnProperties(value, path) {
+  const keys = ownKeys(value, path);
+  if (keys.length > 0) {
+    throw new RemoteSubsetWireValueError(
+      propertyPath(path, keys[0]),
+      `property`
+    );
+  }
+}
+function assertFixedArrayBuffer(value, path) {
+  if (value.resizable) {
+    throw new RemoteSubsetWireValueError(path, `resizable ArrayBuffer`);
+  }
+}
+function assertRegExpShape(value, path) {
+  const keys = ownKeys(value, path);
+  for (const key of keys) {
+    if (key !== `lastIndex`) {
+      throw new RemoteSubsetWireValueError(propertyPath(path, key), `property`);
+    }
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(value, `lastIndex`);
+  if (!descriptor || !(`value` in descriptor) || descriptor.value !== 0) {
+    throw new RemoteSubsetWireValueError(
+      `${path}.lastIndex`,
+      `RegExp lastIndex must be 0`
+    );
+  }
+}
+function assertTypedArrayShape(value, path) {
+  const keys = ownKeys(value, path);
+  for (const key of keys) {
+    if (typeof key !== `string` || !isCanonicalArrayIndex(key, value.length)) {
+      throw new RemoteSubsetWireValueError(propertyPath(path, key), `property`);
+    }
+  }
+}
+function assertArrayShape(value, path) {
+  assertExactPrototype(value, Array.prototype, path);
+  const keys = ownKeys(value, path);
+  for (const key of keys) {
+    if (key !== `length` && (typeof key !== `string` || !isCanonicalArrayIndex(key, value.length))) {
+      throw new RemoteSubsetWireValueError(propertyPath(path, key), `property`);
+    }
+    if (key !== `length`) {
+      readDataProperty(value, key, propertyPath(path, key));
+    }
+  }
+}
+function isCanonicalArrayIndex(key, length) {
+  if (!/^(0|[1-9][0-9]*)$/.test(key)) return false;
+  const index = Number(key);
+  return Number.isSafeInteger(index) && index >= 0 && index < length;
+}
+function getTypedArrayConstructor(value) {
+  let prototype;
+  try {
+    prototype = Object.getPrototypeOf(value);
+  } catch {
+    return void 0;
+  }
+  return typedArrayConstructors.find(
+    (constructor) => prototype === constructor.prototype
+  );
+}
+function requireArray(value, path) {
+  if (!Array.isArray(value)) {
+    throw new RemoteSubsetWireValueError(path, describe(value));
+  }
+  return value;
+}
+function requireObject(value, path) {
+  if (value === null || typeof value !== `object`) {
+    throw new RemoteSubsetWireValueError(path, describe(value));
+  }
+  return value;
+}
+function requirePlainRecord(value, path) {
+  const object = requireObject(value, path);
+  assertExactPrototype(object, Object.prototype, path);
+  return object;
+}
+function ownKeys(value, path) {
+  try {
+    return Reflect.ownKeys(value);
+  } catch {
+    throw new RemoteSubsetWireValueError(path, `unreadable properties`);
+  }
+}
+function propertyPath(path, key) {
+  if (typeof key === `symbol`) return `${path}[${String(key)}]`;
+  return identifierPattern.test(key) ? `${path}.${key}` : `${path}[${JSON.stringify(key)}]`;
+}
+function describe(value) {
+  if (value === null) return `null`;
+  if (typeof value !== `object`) return typeof value;
+  return `object`;
+}
+exports.RemoteSubsetWireValueError = RemoteSubsetWireValueError;
+exports.toProcessLocalLoadSubsetOptions = toProcessLocalLoadSubsetOptions;
+exports.toTransportedLoadSubsetOptions = toTransportedLoadSubsetOptions;
+//# sourceMappingURL=remote-subset-wire.cjs.map