@loro-dev/flock-sqlite 0.1.0

package/src/moonbit.d.ts

@@ -0,0 +1,57 @@
+/**
+ * A non-public unique symbol used to mark the brand of a type.
+ * And avoid user to construct values of the type.
+ */
+export const __brand: unique symbol;
+
+export type Unit = undefined;
+export type Bool = boolean;
+
+/**
+ * A signed integer in 32-bit two's complement format.
+ */
+export type Int = number;
+
+/**
+ * An unsigned integer in 32-bit two's complement format.
+ */
+export type UInt = number;
+
+/**
+ * A character in the range 0-0x10FFFF.
+ */
+export type Char = number;
+
+/**
+ * A byte in the range 0-255.
+ */
+export type Byte = number;
+
+/**
+ * Single-precision floating point number.
+ */
+export type Float = number;
+
+export type Double = number;
+
+export type Int64 = { [__brand]: 568910272 };
+
+export type UInt64 = { [__brand]: 689305396 };
+
+export type String = string;
+
+export type Bytes = Uint8Array;
+
+export type FixedArray<T> = T[];
+
+export type UnboxedOption<T> = 
+  | /* Some */ T 
+  | /* None */ undefined;
+
+export type UnboxedOptionAsInt<T> = 
+  | /* Some */ T 
+  | /* None */ -1;
+
+export type Result<T, E> =
+  | /* Ok */ { $tag: 1, _0: T }
+  | /* Err */ { $tag: 0, _0: E };

package/src/types.ts

@@ -0,0 +1,128 @@
+export type Value =
+  | string
+  | number
+  | boolean
+  | null
+  | Array<Value>
+  | { [key: string]: Value };
+
+export type KeyPart = Value;
+
+export type MetadataMap = Record<string, unknown>;
+
+export type ExportRecord = {
+  c: string;
+  d?: Value;
+  m?: MetadataMap;
+};
+
+export type ExportBundle = { version: number; entries: Record<string, ExportRecord> };
+
+export type EntryClock = {
+  physicalTime: number;
+  logicalCounter: number;
+  peerId: string;
+};
+
+export type ExportPayload = {
+  data?: Value;
+  metadata?: MetadataMap;
+};
+
+export type ExportHookContext = {
+  key: KeyPart[];
+  clock: EntryClock;
+  raw: ExportRecord;
+};
+
+export type MaybePromise<T> = T | Promise<T>;
+
+export type ExportHooks = {
+  transform?: (context: ExportHookContext, payload: ExportPayload) => MaybePromise<ExportPayload | void>;
+};
+
+export type ImportPayload = ExportPayload;
+
+export type ImportHookContext = ExportHookContext;
+
+export type ImportAccept = { accept: true };
+export type ImportSkip = { accept: false; reason: string };
+export type ImportDecision = ImportAccept | ImportSkip | ImportPayload | void;
+
+export type ImportHooks = {
+  preprocess?: (context: ImportHookContext, payload: ImportPayload) => MaybePromise<ImportDecision>;
+};
+
+export type ImportReport = {
+  accepted: number;
+  skipped: Array<{ key: KeyPart[]; reason: string }>;
+};
+
+export type VersionVectorEntry = {
+  physicalTime: number;
+  logicalCounter: number;
+};
+
+export type VersionVector = Record<string, VersionVectorEntry>;
+
+export type ScanBound =
+  | { kind: "inclusive"; key: KeyPart[] }
+  | { kind: "exclusive"; key: KeyPart[] }
+  | { kind: "unbounded" };
+
+export type ScanOptions = {
+  start?: ScanBound;
+  end?: ScanBound;
+  prefix?: KeyPart[];
+};
+
+export type ScanRow = {
+  key: KeyPart[];
+  raw: ExportRecord;
+  value?: Value;
+};
+
+export type EventPayload = ExportPayload;
+
+export type Event = {
+  key: KeyPart[];
+  value?: Value;
+  metadata?: MetadataMap;
+  payload: EventPayload;
+};
+
+export type EventBatch = {
+  source: string;
+  events: Event[];
+};
+
+export type ExportOptions = {
+  from?: VersionVector;
+  hooks?: ExportHooks;
+  pruneTombstonesBefore?: number;
+  peerId?: string;
+};
+
+export type ImportOptions = {
+  bundle: ExportBundle;
+  hooks?: ImportHooks;
+};
+
+export type PutPayload = ExportPayload;
+
+export type PutHookContext = {
+  key: KeyPart[];
+  now?: number;
+};
+
+export type PutHooks = {
+  transform?: (context: PutHookContext, payload: PutPayload) => MaybePromise<PutPayload | void>;
+};
+
+export type PutWithMetaOptions = {
+  metadata?: MetadataMap;
+  now?: number;
+  hooks?: PutHooks;
+};
+
+export type EventListener = (batch: EventBatch) => void;