@warp-drive/experiments 0.2.7-alpha.19 → 0.2.7-alpha.20

package/README.md

@@ -27,5 +27,5 @@
 
 - [DataWorker](./src/data-worker/README.md)
 - [DocumentStorage](./src/document-storage/README.md)
-- [ImageWorker](./src/image-worker/README.md)
+- [ImageWorker](./src/image-worker.md)
 - ReactiveStorage

package/declarations/data-worker.d.ts

@@ -1,2 +1,35 @@
-export { DataWorker } from "./data-worker/worker.js";
-export { CacheHandler } from "./data-worker/cache-handler.js";
+import { t as DocumentStorage } from "./document-storage-CwwTQ49-.js";
+import { n as RequestEventData, t as AbortEventData } from "./types-CRs-Qww6.js";
+import { CacheHandler as CacheHandler$1, Future } from "@warp-drive/core/request";
+import { Store } from "@warp-drive/core";
+//#region src/data-worker/worker.d.ts
+declare class DataWorker {
+  store: Store;
+  threads: Map<string, MessagePort>;
+  pending: Map<string, Map<number, Future<unknown>>>;
+  isSharedWorker: boolean;
+  options: {
+    persisted: boolean;
+    scope?: string;
+  };
+  storage: DocumentStorage;
+  constructor(UserStore: typeof Store, options?: {
+    persisted: boolean;
+    scope?: string;
+  });
+  initialize(): void;
+  setupThread(thread: string, port: MessagePort): void;
+  abortRequest(event: AbortEventData): void;
+  request(event: RequestEventData): Promise<void>;
+}
+//#endregion
+//#region src/data-worker/cache-handler.d.ts
+/**
+ * A simplified CacheHandler that hydrates ResourceDataDocuments from the cache
+ * with their referenced resources.
+ *
+ */
+declare const CacheHandler: CacheHandler$1;
+//#endregion
+export { CacheHandler, DataWorker };
+//# sourceMappingURL=data-worker.d.ts.map

package/declarations/data-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-worker.d.ts","names":[],"sources":["../src/data-worker/worker.ts","../src/data-worker/cache-handler.ts"],"mappings":";;;;;cASa;EACX,OAAe;EACf,SAAiB,YAAY;EAC7B,SAAiB,YAAY,YAAY;EACzC;EACA;IAAmB;IAAoB;;EACvC,SAAiB;EAEjB,YAAY,kBAAkB,OAAO;IAAY;IAAoB;;EAarE;EAkCA,YAAY,gBAAgB,MAAM;EAqBlC,aAAa,OAAO;EAUpB,QAAc,OAAO,mBAAmB;;;;;;;;;cCnE7B,cAAc"}

package/declarations/document-storage-CwwTQ49-.d.ts

@@ -0,0 +1,91 @@
+import { StructuredDocument } from "@warp-drive/core/types/request";
+import { PersistedResourceKey } from "@warp-drive/core/types/identifier";
+import { ResourceDataDocument, ResourceDocument } from "@warp-drive/core/types/spec/document";
+import { ExistingResourceObject } from "@warp-drive/core/types/spec/json-api-raw";
+//#region src/document-storage/index.d.ts
+type DocumentStorageOptions = {
+  /**
+   * The scope of the storage. This is used to enable multiple distinct
+   * storage areas within the same origin.
+   *
+   * One use case for this is to have a separate storage area for each
+   * user credential. So for instance, in applications that allow a single
+   * user to have multiple accounts, each account can have its own storage!
+   */
+  scope: string;
+  /**
+   * When set to true, if other instances of the storage are created with
+   * the same scope, they will not share the same in-memory cache and BroadcastChannel.
+   *
+   * This is mostly useful for testing purposes to replicate the behavior of
+   * multiple tabs or workers.
+   */
+  isolated: boolean;
+};
+/**
+ * DocumentStorage is specifically designed around WarpDrive Cache and Request concepts.
+ *
+ * CacheFileDocument is a StructuredDocument (request response) whose `content` is
+ * the ResourceDocument returned by inserting the request into a Store's Cache.
+ */
+type CacheFileDocument = StructuredDocument<ResourceDocument>;
+/**
+ * A CacheDocument is a reconstructed request response that rehydrates ResourceDocument
+ * with the associated resources based on their identifiers.
+ */
+type CacheDocument = StructuredDocument<ResourceDocument<ExistingResourceObject>>;
+type DocumentIdentifier = {
+  lid: string;
+};
+type MemCache = {
+  documents: Map<string, CacheFileDocument>;
+  resources: Map<string, ExistingResourceObject>;
+};
+declare class InternalDocumentStorage {
+  readonly options: DocumentStorageOptions;
+  _fileHandle: Promise<FileSystemFileHandle>;
+  _channel: BroadcastChannel;
+  _invalidated: boolean;
+  _lastModified: number;
+  _cache: MemCache | null;
+  _filePromise: Promise<MemCache> | null;
+  constructor(options: DocumentStorageOptions);
+  _onMessage(_event: MessageEvent): void;
+  _open(scope: string): Promise<FileSystemFileHandle>;
+  _read(): Promise<MemCache>;
+  _patch(documentKey: string, document: CacheFileDocument, updatedResources: Map<string, ExistingResourceObject>): Promise<void>;
+  getDocument(key: DocumentIdentifier): Promise<CacheDocument | null>;
+  putDocument(document: CacheFileDocument, resourceCollector: (resourceIdentifier: PersistedResourceKey) => ExistingResourceObject): Promise<void>;
+  _getResources(document: ResourceDataDocument, resourceCollector: (resourceIdentifier: PersistedResourceKey) => ExistingResourceObject, resources?: Map<string, ExistingResourceObject>): Map<string, ExistingResourceObject>;
+  putResources(document: ResourceDataDocument, resourceCollector: (resourceIdentifier: PersistedResourceKey) => ExistingResourceObject): Promise<void>;
+  clear(reset?: boolean): Promise<void>;
+}
+/**
+ * DocumentStorage is a wrapper around the StorageManager API that provides
+ * a simple interface for reading and updating documents and requests.
+ *
+ * Some goals for this experiment:
+ *
+ * - optimize for storing requests/documents
+ * - optimize for storing resources
+ * - optimize for looking up resources associated to a document
+ * - optimize for notifying cross-tab when data is updated
+ *
+ * optional features:
+ *
+ * - support for offline mode
+ * - ?? support for relationship based cache traversal
+ * - a way to index records by type + another field (e.g updatedAt/createAt/name)
+ *   such that simple queries can be done without having to scan all records
+ */
+declare class DocumentStorage {
+  readonly _storage: InternalDocumentStorage;
+  constructor(options?: Partial<DocumentStorageOptions>);
+  getDocument(key: DocumentIdentifier): Promise<CacheDocument | null>;
+  putDocument(document: CacheFileDocument, resourceCollector: (resourceIdentifier: PersistedResourceKey) => ExistingResourceObject): Promise<void>;
+  putResources(document: ResourceDataDocument, resourceCollector: (resourceIdentifier: PersistedResourceKey) => ExistingResourceObject): Promise<void>;
+  clear(reset?: boolean): Promise<void>;
+}
+//#endregion
+export { DocumentStorage as t };
+//# sourceMappingURL=document-storage-CwwTQ49-.d.ts.map

package/declarations/document-storage-CwwTQ49-.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-storage-CwwTQ49-.d.ts","names":[],"sources":["../src/document-storage/index.ts"],"mappings":";;;;;KAUY;;;;;;;;;EASV;;;;;;;;EAQA;;;;;;;;KAQG,oBAAoB,mBAAmB;;;;;KAKvC,gBAAgB,mBAAmB,iBAAiB;KAMpD;EAAuB;;KAEvB;EACH,WAAW,YAAY;EACvB,WAAW,YAAY;;cAGnB;WACa,SAAS;EAC1B,aAAqB,QAAQ;EAC7B,UAAkB;EAClB;EACA;EACA,QAAgB;EAChB,cAAsB,QAAQ;EAE9B,YAAY,SAAS;EAWrB,WAAW,QAAQ;EAInB,MAAY,gBAAgB,QAAQ;EAMpC,SAAe,QAAQ;EAmCvB,OACE,qBACA,UAAU,mBACV,kBAAkB,YAAY,0BAC7B;EAuBH,YAAkB,KAAK,qBAAqB,QAAQ;EAqDpD,YACE,UAAU,mBACV,oBAAoB,oBAAoB,yBAAyB,yBAChE;EAkBH,cACE,UAAU,sBACV,oBAAoB,oBAAoB,yBAAyB,wBACjE,YAAW,YAAY,0BACtB,YAAY;EAqBf,aACE,UAAU,sBACV,oBAAoB,oBAAoB,yBAAyB,yBAChE;EAwBH,MAAY,kBAAkB;;;;;;;;;;;;;;;;;;;;cAuInB;WACM,UAAU;EAE3B,YAAY,UAAS,QAAQ;EAoB7B,YAAY,KAAK,qBAAqB,QAAQ;EAI9C,YACE,UAAU,mBACV,oBAAoB,oBAAoB,yBAAyB,yBAChE;EAIH,aACE,UAAU,sBACV,oBAAoB,oBAAoB,yBAAyB,yBAChE;EAIH,MAAM,kBAAkB"}

package/declarations/document-storage.d.ts

@@ -1 +1,2 @@
-export { DocumentStorage } from "./document-storage/index.js";
+import { t as DocumentStorage } from "./document-storage-CwwTQ49-.js";
+export { DocumentStorage };

package/declarations/image-fetch.d.ts

@@ -1 +1,60 @@
-export { ImageFetch } from "./image-worker/fetch.js";
+import { Deferred } from "@warp-drive/core/request";
+//#region src/image-worker/types.d.ts
+/** Sent by {@link ImageFetch} to request that an image url be loaded. */
+type RequestEventData = {
+  type: "load";
+  thread: string;
+  url: string;
+};
+//#endregion
+//#region src/image-worker/fetch.d.ts
+/**
+ * Main-thread client for an {@link ImageWorker}. Sends image `load`
+ * requests to a `Worker` or `SharedWorker` running an `ImageWorker`.
+ *
+ * In FastBoot/SSR, or when constructed with a `null` worker, `ImageFetch`
+ * skips worker communication entirely: {@link ImageFetch.load} resolves
+ * immediately with the given url.
+ *
+ * A plain `Worker` is only accepted when running in a `TESTING` build;
+ * production usage requires a `SharedWorker`.
+ *
+ * @public
+ */
+declare class ImageFetch {
+  worker: Worker | SharedWorker;
+  threadId: string;
+  pending: Map<string, Deferred<string>>;
+  channel: MessageChannel;
+  cache: Map<string, string>;
+  /**
+   * @param worker - the `Worker` or `SharedWorker` running an
+   * {@link ImageWorker}, or `null` to disable worker communication (e.g.
+   * in FastBoot/SSR).
+   */
+  constructor(worker: Worker | SharedWorker | null);
+  cleanupRequest(url: string): Deferred<string> | undefined;
+  _send(event: RequestEventData): void;
+  /**
+   * Requests that the given image url be loaded by the connected
+   * {@link ImageWorker}, resolving with an object url for the fetched
+   * image's blob once the worker responds (or immediately with the
+   * original `url`, in SSR/FastBoot or when this instance was constructed
+   * with a `null` worker).
+   *
+   * The resolved object url is cached in-memory by source url on this
+   * instance, so subsequent calls for the same url resolve immediately
+   * without another round-trip to the worker.
+   *
+   * Calling `load` again for a url that is already in-flight (not yet
+   * cached) on this instance replaces the pending request rather than
+   * joining it — only the most recently issued call for a given url will
+   * resolve.
+   *
+   * @public
+   */
+  load(url: string): Promise<string>;
+}
+//#endregion
+export { ImageFetch };
+//# sourceMappingURL=image-fetch.d.ts.map

package/declarations/image-fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-fetch.d.ts","names":[],"sources":["../src/image-worker/types.ts","../src/image-worker/fetch.ts"],"mappings":";;;KA8BY;EACV;EACA;EACA;;;;;;;;;;;;;;;;;cCFW;EACX,QAAgB,SAAS;EACzB;EACA,SAAiB,YAAY;EAC7B,SAAiB;EACjB,OAAe;;;;;;EAOf,YAAY,QAAQ,SAAS;EA0C7B,eAAe,cAAc;EAO7B,MAAM,OAAO;;;;;;;;;;;;;;;;;;;EAuBb,KAAK,cAAc"}

package/declarations/image-worker.d.ts

@@ -1 +1,40 @@
-export { ImageWorker } from "./image-worker/worker.js";
+//#region src/image-worker/worker.d.ts
+/**
+ * Runs inside a `Worker` or `SharedWorker` to fetch images on behalf of
+ * one or more {@link ImageFetch} instances running on the main thread(s)
+ * that connect to it.
+ *
+ * Each connecting thread registers itself by sending a `connect` message
+ * along with a {@link MessagePort}. When a thread sends a `load` request
+ * for a url, the worker fetches the image via `fetch`, converts the
+ * response into a `Blob`, and creates an object url for it via
+ * `URL.createObjectURL`. The fetch for a given url is deduped and cached
+ * in-memory for the lifetime of the worker, so repeat `load` requests for
+ * the same url — whether from the same or a different connected thread —
+ * do not trigger another network request.
+ *
+ * Only intended for use inside a Worker context: constructing an
+ * `ImageWorker` on the main thread is a no-op.
+ *
+ * @public
+ */
+declare class ImageWorker {
+  private threads;
+  private pendingImages;
+  private options;
+  private isSharedWorker;
+  private cache;
+  /**
+   * @param options.persisted - reserved for a future on-disk cache; currently unused.
+   */
+  constructor(options?: {
+    persisted: boolean;
+  });
+  private fetch;
+  private initialize;
+  private setupThread;
+  private request;
+}
+//#endregion
+export { ImageWorker };
+//# sourceMappingURL=image-worker.d.ts.map

package/declarations/image-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-worker.d.ts","names":[],"sources":["../src/image-worker/worker.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;cA+Ba;UACK;UACA;UACA;UACA;UACA;;;;EAKhB,YAAY;IAAY;;UAahB;UAsBA;UA4BA;UAiBM"}

package/declarations/storage.d.ts

@@ -1,7 +1,359 @@
-export * from "./storage/storage.js";
-export type * from "./storage/storage.js";
-export * from "./storage/storage-resource.js";
-export type * from "./storage/storage-resource.js";
-export * from "./storage/cache.js";
-export type * from "./storage/cache.js";
-export { initMeta as _initMeta, getParamCompanion as _getParamCompanion } from "./storage/-private/storage-infra.js";
+//#region src/storage/cache.d.ts
+declare const DEFAULT_CACHE_ID = "reactive-cache";
+interface InternalCacheStorageEvent {
+  storageArea: string;
+  key: string | null;
+  oldValue: string | null;
+  newValue: string | null;
+}
+interface CacheStorageEvent {
+  storageArea: CacheStorage;
+  key: string | null;
+  oldValue: string | null;
+  newValue: string | null;
+}
+/**
+ * A reactive interface for json stored in the browser [Cache](https://developer.mozilla.org/en-US/docs/Web/API/Cache) API.
+ *
+ * This is a good option for larger data sets than can be efficiently stored in localStorage
+ * but should not be used as a permanent DB or storage solution.
+ */
+declare class CacheStorage implements Storage {
+  #private;
+  _data: Map<string, string | null>;
+  _nextUpdate: number | null;
+  _bufferedEvents: InternalCacheStorageEvent[];
+  constructor(cacheId: string);
+  get length(): number;
+  clear(): void;
+  getItem(key: string): string | null;
+  key(index: number): string | null;
+  removeItem(key: string): void;
+  setItem(key: string, value: string): void;
+  /**
+   * Get the singleton CacheStorage instance.
+   *
+   */
+  static get(cacheId?: string): Promise<CacheStorage>;
+  static expectCache(cacheId?: string): CacheStorage;
+  /**
+   * Returns the IDs of all {@link CacheStorage} instances that have been
+   * opened in this context via {@link CacheStorage.get}.
+   */
+  static getAllCacheIds(): string[];
+}
+//#endregion
+//#region src/storage/storage.d.ts
+interface ReactiveStorageOptions {
+  /**
+   * If true, falls back to in-memory storage when the underlying
+   * storage is unavailable (e.g., private browsing mode).
+   */
+  fallbackToMemory?: boolean;
+  /**
+   * If true, updates signal state even when writes fail due to quota.
+   * The onQuotaExceeded callback will be invoked before retrying.
+   */
+  updateOnQuotaExceeded?: boolean;
+  /**
+   * Called when a write fails due to quota exceeded.
+   * Return true to retry the write after freeing space.
+   */
+  onQuotaExceeded?: (key: string, value: string) => boolean | Promise<boolean>;
+}
+/**
+ * Retrieves the singleton instance of the LocalStorage service.
+ *
+ * If the instance does not already exist, it is created.
+ */
+declare function getLocalStorage(): ReactiveStorage;
+declare function getSessionStorage(): ReactiveStorage;
+declare function getCacheStorage(namespace?: string | null): ReactiveStorage;
+/**
+ * Configure options for the localStorage singleton.
+ * Must be called before getLocalStorage() is first invoked.
+ */
+declare function configureLocalStorage(options: ReactiveStorageOptions): void;
+/**
+ * Configure options for the sessionStorage singleton.
+ * Must be called before getSessionStorage() is first invoked.
+ */
+declare function configureSessionStorage(options: ReactiveStorageOptions): void;
+type EffectStorageEvent = CacheStorageEvent | StorageEvent;
+declare global {
+  interface WindowEventMap {
+    storage: CustomEvent<CacheStorageEvent> | StorageEvent;
+  }
+}
+/**
+ * A reactive wrapper around the Web Storage API (localStorage/sessionStorage)
+ * that provides signal-based access to storage items and length.
+ *
+ * Will automatically update when storage events occur in other tabs/windows.
+ */
+declare class ReactiveStorage implements Storage {
+  private _storage;
+  private _options;
+  private _memoryOnly;
+  private _values;
+  private _signals;
+  private _length;
+  private _effects;
+  setEffect(key: string, fn: (value: EffectStorageEvent) => void): void;
+  constructor(storage: Storage, options?: ReactiveStorageOptions);
+  /**
+   * Reactive access to the number of keys in Storage
+   */
+  get length(): number;
+  /**
+   * Non-reactive way to peek the current value of a key in Storage
+   */
+  peekItem(key: string): string | null;
+  /**
+   * Reactive access to Storage contents
+   */
+  getItem(key: string): string | null;
+  /**
+   * Set a value in Storage, triggering reactivity
+   */
+  setItem(key: string, value: string): void;
+  /**
+   * Remove a value from Storage, triggering reactivity
+   */
+  removeItem(key: string): void;
+  /**
+   * Clears all keys from Storage, triggering reactivity
+   */
+  clear(): void;
+  /**
+   * Reactive access to the key at the given index
+   */
+  key(index: number): string | null;
+}
+//#endregion
+//#region src/storage/-private/storage-infra.d.ts
+/**
+ * Configuration options for fields that are also query parameters
+ */
+interface ParamConfig {
+  /**
+   * Convert a value into a string for storage in the URL.
+   * `null` indicates the value should be omitted from the URL.
+   */
+  serialize: (value: unknown, instance: any) => string | null;
+  /**
+   * Convert a string value from the URL back into
+   * its original type
+   */
+  deserialize: (urlValue: string, instance: any) => unknown;
+  /**
+   * Get the default value for this param from the given instance.
+   *
+   * If not present, the value passed to the field initializer
+   * will be used as the default.
+   *
+   * This should return the value in the field's native type,
+   * not the serialized URL form.
+   */
+  getDefault?: (instance: any) => unknown;
+}
+interface InternalParamConfig extends ParamConfig {
+  initialized?: boolean;
+}
+interface ValueTransition<T = unknown> {
+  key: string;
+  from: T;
+  to: T;
+}
+/**
+ * Metadata attached to persisted resource classes
+ */
+interface StorageResourceMeta {
+  id: string;
+  namespace: string | null;
+  pkFn: KeyFn | null;
+  type: "local-resource" | "session-resource" | "cache-resource";
+  typeOverrides: Map<string, "local-storage" | "session-storage" | "cache-storage"> | null;
+  fields: Map<string, null | ((update: ValueTransition<string>) => void)>;
+  initializers: Map<string, (() => unknown) | null>;
+  paramConfigs: Map<string, InternalParamConfig> | null;
+  paramCompanion: object | null;
+  instances: WeakMap<object, StorageResourceMeta> | null;
+}
+/**
+ * A function which generates a unique primary-key
+ * string for a given LocalResource or SessionResource
+ * instance.
+ *
+ * Use functions when you want to create more than
+ * one instance of a resource type, each with its own
+ * persisted data.
+ */
+type KeyFn = (obj: any) => string;
+/**
+ * Setup persisted resource metadata on target
+ * if not already present
+ *
+ * @private
+ */
+declare function initMeta(target: object): StorageResourceMeta;
+/**
+ * Get or create the param companion object for a StorageResource instance.
+ *
+ * The companion object contains URL-serialized versions of all @param decorated fields.
+ * Each param field gets a corresponding property on the companion that:
+ * - Reads: Serializes the storage value to a URL string (returns null if not active)
+ * - Writes: Deserializes the URL string and updates the storage value
+ *
+ * The companion object is reactive using trackedObject, ensuring that changes
+ * to the underlying storage fields trigger updates in the query param system.
+ *
+ * This companion object is what QPRoute will bind to for URL query params.
+ *
+ * @private
+ * @param instance - The StorageResource instance
+ * @param groupControlMap - Optional map of fieldName -> controlFieldName for grouped params
+ * @returns The companion object with serialized param properties
+ */
+declare function getParamCompanion(instance: object, groupControlMap?: Record<string, string>): object;
+//#endregion
+//#region src/storage/storage-resource.d.ts
+/**
+ * Decorator which transforms a class into a StorageResource
+ * persisted in localStorage.
+ *
+ * LocalResources must either be singletons or expect all instances
+ * to share state unless a primary key function is provided.
+ *
+ * When a primary key function is provided, each instance
+ * will have its own persisted data based on the key generated
+ * by the function.
+ *
+ * The function will be called once per instance during
+ * initialization to determine the unique ID for that instance.
+ */
+declare function LocalResource(id: string | KeyFn): ClassDecorator;
+/**
+ * Decorator which transforms a class into a StorageResource
+ * persisted in sessionStorage.
+ *
+ * SessionResources must either be singletons or expect all instances
+ * to share state unless a primary key function is provided.
+ *
+ * When a primary key function is provided, each instance
+ * will have its own persisted data based on the key generated
+ * by the function.
+ *
+ * The function will be called once per instance during
+ * initialization to determine the unique ID for that instance.
+ */
+declare function SessionResource(id: string | KeyFn): ClassDecorator;
+/**
+ * Decorator which transforms a class into a StorageResource
+ * persisted via the [Cache API](https://developer.mozilla.org/en-US/docs/Web/API/Cache).
+ * api and shared across all tabs/windows under the same origin.
+ *
+ * CacheResources must either be singletons or expect all instances
+ * to share state unless a primary key function is provided.
+ *
+ * When a primary key function is provided, each instance
+ * will have its own persisted data based on the key generated
+ * by the function.
+ *
+ * The function will be called once per instance during
+ * initialization to determine the unique ID for that instance.
+ *
+ * All object cached in the same `namespace` share the namespace's storage context,
+ * so partitioning can be achieved by using different namespaces for different groups
+ * of data.
+ */
+declare function CacheResource(id: string | KeyFn, namespace?: string | null): ClassDecorator;
+/**
+ * Decorator which marks a property as a field on
+ * a LocalResource or SessionResource
+ *
+ * The field's value will be initialized from the persisted resource data
+ * if available, falling back to the property's default value otherwise.
+ *
+ * Fields can be of any type that is serializable to and restorable from JSON,
+ * but complex types (like objects or arrays) should be handled with care to avoid
+ * unintended mutations or reactivity issues.
+ *
+ * By default, fields are persisted in the storage type defined by the resource decorator
+ * (@LocalResource or @SessionResource). However, you can override this behavior
+ * by passing 'local' or 'session' as an argument to the decorator.
+ *
+ * ---
+ *
+ * **Example:**
+ *
+ * ```ts
+ * @LocalResource('user-settings')
+ * class UserSettings {
+ *   @field
+ *   theme: 'light' | 'dark' = 'light';
+ *
+ *   @field('session')
+ *   sessionToken: string | null = null;
+ * }
+ * ```
+ *
+ */
+declare function field(type: "local" | "session" | "cache"): PropertyDecorator;
+declare function field(target: object, key: string, descriptor?: PropertyDescriptor): void;
+declare function input(type: "number" | "boolean" | "float"): PropertyDecorator;
+/**
+ * Effects are fields that run a side-effecting function.
+ *
+ * Effects are intended to enable synchronizing get states between
+ * tabs or windows that result in needing to synchronize other
+ * non-reactive state.
+ *
+ * For example, when a user selects a light/dark mode theme preference
+ * that differs from the system preference, effects can be used to trigger
+ * DOM updates on the documentElement necessary to ensure its state is
+ * consistent with the persisted resource state and reactive application state.
+ *
+ * To do this without an effect would require either setting up your own
+ * storage event listeners or consuming the reactive state of the property
+ * in another effect-like API such as an Ember modifier or React useEffect,
+ *
+ * Effects *only* run when the stored value changes due to storage events
+ * emitted from other tabs or windows. They do not run when the property
+ * is updated in the same context.
+ *
+ * ---
+ *
+ * **Example:**
+ *
+ * ```ts
+ * @LocalResource('user-preferences')
+ * class UserPreferences {
+ *   @effect(syncThemeToDOM)
+ *   explicitThemePreference: 'light' | 'dark' | null = null;
+ *
+ *   @matchMedia('(prefers-color-scheme: dark)')
+ *   systemPrefersDarkMode: boolean = false;
+ * }
+ *
+ * function syncThemeToDOM(update: ValueTransition<'light' | 'dark' | null>): void {
+ *   const newTheme = update.to;
+ *   document.documentElement.style.colorScheme = newTheme ?? 'light dark';
+ *
+ *   if (newTheme === 'dark') {
+ *     document.documentElement.classList.add('dark-theme');
+ *     document.documentElement.classList.remove('light-theme');
+ *   } else if (newTheme === 'light') {
+ *     document.documentElement.classList.add('light-theme');
+ *     document.documentElement.classList.remove('dark-theme');
+ *   } else {
+ *     document.documentElement.classList.remove('light-theme');
+ *     document.documentElement.classList.remove('dark-theme');
+ *   }
+ * }
+ * ```
+ */
+declare function effect(fn: <K>(update: ValueTransition<K>) => void, type?: "local" | "session"): PropertyDecorator;
+//#endregion
+export { CacheResource, CacheStorage, CacheStorageEvent, DEFAULT_CACHE_ID, EffectStorageEvent, InternalCacheStorageEvent, LocalResource, type ReactiveStorage, ReactiveStorageOptions, SessionResource, getParamCompanion as _getParamCompanion, initMeta as _initMeta, configureLocalStorage, configureSessionStorage, effect, field, getCacheStorage, getLocalStorage, getSessionStorage, input };
+//# sourceMappingURL=storage.d.ts.map

package/declarations/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","names":[],"sources":["../src/storage/cache.ts","../src/storage/storage.ts","../src/storage/-private/storage-infra.ts","../src/storage/storage-resource.ts"],"mappings":";cAEa;UAKI;EACf;EACA;EACA;EACA;;UAEe;EACf,aAAa;EACb;EACA;EACA;;;;;;;;cAkEW,wBAAwB;;EAInC,OAAO;EACP;EACA,iBAAiB;EAYjB,YAAY;MAMR;EA4BJ;EAKA,QAAQ;EAIR,IAAI;EAgBJ,WAAW;EAQX,QAAQ,aAAa;;;;;SAed,IAAI,mBAAqC,QAAQ;SASjD,YAAY,mBAAqC;;;;;SAYjD;;;;UCtMQ;;;;;EAKf;;;;;EAMA;;;;;EAMA,mBAAmB,aAAa,4BAA4B;;;;;;;iBAgB9C,mBAAmB;iBAOnB,qBAAqB;iBAQrB,gBAAgB,4BAAkC;;;;;iBAelD,sBAAsB,SAAS;;;;;iBAQ/B,wBAAwB,SAAS;KA8BrC,qBAAqB,oBAAoB;QAEtC;YACH;IACR,SAAS,YAAY,qBAAqB;;;;;;;;;cAUxC,2BAA2B;UACvB;UACA;UACA;UACA;UAEQ;UACA;UAER;EACR,UAAU,aAAa,KAAK,OAAO;EAKnC,YAAY,SAAS,SAAS,UAAS;;;;MA2CnC;;;;EAOJ,SAAS;;;;EAsBT,QAAQ;;;;EAyBR,QAAQ,aAAa;;;;EA2DrB,WAAW;;;;EAsBX;;;;EAeA,IAAI;;;;;;;UCjUW;;;;;EAMf,YAAY,gBAAgB;;;;;EAM5B,cAAc,kBAAkB;;;;;;;;;;EAWhC,cAAc;;UAGN,4BAA4B;EACpC;;UAGe,gBAAgB;EAC/B;EACA,MAAM;EACN,IAAI;;;;;UAMW;EACf;EACA;EACA,MAAM;EACN;EACA,eAAe;EACf,QAAQ,qBAAqB,QAAQ;EACrC,cAAc;EACd,cAAc,YAAY;EAC1B;EACA,WAAW,gBAAgB;;;;;;;;;;;KAajB,SAAS;;;;;;;iBAaL,SAAS,iBAAiB;;;;;;;;;;;;;;;;;;;iBAiT1B,kBAAkB,kBAAkB,kBAAkB;;;;;;;;;;;;;;;;;iBCxWtD,cAAc,aAAa,QAAQ;;;;;;;;;;;;;;;iBAkBnC,gBAAgB,aAAa,QAAQ;;;;;;;;;;;;;;;;;;;;iBAuBrC,cAAc,aAAa,OAAO,4BAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmCpE,MAAM,sCAAsC;iBAC5C,MAAM,gBAAgB,aAAa,aAAa;iBAgBhD,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoF7C,OAAO,KAAK,GAAG,QAAQ,gBAAgB,aAAa,6BAA6B"}

package/declarations/types-CRs-Qww6.d.ts

@@ -0,0 +1,17 @@
+import { RequestInfo } from "@warp-drive/core/types/request";
+//#region src/data-worker/types.d.ts
+type RequestEventData = {
+  type: "request";
+  thread: string;
+  id: number;
+  data: RequestInfo;
+};
+type AbortEventData = {
+  type: "abort";
+  thread: string;
+  id: number;
+  data: string;
+};
+//#endregion
+export { RequestEventData as n, AbortEventData as t };
+//# sourceMappingURL=types-CRs-Qww6.d.ts.map

package/declarations/types-CRs-Qww6.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-CRs-Qww6.d.ts","names":[],"sources":["../src/data-worker/types.ts"],"mappings":";;KAeY;EACV;EACA;EACA;EACA,MAAM;;KAGI;EACV;EACA;EACA;EACA"}