@byearlybird/starling 0.1.2 → 0.2.0

package/dist/chunk-Bp6m_JJh.js

@@ -0,0 +1,13 @@
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __export = (all) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	return target;
+};
+
+//#endregion
+export { __export as t };

package/dist/index.d.ts

@@ -1,2 +1,170 @@
-export * from "./core/index";
-//# sourceMappingURL=index.d.ts.map
+import { t as __export } from "./chunk-Bp6m_JJh.js";
+
+//#region src/clock.d.ts
+declare namespace clock_d_exports {
+  export { Clock, create$2 as create };
+}
+type Clock = {
+  now: () => string;
+  latest: () => string;
+  forward: (eventstamp: string) => void;
+};
+declare const create$2: () => Clock;
+declare namespace value_d_exports {
+  export { EncodedValue, decode$3 as decode, encode$3 as encode, isEncoded, merge$2 as merge };
+}
+type EncodedValue<T$1> = {
+  __value: T$1;
+  __eventstamp: string;
+};
+declare const encode$3: <T>(value: T, eventstamp: string) => EncodedValue<T>;
+declare const decode$3: <T>(value: EncodedValue<T>) => T;
+declare const merge$2: <T>(into: EncodedValue<T>, from: EncodedValue<T>) => EncodedValue<T>;
+declare const isEncoded: (value: unknown) => boolean;
+declare namespace record_d_exports {
+  export { EncodedRecord, decode$2 as decode, encode$2 as encode, merge$1 as merge };
+}
+type EncodedRecord = {
+  [key: string]: EncodedValue<unknown> | EncodedRecord;
+};
+declare const encode$2: <T extends Record<string, unknown>>(obj: T, eventstamp: string) => EncodedRecord;
+declare const decode$2: <T extends Record<string, unknown>>(obj: EncodedRecord) => T;
+declare const merge$1: (into: EncodedRecord, from: EncodedRecord) => EncodedRecord;
+declare namespace document_d_exports {
+  export { EncodedDocument, decode$1 as decode, del$1 as del, encode$1 as encode, merge };
+}
+type EncodedDocument = {
+  __id: string;
+  __data: EncodedRecord;
+  __deletedAt: string | null;
+};
+declare const encode$1: <T extends Record<string, unknown>>(id: string, obj: T, eventstamp: string, deletedAt?: string | null) => EncodedDocument;
+declare const decode$1: <T extends Record<string, unknown>>(doc: EncodedDocument) => {
+  __id: string;
+  __data: T;
+  __deletedAt: string | null;
+};
+declare const merge: (into: EncodedDocument, from: EncodedDocument) => EncodedDocument;
+declare const del$1: (doc: EncodedDocument, eventstamp: string) => EncodedDocument;
+declare namespace collection_d_exports {
+  export { Collection, del, from, insert, update };
+}
+type Collection = Map<string, EncodedDocument>;
+declare const insert: (collection: Collection, doc: EncodedDocument) => Collection;
+declare const update: (collection: Collection, doc: EncodedDocument) => Collection;
+declare const del: (collection: Collection, id: string) => Collection;
+declare const from: (docs: EncodedDocument[]) => Collection;
+declare namespace eventstamp_d_exports {
+  export { decode, encode };
+}
+declare const encode: (timestampMs: number, counter: number) => string;
+declare const decode: (eventstamp: string) => {
+  timestampMs: number;
+  counter: number;
+};
+declare namespace map_d_exports {
+  export { create$1 as create };
+}
+declare const create$1: (iterable?: Iterable<readonly [string, EncodedDocument]> | null) => {
+  get(key: string): EncodedDocument | null;
+  has(key: string): boolean;
+  values(): MapIterator<EncodedDocument>;
+  entries(): MapIterator<[string, EncodedDocument]>;
+  readonly size: number;
+  put(key: string, value: EncodedDocument): void;
+  patch(key: string, value: EncodedDocument): void;
+  del(key: string, eventstamp: string): void;
+  begin(): {
+    put(key: string, value: EncodedDocument): void;
+    patch(key: string, value: EncodedDocument): void;
+    del(key: string, eventstamp: string): void;
+    commit(): void;
+    rollback(): void;
+  };
+};
+declare namespace store_d_exports {
+  export { Plugin, PluginHandle, Store, StoreHooks, StoreOnBeforeDelete, StoreOnBeforePatch, StoreOnBeforePut, StoreOnDelete, StoreOnPatch, StoreOnPut, StoreOptions, StoreTransaction, create };
+}
+type DeepPartial<T$1> = T$1 extends object ? { [P in keyof T$1]?: DeepPartial<T$1[P]> } : T$1;
+/**
+ * Called once per commit with all put operations accumulated as decoded entries.
+ * Only fires if at least one put occurred.
+ */
+type StoreOnPut<T$1 extends Record<string, unknown>> = (entries: ReadonlyArray<readonly [string, T$1]>) => void;
+/**
+ * Called once per commit with all patch operations accumulated as decoded entries.
+ * Only fires if at least one patch occurred.
+ */
+type StoreOnPatch<T$1 extends Record<string, unknown>> = (entries: ReadonlyArray<readonly [string, T$1]>) => void;
+/**
+ * Called once per commit with all deleted keys (IDs).
+ * Only fires if at least one delete occurred.
+ */
+type StoreOnDelete = (keys: ReadonlyArray<string>) => void;
+/**
+ * Called before a put operation is applied.
+ * Throws to reject the operation.
+ */
+type StoreOnBeforePut<T$1 extends Record<string, unknown>> = (key: string, value: T$1) => void;
+/**
+ * Called before a patch operation is applied.
+ * Throws to reject the operation.
+ */
+type StoreOnBeforePatch<T$1 extends Record<string, unknown>> = (key: string, value: DeepPartial<T$1>) => void;
+/**
+ * Called before a delete operation is applied.
+ * Throws to reject the operation.
+ */
+type StoreOnBeforeDelete = (key: string) => void;
+/**
+ * Hook callbacks that receive batches of decoded entries.
+ * Hooks fire on commit only, never during staged operations.
+ * Arrays are readonly to prevent external mutation.
+ */
+type StoreHooks<T$1 extends Record<string, unknown>> = {
+  onBeforePut?: StoreOnBeforePut<T$1>;
+  onBeforePatch?: StoreOnBeforePatch<T$1>;
+  onBeforeDelete?: StoreOnBeforeDelete;
+  onPut?: StoreOnPut<T$1>;
+  onPatch?: StoreOnPatch<T$1>;
+  onDelete?: StoreOnDelete;
+};
+/**
+ * Configuration for Store instance.
+ * Hooks receive batches of decoded entries on commit.
+ */
+type StoreOptions<T$1 extends Record<string, unknown>> = {
+  hooks?: StoreHooks<T$1>;
+};
+type StoreTransaction<T$1 extends Record<string, unknown>> = {
+  put: (key: string, value: T$1) => void;
+  patch: (key: string, value: DeepPartial<T$1>) => void;
+  del: (key: string) => void;
+  commit: () => void;
+  rollback: () => void;
+};
+type PluginHandle<T$1 extends Record<string, unknown>> = {
+  init: () => Promise<void> | void;
+  dispose: () => Promise<void> | void;
+  hooks?: StoreHooks<T$1>;
+};
+type Plugin<T$1 extends Record<string, unknown>> = (store: Store<T$1>) => PluginHandle<T$1>;
+type Store<T$1 extends Record<string, unknown>> = {
+  get: (key: string) => T$1 | null;
+  has: (key: string) => boolean;
+  readonly size: number;
+  values: () => IterableIterator<T$1>;
+  entries: () => IterableIterator<readonly [string, T$1]>;
+  put: (key: string, value: T$1) => void;
+  patch: (key: string, value: DeepPartial<T$1>) => void;
+  del: (key: string) => void;
+  begin: () => StoreTransaction<T$1>;
+  use: (plugin: Plugin<T$1>) => Store<T$1>;
+  init: () => Promise<void>;
+  dispose: () => Promise<void>;
+};
+declare const create: <T extends Record<string, unknown>>({
+  hooks
+}?: StoreOptions<T>) => Store<T>;
+//#endregion
+export { clock_d_exports as $clock, collection_d_exports as $collection, document_d_exports as $document, eventstamp_d_exports as $eventsamp, map_d_exports as $map, record_d_exports as $record, store_d_exports as $store, value_d_exports as $value };