@warp-drive-mirror/core 5.9.0-alpha.2 → 5.9.0-alpha.21

package/declarations/types/utils.d.ts

@@ -1,5 +1,2 @@
-export type WithPartial<
-	T,
-	K extends keyof T
-> = Omit<T, K> & Partial<Pick<T, K>>;
-export type Mutable<T> = { -readonly [P in keyof T] : T[P] };
+import { n as WithPartial, t as Mutable } from "../utils-BtURiy8l.js";
+export { Mutable, WithPartial };

package/declarations/types.d.ts

@@ -1,11 +1,3 @@
-/**
-* This package provides core types, type-utilities, symbols
-* and constants used across the WarpDrive ecosystem.
-*
-* @module
-*/
-export type { StableRecordIdentifier, ResourceKey } from "./types/identifier.js";
-export type { CacheCapabilitiesManager } from "./store/-types/q/cache-capabilities-manager.js";
-export type { ModelSchema } from "./store/deprecated/-private.js";
-export type { SchemaService } from "./types/schema/schema-service.js";
-export type { BaseFinderOptions, FindRecordOptions, LegacyResourceQuery, QueryOptions, FindAllOptions } from "./store/-types/q/store.js";
+import { f as StableRecordIdentifier, l as ResourceKey } from "./identifier-DyEvjMjb.js";
+import { Gt as FindAllOptions, Jt as QueryOptions, Kn as SchemaService, Kt as FindRecordOptions, Wt as BaseFinderOptions, Xt as CacheCapabilitiesManager, Yt as ModelSchema, qt as LegacyResourceQuery } from "./internal-DMxLqCZa.js";
+export type { BaseFinderOptions, CacheCapabilitiesManager, FindAllOptions, FindRecordOptions, LegacyResourceQuery, ModelSchema, QueryOptions, ResourceKey, SchemaService, StableRecordIdentifier };

package/declarations/utils/string.d.ts

@@ -1,47 +1,54 @@
+//#region src/utils/string.d.ts
 /**
-* An LRUCache implementation with upsert semantics.
-*
-* This implementation is *not* generic, but focuses on
-* performance tuning for the string transformation cases
-* where the key maps to the value very simply.
-*
-* It takes a work function that should generate a new value
-* for a given key when called. It will be called when the key
-* is not found in the cache.
-*
-* It keeps track of the number of hits, misses, and ejections
-* in DEBUG envs, which is useful for tuning the cache size.
-*
-* This is an internal utility class for use by this module
-* and by `@warp-drive-mirror/utilities/string`. It is not intended
-* for use outside of these modules at this time.
-*
-* @private
-*/
-export declare class LRUCache<
-	T,
-	V
-> {
-	size: number;
-	state: Map<T, V>;
-	doWork: (k: T) => V;
-	_hits: number;
-	_misses: number;
-	_ejected: number;
-	constructor(doWork: (k: T) => V, size?: number);
-	get(key: T): V;
-	set(key: T, value: V): void;
-	clear(): void;
+ * An LRUCache implementation with upsert semantics.
+ *
+ * This implementation is *not* generic, but focuses on
+ * performance tuning for the string transformation cases
+ * where the key maps to the value very simply.
+ *
+ * It takes a work function that should generate a new value
+ * for a given key when called. It will be called when the key
+ * is not found in the cache.
+ *
+ * It keeps track of the number of hits, misses, and ejections
+ * in DEBUG envs, which is useful for tuning the cache size.
+ *
+ * This is an internal utility class for use by this module
+ * and by `@warp-drive-mirror/utilities/string`. It is not intended
+ * for use outside of these modules at this time.
+ *
+ * @private
+ */
+declare class LRUCache<T, V> {
+  size: number;
+  state: Map<T, V>;
+  doWork: (k: T) => V;
+  _hits: number;
+  _misses: number;
+  _ejected: number;
+  constructor(doWork: (k: T) => V, size?: number);
+  get(key: T): V;
+  set(key: T, value: V): void;
+  clear(): void;
 }
-export declare const STRING_DASHERIZE_CACHE: LRUCache<string, string>;
 /**
-* This is an internal utility function that converts a string
-* to a dasherized format. Library consumers should use the
-* re-exported version from `@warp-drive-mirror/utilities/string` instead.
-*
-* This version is only in this location to support a deprecated
-* behavior in the core package and will be removed in a future.
-*
-* @private
-*/
-export declare function dasherize(str: string): string;
+ * The {@link LRUCache} backing {@link dasherize}, keyed by the original
+ * (un-dasherized) string.
+ *
+ * @private
+ */
+declare const STRING_DASHERIZE_CACHE: LRUCache<string, string>;
+/**
+ * This is an internal utility function that converts a string
+ * to a dasherized format. Library consumers should use the
+ * re-exported version from `@warp-drive-mirror/utilities/string` instead.
+ *
+ * This version is only in this location to support a deprecated
+ * behavior in the core package and will be removed in a future.
+ *
+ * @private
+ */
+declare function dasherize(str: string): string;
+//#endregion
+export { LRUCache, STRING_DASHERIZE_CACHE, dasherize };
+//# sourceMappingURL=string.d.ts.map

package/declarations/utils/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","names":[],"sources":["../../src/utils/string.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;cAwBa,SAAS,GAAG;EACvB;EACA,OAAe,IAAI,GAAG;EACtB,SAAiB,GAAG,MAAM;EAG1B;EACA;EACA;EAEA,YAAY,SAAS,GAAG,MAAM,GAAG;EAYjC,IAAI,KAAK,IAAI;EAmBb,IAAI,KAAK,GAAG,OAAO;EAanB;;;;;;;;cAkBW,wBAAwB;;;;;;;;;;;iBAcrB,UAAU"}

package/declarations/utils-BtURiy8l.d.ts

@@ -0,0 +1,24 @@
+//#region src/types/utils.d.ts
+/**
+ * Makes the properties named in `K` optional on `T`, leaving the rest as-is.
+ *
+ * @example
+ * ```ts
+ * interface User { id: string; name: string; }
+ * type PartialName = WithPartial<User, 'name'>; // { id: string; name?: string }
+ * ```
+ */
+type WithPartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+/**
+ * Removes `readonly` from every property of `T`.
+ *
+ * @example
+ * ```ts
+ * interface Config { readonly host: string; }
+ * type MutableConfig = Mutable<Config>; // { host: string }
+ * ```
+ */
+type Mutable<T> = { -readonly [P in keyof T]: T[P]; };
+//#endregion
+export { WithPartial as n, Mutable as t };
+//# sourceMappingURL=utils-BtURiy8l.d.ts.map

package/declarations/utils-BtURiy8l.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-BtURiy8l.d.ts","names":[],"sources":["../src/types/utils.ts"],"mappings":";;;;;;;;;;KASY,YAAY,GAAG,gBAAgB,KAAK,KAAK,GAAG,KAAK,QAAQ,KAAK,GAAG;;;;;;;;;;KAWjE,QAAQ,kBAAkB,WAAW,IAAI,EAAE"}

package/dist/-private-D4dQm2VC.js

@@ -0,0 +1,22 @@
+import { t as getOrSetGlobal } from "./-private-DYCb3vir.js";
+
+//#region src/reactive/-private/symbols.ts
+const SOURCE = getOrSetGlobal("SOURCE", Symbol("#source"));
+const Destroy = getOrSetGlobal("Destroy", Symbol.dispose || Symbol.for("Dispose"));
+/**
+* Symbol for the method used to request a mutable copy of an otherwise
+* immutable {@link ReactiveResource}.
+*
+* @deprecated use the {@link checkout} utility function instead.
+*/
+const Checkout = getOrSetGlobal("Checkout", Symbol("Checkout"));
+const Commit = getOrSetGlobal("Commit", Symbol("Commit"));
+/**
+* Symbol used to stash the internal field/resource context (schema, store,
+* mutability, etc.) on a {@link ReactiveResource} or reactive field instance.
+*/
+const Context = getOrSetGlobal("Context", Symbol("Context"));
+
+//#endregion
+export { SOURCE as a, Destroy as i, Commit as n, Context as r, Checkout as t };
+//# sourceMappingURL=-private-D4dQm2VC.js.map

package/dist/-private-D4dQm2VC.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"-private-D4dQm2VC.js","names":["getOrSetGlobal","SOURCE","Symbol","Destroy","dispose","for","Checkout","Commit","Context"],"sources":["../src/reactive/-private/symbols.ts"],"sourcesContent":["///////////////////\n///// WARNING /////\n///////////////////\n\nimport { getOrSetGlobal } from '../../types/-private';\n\n// Great, got your attention with that warning didn't we?\n// Good. Here's the deal: typescript treats symbols as unique types.\n// If by accident a module creating a symbol is processed more than\n// once, the symbol will be different in each processing. This will\n// cause a type error.\n// It could also cause a runtime error if the symbol is used innapropriately.\n// However, this case is extremely hard to hit and would require other things\n// to go wrong first.\n//\n// So, why do the warning? And why do we lie about the types of the symbols?\n//\n// Because we intentionally create multiple copies of them within the types\n// at build time. This is because we rollup our d.ts files in order to give\n// our consumers a better experience.\n//\n// However, no tool today supports rolling up d.ts files with multiple entry\n// points correctly. The tool we use currently (vite-plugin-dts) uses @microsoft/api-extractor\n// which creates a fully unique stand-alone types file per-entry-point. Thus\n// every entry point that uses one of these symbols somewhere will have accidentally\n// created a new symbol type.\n//\n// This cast allows us to rollup these types using this tool while not encountering\n// the unique symbol type issue.\n//\n// Note that none of these symbols are part of the public API, these are used for\n// debugging DX and as a safe way to provide an intimate contract on public objects.\n\nexport const SOURCE: '___(unique) Symbol(SOURCE)' = getOrSetGlobal('SOURCE', Symbol('#source'));\n\nexport const Destroy: '___(unique) Symbol(Destroy)' = getOrSetGlobal(\n  'Destroy',\n  Symbol.dispose || Symbol.for('Dispose')\n);\n/**\n * Symbol for the method used to request a mutable copy of an otherwise\n * immutable {@link ReactiveResource}.\n *\n * @deprecated use the {@link checkout} utility function instead.\n */\nexport const Checkout: '___(unique) Symbol(Checkout)' = getOrSetGlobal('Checkout', Symbol('Checkout'));\nexport const Commit: '___(unique) Symbol(Commit)' = getOrSetGlobal('Commit', Symbol('Commit'));\n\n/**\n * Symbol used to stash the internal field/resource context (schema, store,\n * mutability, etc.) on a {@link ReactiveResource} or reactive field instance.\n */\nexport const Context: '___(unique) Symbol(Context)' = getOrSetGlobal('Context', Symbol('Context'));\n"],"mappings":";;;AAiCA,MAAaC,SAAuCD,eAAe,UAAUE,OAAO,SAAS,CAAC;AAE9F,MAAaC,UAAyCH,eACpD,WACAE,OAAOE,WAAWF,OAAOG,IAAI,SAAS,CACxC;;;;;;;AAOA,MAAaC,WAA2CN,eAAe,YAAYE,OAAO,UAAU,CAAC;AACrG,MAAaK,SAAuCP,eAAe,UAAUE,OAAO,QAAQ,CAAC;;;;;AAM7F,MAAaM,UAAyCR,eAAe,WAAWE,OAAO,SAAS,CAAC"}