@cocoar/vue-calendar 1.18.0 → 2.0.0

package/dist/core/recurrence.d.ts

@@ -1,112 +0,0 @@
-/**
- * Recurrence engine — main-thread API.
- *
- * Two paths sharing one request/response shape:
- *
- *   - `expandSync`  — runs `rrule-rust` in the calling thread.
- *                     Cheapest for small workloads (single rule,
- *                     one-shot expansion). Blocks the main thread.
- *
- *   - `expandAsync` — dispatches to a long-lived worker. Cheapest
- *                     for large workloads where main-thread blocking
- *                     would jank the UI. Pays a postMessage round-
- *                     trip (~ 1-2 ms) on top of the actual expansion.
- *
- * Spike E benchmarks both at four scales (W1-W4) and locks the
- * auto-dispatch threshold — when does the worker round-trip beat
- * in-thread? Per Spike B's measurements (`rrule-rust` warm path =
- * 0.6 ms / expansion), the in-thread cost is much lower than the
- * spike-plan hypothesis suggested, so the auto-dispatch threshold
- * lands at higher series counts than originally estimated.
- *
- * Wire format is the same in both modes; consumers swap engines by
- * choosing which function to call. A higher-level
- * `<CoarCalendar :recurrence-engine="...">` prop in Phase 1 will
- * pick automatically based on `series.length` against the locked
- * threshold.
- */
-export interface RecurrenceRequest {
-    rules: ReadonlyArray<{
-        seriesId: string;
-        rruleString: string;
-    }>;
-    /** Window start as unix-ms (absolute timestamp). */
-    windowStart: number;
-    /** Window end as unix-ms (absolute timestamp), exclusive-ish. */
-    windowEnd: number;
-}
-export interface RecurrenceRuleResult {
-    seriesId: string;
-    /** Unix-ms timestamps of every occurrence inside the window. */
-    timestamps: Float64Array;
-}
-export interface RecurrenceResponse {
-    results: RecurrenceRuleResult[];
-    /** Time spent in actual expansion (ms). Excludes worker round-trip. */
-    expansionMs: number;
-    /** Per-rule errors; empty on full success. */
-    errors: Array<{
-        seriesId: string;
-        message: string;
-    }>;
-}
-/**
- * Synchronous in-thread expansion. Runs in the caller's thread; for
- * large workloads (≥ threshold), prefer `expandAsync`.
- */
-export declare function expandSync(req: RecurrenceRequest): RecurrenceResponse;
-/**
- * Asynchronous expansion via a long-lived worker. The worker is
- * lazily created on first use and reused for the lifetime of the
- * page. Cold-start (~ 175 ms WASM init) hits the first call; warm
- * calls cost ~ 1-2 ms postMessage round-trip plus the expansion
- * time.
- */
-export declare function expandAsync(req: RecurrenceRequest): Promise<RecurrenceResponse>;
-/**
- * Tear down the worker. Useful for tests or for apps that know
- * recurrence won't be needed any more.
- */
-export declare function shutdownRecurrenceWorker(): void;
-export interface RecurrenceEngine {
-    /**
-     * Expand a batch of recurring rules over a window. The engine
-     * decides whether to run sync (in-thread) or async (worker)
-     * per-call; consumers always await regardless.
-     */
-    expand(request: RecurrenceRequest): Promise<RecurrenceResponse>;
-}
-export interface DefaultRecurrenceEngineOptions {
-    /**
-     * Auto-dispatch threshold. Rules >= threshold → worker. Default
-     * 200, locked empirically in Phase 0 Spike E (W1 sync stays
-     * under one frame, W2+ blocks UI).
-     */
-    threshold?: number;
-}
-/**
- * Default engine: rrule-rust with auto-dispatch at the locked
- * threshold (200 rules by default, configurable).
- */
-export declare class DefaultRecurrenceEngine implements RecurrenceEngine {
-    private threshold;
-    constructor(opts?: DefaultRecurrenceEngineOptions);
-    expand(request: RecurrenceRequest): Promise<RecurrenceResponse>;
-}
-/**
- * Forces every expansion through the synchronous in-thread path.
- * Useful for tests (no worker setup) and SSR (no Worker API).
- */
-export declare class SyncOnlyRecurrenceEngine implements RecurrenceEngine {
-    expand(request: RecurrenceRequest): Promise<RecurrenceResponse>;
-}
-/**
- * Forces every expansion through the worker. Useful for diagnostic
- * purposes — never blocks the main thread, even for tiny inputs.
- * Production consumers should prefer `DefaultRecurrenceEngine` so
- * the small-batch fast path stays sync.
- */
-export declare class WorkerOnlyRecurrenceEngine implements RecurrenceEngine {
-    expand(request: RecurrenceRequest): Promise<RecurrenceResponse>;
-}
-//# sourceMappingURL=recurrence.d.ts.map

package/dist/core/recurrence.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"recurrence.d.ts","sourceRoot":"","sources":["../../src/core/recurrence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAQH,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,aAAa,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAChE,oDAAoD;IACpD,WAAW,EAAE,MAAM,CAAC;IACpB,iEAAiE;IACjE,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,gEAAgE;IAChE,UAAU,EAAE,YAAY,CAAC;CAC1B;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,oBAAoB,EAAE,CAAC;IAChC,uEAAuE;IACvE,WAAW,EAAE,MAAM,CAAC;IACpB,8CAA8C;IAC9C,MAAM,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACtD;AAgCD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,iBAAiB,GAAG,kBAAkB,CAErE;AAuCD;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAO/E;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAO/C;AAoBD,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;CACjE;AAED,MAAM,WAAW,8BAA8B;IAC7C;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,qBAAa,uBAAwB,YAAW,gBAAgB;IAC9D,OAAO,CAAC,SAAS,CAAS;gBAEd,IAAI,GAAE,8BAAmC;IAI/C,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAMtE;AAED;;;GAGG;AACH,qBAAa,wBAAyB,YAAW,gBAAgB;IACzD,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAGtE;AAED;;;;;GAKG;AACH,qBAAa,0BAA2B,YAAW,gBAAgB;IAC3D,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAGtE"}

package/dist/core/recurrenceWorker.d.ts

@@ -1,62 +0,0 @@
-/**
- * Recurrence expansion worker — runs `rrule-rust` off the main
- * thread. Imported via Vite's `?worker` syntax; only this file
- * actually executes in the worker context.
- *
- * The worker pays ~ 175 ms WASM init on first instantiation (per
- * Spike B browser cold-start measurement). Subsequent expansions
- * are sub-millisecond. The main thread keeps this worker alive for
- * the lifetime of the calendar; warm-path expansions cost only the
- * postMessage round-trip.
- *
- * Wire format (request → response):
- *
- *   self.postMessage({
- *     id: 7,
- *     rules: [{ seriesId: 'standup', rruleString: 'DTSTART:...\nRRULE:...' }, …],
- *     windowStart: 1717200000000,
- *     windowEnd:   1719792000000,
- *   });
- *
- *   self.onmessage = (e) => {
- *     // e.data: {
- *     //   id: 7,
- *     //   results: [{ seriesId, timestamps: Float64Array }, …],
- *     //   expansionMs: 0.6,
- *     //   errors: [{ seriesId, message }, …]  // empty on success
- *     // }
- *     // Transferred: the Float64Array buffers themselves.
- *   };
- *
- * Float64Array is a Transferable. Sending 7.000 timestamps as a
- * 56 KB ArrayBuffer is roughly free; structured-cloning the same
- * count of plain-object dates would cost milliseconds.
- */
-export interface RecurrenceRequest {
-    id: number;
-    rules: ReadonlyArray<{
-        seriesId: string;
-        rruleString: string;
-    }>;
-    windowStart: number;
-    windowEnd: number;
-}
-export interface RecurrenceRuleResult {
-    seriesId: string;
-    /**
-     * Unix-ms timestamps of every occurrence in the window. Always
-     * sent as a Float64Array whose `.buffer` is in the transferList.
-     */
-    timestamps: Float64Array;
-}
-export interface RecurrenceResponse {
-    id: number;
-    results: RecurrenceRuleResult[];
-    /** Worker-side time spent on actual expansion, in milliseconds. */
-    expansionMs: number;
-    errors: Array<{
-        seriesId: string;
-        message: string;
-    }>;
-}
-//# sourceMappingURL=recurrenceWorker.d.ts.map

package/dist/core/recurrenceWorker.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"recurrenceWorker.d.ts","sourceRoot":"","sources":["../../src/core/recurrenceWorker.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAIH,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,aAAa,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAChE,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,UAAU,EAAE,YAAY,CAAC;CAC1B;AAED,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,oBAAoB,EAAE,CAAC;IAChC,mEAAmE;IACnE,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACtD"}