joist-core 2.4.0-next.37 → 2.4.0-next.39

package/build/transitions.d.mts

@@ -8,7 +8,7 @@ import { Entity } from "./Entity.mjs";
  *
  * Omitting `from` or `to` matches any state. Guards never run on creation.
  */
-interface GuardTransitionMatch<V> {
+export interface GuardTransitionMatch<V> {
   from?: V | readonly V[];
   to?: V | readonly V[];
 }
@@ -17,7 +17,7 @@ interface GuardTransitionMatch<V> {
  *
  * Creating an entity with a matching `to` state also matches, unless `from` is set or `onCreate` is `false`.
  */
-interface OnTransitionMatch<V> extends GuardTransitionMatch<V> {
+export interface OnTransitionMatch<V> extends GuardTransitionMatch<V> {
   /**
    * Whether `addTransitionReaction` fires when an entity is created with a matching `to` state, defaults to `true`.
    *
@@ -29,44 +29,44 @@ interface OnTransitionMatch<V> extends GuardTransitionMatch<V> {
   phase?: "flush" | "commit";
 }
 /** Maps each state to the states it may transition to, i.e. `{ Draft: ["Open"], Open: ["Closed"] }`. */
-type TransitionTable<V extends PropertyKey> = Partial<Record<V, readonly V[]>>;
+export type TransitionTable<V extends PropertyKey> = Partial<Record<V, readonly V[]>>;
 /**
  * The transition a guard or reaction is handling, i.e. `{ from: "DRAFT", to: "OPEN" }`.
  *
  * Guards and callbacks run during reaction passes, after the assignment, so the entity may already be in a
  * later state. This tells them which transition they're handling. `from` is `undefined` for creation.
  */
-interface Transition<V> {
+export interface Transition<V> {
   from: V | undefined;
   to: V;
 }
 /** The "from" state of a just-created entity, because `undefined` can be a real field value. */
-declare const created: unique symbol;
+export declare const created: unique symbol;
 /** A single recorded transition of a field, with `from` as `created` for creation. */
-interface TransitionStep {
+export interface TransitionStep {
   from: unknown;
   to: unknown;
 }
 /** An `addTransitionRule` as registered in config, with its `match` still using accessors. */
-interface TransitionGuardConfig<T extends Entity = Entity> {
+export interface TransitionGuardConfig<T extends Entity = Entity> {
   match: GuardTransitionMatch<string>;
   run(entity: T, step: TransitionStep): MaybePromise<ValidationRuleResult>;
 }
 /** An `addTransitionReaction` as registered in config, with its `match` still using accessors. */
-interface TransitionCallbackConfig<T extends Entity = Entity, C = unknown> {
+export interface TransitionCallbackConfig<T extends Entity = Entity, C = unknown> {
   name: string;
   match: OnTransitionMatch<string>;
   run(entity: T, ctx: C, step: TransitionStep): MaybePromise<unknown>;
 }
 /** One field's `setTransitions`, `addTransitionRule`, and `addTransitionReaction` config on a single entity type. */
-interface FieldTransitionsConfig<T extends Entity = Entity, C = unknown> {
+export interface FieldTransitionsConfig<T extends Entity = Entity, C = unknown> {
   /** The `transitions` table, if any; subtypes add their own tables on their own configs. */
   table?: TransitionTable<string>;
   guards: TransitionGuardConfig<T>[];
   callbacks: TransitionCallbackConfig<T, C>[];
 }
 /** A `match` with accessors converted to codes, so it can be compared to recorded steps. */
-interface TransitionMatcher {
+export interface TransitionMatcher {
   /** The allowed previous states, or `undefined` for any state. */
   from: readonly unknown[] | undefined;
   /** The allowed new states, or `undefined` for any state. */
@@ -75,36 +75,35 @@ interface TransitionMatcher {
   onCreate: boolean;
 }
 /** A guard with its `match` converted to codes. */
-interface TransitionGuard {
+export interface TransitionGuard {
   matcher: TransitionMatcher;
   run(entity: Entity, step: TransitionStep): MaybePromise<ValidationRuleResult>;
 }
 /** A callback with its `match` converted to codes, dispatched only after its transition's guards pass. */
-interface TransitionCallback {
+export interface TransitionCallback {
   name: string;
   phase: "flush" | "commit";
   matcher: TransitionMatcher;
   run(entity: Entity, ctx: unknown, step: TransitionStep): MaybePromise<unknown>;
 }
 /** One field's transition config from an entity type and its base types, with accessors converted to codes. */
-interface FieldTransitions {
+export interface FieldTransitions {
   /** Each table maps a `from` code to its allowed `to` codes; every table must allow a change. */
   tables: ReadonlyMap<unknown, readonly unknown[]>[];
   guards: TransitionGuard[];
   callbacks: TransitionCallback[];
 }
 /** Converts an internal step to the `Transition` that guards and reactions receive. */
-declare function toTransition(step: TransitionStep): Transition<any>;
+export declare function toTransition(step: TransitionStep): Transition<any>;
 /**
  * Merges the transition config of `meta` and its base types by field, converting accessors to codes.
  *
  * This runs after boot, because the config is written before the enum metadata exists.
  */
-declare function buildFieldTransitions(meta: EntityMetadata): Map<string, FieldTransitions>;
+export declare function buildFieldTransitions(meta: EntityMetadata): Map<string, FieldTransitions>;
 /** Returns whether `step` matches `matcher`'s `from`, `to`, and `onCreate` settings. */
-declare function matchesTransition(matcher: TransitionMatcher, step: TransitionStep): boolean;
+export declare function matchesTransition(matcher: TransitionMatcher, step: TransitionStep): boolean;
 /** Uses the enum's display name in error messages when there is one, i.e. `Approved` instead of `APPROVED`. */
-declare function describeValue(meta: EntityMetadata, fieldName: string, value: unknown): string;
+export declare function describeValue(meta: EntityMetadata, fieldName: string, value: unknown): string;
 //#endregion
-export { FieldTransitions, FieldTransitionsConfig, GuardTransitionMatch, OnTransitionMatch, Transition, TransitionCallback, TransitionCallbackConfig, TransitionGuard, TransitionGuardConfig, TransitionMatcher, TransitionStep, TransitionTable, buildFieldTransitions, created, describeValue, matchesTransition, toTransition };
 //# sourceMappingURL=transitions.d.mts.map

package/build/transitions.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"transitions.d.mts","names":[],"sources":["../src/transitions.ts"],"mappings":";;;;;;;;;;UAUiB,qBAAqB;EACpC,OAAO,aAAa;EACpB,KAAK,aAAa;;;;;;;UAQH,kBAAkB,WAAW,qBAAqB;;;;;;;EAOjE;;EAEA;;;KAIU,gBAAgB,UAAU,eAAe,QAAQ,OAAO,YAAY;;;;;;;UAQ/D,WAAW;EAC1B,MAAM;EACN,IAAI;;;cAIO;;UAGI;EACf;EACA;;;UAIe,sBAAsB,UAAU,SAAS;EACxD,OAAO;EACP,IAAI,QAAQ,GAAG,MAAM,iBAAiB,aAAa;;;UAIpC,yBAAyB,UAAU,SAAS,QAAQ;EACnE;EACA,OAAO;EACP,IAAI,QAAQ,GAAG,KAAK,GAAG,MAAM,iBAAiB;;;UAI/B,uBAAuB,UAAU,SAAS,QAAQ;;EAEjE,QAAQ;EACR,QAAQ,sBAAsB;EAC9B,WAAW,yBAAyB,GAAG;;;UAIxB;;EAEf;;EAEA;;EAEA;;;UAIe;EACf,SAAS;EACT,IAAI,QAAQ,QAAQ,MAAM,iBAAiB,aAAa;;;UAIzC;EACf;EACA;EACA,SAAS;EACT,IAAI,QAAQ,QAAQ,cAAc,MAAM,iBAAiB;;;UAI1C;;EAEf,QAAQ;EACR,QAAQ;EACR,WAAW;;;iBAIG,aAAa,MAAM,iBAAiB;;;;;;iBASpC,sBAAsB,MAAM,iBAAiB,YAAY;;iBAoBzD,kBAAkB,SAAS,mBAAmB,MAAM;;iBAUpD,cAAc,MAAM,gBAAgB,mBAAmB"}
+{"version":3,"file":"transitions.d.mts","names":[],"sources":["../src/transitions.ts"],"mappings":";;;;;;;;;;iBAUiB,qBAAqB;EACpC,OAAO,aAAa;EACpB,KAAK,aAAa;;;;;;;iBAQH,kBAAkB,WAAW,qBAAqB;;;;;;;EAOjE;;EAEA;;;YAIU,gBAAgB,UAAU,eAAe,QAAQ,OAAO,YAAY;;;;;;;iBAQ/D,WAAW;EAC1B,MAAM;EACN,IAAI;;;qBAIO;;iBAGI;EACf;EACA;;;iBAIe,sBAAsB,UAAU,SAAS;EACxD,OAAO;EACP,IAAI,QAAQ,GAAG,MAAM,iBAAiB,aAAa;;;iBAIpC,yBAAyB,UAAU,SAAS,QAAQ;EACnE;EACA,OAAO;EACP,IAAI,QAAQ,GAAG,KAAK,GAAG,MAAM,iBAAiB;;;iBAI/B,uBAAuB,UAAU,SAAS,QAAQ;;EAEjE,QAAQ;EACR,QAAQ,sBAAsB;EAC9B,WAAW,yBAAyB,GAAG;;;iBAIxB;;EAEf;;EAEA;;EAEA;;;iBAIe;EACf,SAAS;EACT,IAAI,QAAQ,QAAQ,MAAM,iBAAiB,aAAa;;;iBAIzC;EACf;EACA;EACA,SAAS;EACT,IAAI,QAAQ,QAAQ,cAAc,MAAM,iBAAiB;;;iBAI1C;;EAEf,QAAQ;EACR,QAAQ;EACR,WAAW;;;wBAIG,aAAa,MAAM,iBAAiB;;;;;;wBASpC,sBAAsB,MAAM,iBAAiB,YAAY;;wBAoBzD,kBAAkB,SAAS,mBAAmB,MAAM;;wBAUpD,cAAc,MAAM,gBAAgB,mBAAmB"}

package/build/trusted.d.cts

@@ -1,8 +1,7 @@
 //#region src/trusted.d.ts
 /** Returns true if we're inside a trusted context, i.e. hooks, reactions, validations, or defaults. */
-declare function isInTrustedContext(): boolean;
+export declare function isInTrustedContext(): boolean;
 /** Runs the given function within a trusted context. */
-declare function runInTrustedContext<T>(fn: () => T): T;
+export declare function runInTrustedContext<T>(fn: () => T): T;
 //#endregion
-export { isInTrustedContext, runInTrustedContext };
 //# sourceMappingURL=trusted.d.cts.map

package/build/trusted.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"trusted.d.cts","names":[],"sources":["../src/trusted.ts"],"mappings":";;iBAKgB;;iBAKA,oBAAoB,GAAG,UAAU,IAAI"}
+{"version":3,"file":"trusted.d.cts","names":[],"sources":["../src/trusted.ts"],"mappings":";;wBAKgB;;wBAKA,oBAAoB,GAAG,UAAU,IAAI"}

package/build/trusted.d.mts

@@ -1,8 +1,7 @@
 //#region src/trusted.d.ts
 /** Returns true if we're inside a trusted context, i.e. hooks, reactions, validations, or defaults. */
-declare function isInTrustedContext(): boolean;
+export declare function isInTrustedContext(): boolean;
 /** Runs the given function within a trusted context. */
-declare function runInTrustedContext<T>(fn: () => T): T;
+export declare function runInTrustedContext<T>(fn: () => T): T;
 //#endregion
-export { isInTrustedContext, runInTrustedContext };
 //# sourceMappingURL=trusted.d.mts.map

package/build/trusted.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"trusted.d.mts","names":[],"sources":["../src/trusted.ts"],"mappings":";;iBAKgB;;iBAKA,oBAAoB,GAAG,UAAU,IAAI"}
+{"version":3,"file":"trusted.d.mts","names":[],"sources":["../src/trusted.ts"],"mappings":";;wBAKgB;;wBAKA,oBAAoB,GAAG,UAAU,IAAI"}

package/build/typeMap.d.cts

@@ -18,7 +18,7 @@ import { Entity } from "./Entity.cjs";
  *
  * Inspired by Tanstack Router, which uses a similar `declare module` approach.
  */
-interface TypeMap {}
+export interface TypeMap {}
 /**
  * Returns a key like `"Author"` or `"SmallPublisher"` for looking up types in the `TypeMap`.
  *
@@ -35,7 +35,7 @@ type TypeMapKey<T> = T extends {
   };
 } ? K : never;
 /** The literal type name of an entity, i.e. `"Author"` or `"SmallPublisher"`. */
-type TypeNameOf<T> = TypeMapKey<T>;
+export type TypeNameOf<T> = TypeMapKey<T>;
 /**
  * The literal type name of an entity's root type, i.e. `"Publisher"` for both `Publisher` and
  * `SmallPublisher`.
@@ -48,41 +48,41 @@ type TypeNameOf<T> = TypeMapKey<T>;
  * untracked key `string`, not `never`: `never` means "source-less" and also broke the comparability of
  * `Alias<T>` with `Alias<Entity>`.
  */
-type RootTypeNameOf<T> = T extends {
+export type RootTypeNameOf<T> = T extends {
   __type: {
     0: infer K extends string;
   };
 } ? K : string;
 /** A helper type to look up `U` in the `TypeMap` for a given entity type `T`. */
-type TypeMapEntry<T, U extends string> = TypeMapKey<T> extends (infer K) ? K extends keyof TypeMap ? U extends keyof TypeMap[K] ? TypeMap[K][U] : unknown : unknown : unknown;
+export type TypeMapEntry<T, U extends string> = TypeMapKey<T> extends (infer K) ? K extends keyof TypeMap ? U extends keyof TypeMap[K] ? TypeMap[K][U] : unknown : unknown : unknown;
 /** Return the `FooOpts` type for the given `Foo` entity. */
-type OptsOf<T> = TypeMapEntry<T, "optsType">;
+export type OptsOf<T> = TypeMapEntry<T, "optsType">;
 /** Return the `FooFields` type for the given `Foo` entity. */
-type FieldsOf<T> = TypeMapEntry<T, "fieldsType">;
+export type FieldsOf<T> = TypeMapEntry<T, "fieldsType">;
 /** Return the physical `FooColumns` type for the given `Foo` entity. */
-type ColumnsOf<T> = TypeMapEntry<T, "columnsType">;
+export type ColumnsOf<T> = TypeMapEntry<T, "columnsType">;
 /** Returns the inheritance strategy, or never for non-inherited entities. */
-type InheritanceTypeOf<T> = TypeMapEntry<T, "inheritanceType">;
-type OptIdsOf<T> = TypeMapEntry<T, "optIdsType">;
+export type InheritanceTypeOf<T> = TypeMapEntry<T, "inheritanceType">;
+export type OptIdsOf<T> = TypeMapEntry<T, "optIdsType">;
 /** Pulls the entity query type out of a given entity type T. */
-type FilterOf<T> = TypeMapEntry<T, "filterType">;
+export type FilterOf<T> = TypeMapEntry<T, "filterType">;
 /** Pulls the entity GraphQL query type out of a given entity type T. */
-type GraphQLFilterOf<T> = TypeMapEntry<T, "gqlFilterType">;
+export type GraphQLFilterOf<T> = TypeMapEntry<T, "gqlFilterType">;
 /** Pulls the entity order type out of a given entity type T. */
-type OrderOf<T> = TypeMapEntry<T, "orderType">;
+export type OrderOf<T> = TypeMapEntry<T, "orderType">;
 /** Returns the factory "extras" type, like `withDerivedField`. */
-type FactoryExtrasOf<T> = TypeMapEntry<T, "factoryExtrasType">;
+export type FactoryExtrasOf<T> = TypeMapEntry<T, "factoryExtrasType">;
 /**
  * Returns the opts of the entity's `newEntity` factory method, as exists in the actual file.
  *
  * This is because `FactoryOpts` is a set of defaults, but the user can customize it if they want.
  */
-type ActualFactoryOpts<T> = TypeMapEntry<T, "factoryOptsType">;
+export type ActualFactoryOpts<T> = TypeMapEntry<T, "factoryOptsType">;
 /** Return the `Foo` type for a given `Foo` entity constructor. */
-type EntityOf<C> = C extends (new (em: EntityManager, opts: any) => infer T) ? T : never;
+export type EntityOf<C> = C extends (new (em: EntityManager, opts: any) => infer T) ? T : never;
 type RelationsKeysOf<T> = { [K in keyof OptsOf<T>]: OptsOf<T>[K] extends Entity[] | undefined ? K : never; }[keyof OptsOf<T>];
 /** Return the Relation keys from `FooOpt` type, given a `Foo` entity */
-type RelationsOf<T extends Entity> = { [K in RelationsKeysOf<T>]: NonNullable<OptsOf<T>[K]>; };
+export type RelationsOf<T extends Entity> = { [K in RelationsKeysOf<T>]: NonNullable<OptsOf<T>[K]>; };
 //#endregion
-export { ActualFactoryOpts, ColumnsOf, EntityOf, FactoryExtrasOf, FieldsOf, FilterOf, GraphQLFilterOf, InheritanceTypeOf, OptIdsOf, OptsOf, OrderOf, RelationsOf, RootTypeNameOf, TypeMap, TypeMapEntry, TypeNameOf };
+export {};
 //# sourceMappingURL=typeMap.d.cts.map

package/build/typeMap.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"typeMap.d.cts","names":[],"sources":["../src/typeMap.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;UAoBiB;;;;;;;KAQZ,WAAW,KAAK;EAAY;IAAU,SAAS;;IAAQ,IAAI;EAAY;IAAU,SAAS;;IAAQ;;KAG3F,WAAW,KAAK,WAAW;;;;;;;;;;;;;KAc3B,eAAe,KAAK;EAAY;IAAU,SAAS;;IAAuB;;KAG1E,aAAa,GAAG,oBAC1B,WAAW,kBAAiB,KACxB,gBAAgB,UACd,gBAAgB,QAAQ,KACtB,QAAQ,GAAG;;KAMT,OAAO,KAAK,aAAa;;KAGzB,SAAS,KAAK,aAAa;;KAG3B,UAAU,KAAK,aAAa;;KAG5B,kBAAkB,KAAK,aAAa;KAEpC,SAAS,KAAK,aAAa;;KAG3B,SAAS,KAAK,aAAa;;KAG3B,gBAAgB,KAAK,aAAa;;KAGlC,QAAQ,KAAK,aAAa;;KAG1B,gBAAgB,KAAK,aAAa;;;;;;KAOlC,kBAAkB,KAAK,aAAa;;KAGpC,SAAS,KAAK,gBAAe,IAAI,eAAe,oBAAoB,KAAI;KAE/E,gBAAgB,QAClB,WAAW,OAAO,KAAK,OAAO,GAAG,WAAW,uBAAuB,mBAC9D,OAAO;;KAGH,YAAY,UAAU,aAC/B,KAAK,gBAAgB,KAAK,YAAY,OAAO,GAAG"}
+{"version":3,"file":"typeMap.d.cts","names":[],"sources":["../src/typeMap.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;iBAoBiB;;;;;;;KAQZ,WAAW,KAAK;EAAY;IAAU,SAAS;;IAAQ,IAAI;EAAY;IAAU,SAAS;;IAAQ;;YAG3F,WAAW,KAAK,WAAW;;;;;;;;;;;;;YAc3B,eAAe,KAAK;EAAY;IAAU,SAAS;;IAAuB;;YAG1E,aAAa,GAAG,oBAC1B,WAAW,kBAAiB,KACxB,gBAAgB,UACd,gBAAgB,QAAQ,KACtB,QAAQ,GAAG;;YAMT,OAAO,KAAK,aAAa;;YAGzB,SAAS,KAAK,aAAa;;YAG3B,UAAU,KAAK,aAAa;;YAG5B,kBAAkB,KAAK,aAAa;YAEpC,SAAS,KAAK,aAAa;;YAG3B,SAAS,KAAK,aAAa;;YAG3B,gBAAgB,KAAK,aAAa;;YAGlC,QAAQ,KAAK,aAAa;;YAG1B,gBAAgB,KAAK,aAAa;;;;;;YAOlC,kBAAkB,KAAK,aAAa;;YAGpC,SAAS,KAAK,gBAAe,IAAI,eAAe,oBAAoB,KAAI;KAE/E,gBAAgB,QAClB,WAAW,OAAO,KAAK,OAAO,GAAG,WAAW,uBAAuB,mBAC9D,OAAO;;YAGH,YAAY,UAAU,aAC/B,KAAK,gBAAgB,KAAK,YAAY,OAAO,GAAG"}

package/build/typeMap.d.mts

@@ -18,7 +18,7 @@ import { Entity } from "./Entity.mjs";
  *
  * Inspired by Tanstack Router, which uses a similar `declare module` approach.
  */
-interface TypeMap {}
+export interface TypeMap {}
 /**
  * Returns a key like `"Author"` or `"SmallPublisher"` for looking up types in the `TypeMap`.
  *
@@ -35,7 +35,7 @@ type TypeMapKey<T> = T extends {
   };
 } ? K : never;
 /** The literal type name of an entity, i.e. `"Author"` or `"SmallPublisher"`. */
-type TypeNameOf<T> = TypeMapKey<T>;
+export type TypeNameOf<T> = TypeMapKey<T>;
 /**
  * The literal type name of an entity's root type, i.e. `"Publisher"` for both `Publisher` and
  * `SmallPublisher`.
@@ -48,41 +48,41 @@ type TypeNameOf<T> = TypeMapKey<T>;
  * untracked key `string`, not `never`: `never` means "source-less" and also broke the comparability of
  * `Alias<T>` with `Alias<Entity>`.
  */
-type RootTypeNameOf<T> = T extends {
+export type RootTypeNameOf<T> = T extends {
   __type: {
     0: infer K extends string;
   };
 } ? K : string;
 /** A helper type to look up `U` in the `TypeMap` for a given entity type `T`. */
-type TypeMapEntry<T, U extends string> = TypeMapKey<T> extends (infer K) ? K extends keyof TypeMap ? U extends keyof TypeMap[K] ? TypeMap[K][U] : unknown : unknown : unknown;
+export type TypeMapEntry<T, U extends string> = TypeMapKey<T> extends (infer K) ? K extends keyof TypeMap ? U extends keyof TypeMap[K] ? TypeMap[K][U] : unknown : unknown : unknown;
 /** Return the `FooOpts` type for the given `Foo` entity. */
-type OptsOf<T> = TypeMapEntry<T, "optsType">;
+export type OptsOf<T> = TypeMapEntry<T, "optsType">;
 /** Return the `FooFields` type for the given `Foo` entity. */
-type FieldsOf<T> = TypeMapEntry<T, "fieldsType">;
+export type FieldsOf<T> = TypeMapEntry<T, "fieldsType">;
 /** Return the physical `FooColumns` type for the given `Foo` entity. */
-type ColumnsOf<T> = TypeMapEntry<T, "columnsType">;
+export type ColumnsOf<T> = TypeMapEntry<T, "columnsType">;
 /** Returns the inheritance strategy, or never for non-inherited entities. */
-type InheritanceTypeOf<T> = TypeMapEntry<T, "inheritanceType">;
-type OptIdsOf<T> = TypeMapEntry<T, "optIdsType">;
+export type InheritanceTypeOf<T> = TypeMapEntry<T, "inheritanceType">;
+export type OptIdsOf<T> = TypeMapEntry<T, "optIdsType">;
 /** Pulls the entity query type out of a given entity type T. */
-type FilterOf<T> = TypeMapEntry<T, "filterType">;
+export type FilterOf<T> = TypeMapEntry<T, "filterType">;
 /** Pulls the entity GraphQL query type out of a given entity type T. */
-type GraphQLFilterOf<T> = TypeMapEntry<T, "gqlFilterType">;
+export type GraphQLFilterOf<T> = TypeMapEntry<T, "gqlFilterType">;
 /** Pulls the entity order type out of a given entity type T. */
-type OrderOf<T> = TypeMapEntry<T, "orderType">;
+export type OrderOf<T> = TypeMapEntry<T, "orderType">;
 /** Returns the factory "extras" type, like `withDerivedField`. */
-type FactoryExtrasOf<T> = TypeMapEntry<T, "factoryExtrasType">;
+export type FactoryExtrasOf<T> = TypeMapEntry<T, "factoryExtrasType">;
 /**
  * Returns the opts of the entity's `newEntity` factory method, as exists in the actual file.
  *
  * This is because `FactoryOpts` is a set of defaults, but the user can customize it if they want.
  */
-type ActualFactoryOpts<T> = TypeMapEntry<T, "factoryOptsType">;
+export type ActualFactoryOpts<T> = TypeMapEntry<T, "factoryOptsType">;
 /** Return the `Foo` type for a given `Foo` entity constructor. */
-type EntityOf<C> = C extends (new (em: EntityManager, opts: any) => infer T) ? T : never;
+export type EntityOf<C> = C extends (new (em: EntityManager, opts: any) => infer T) ? T : never;
 type RelationsKeysOf<T> = { [K in keyof OptsOf<T>]: OptsOf<T>[K] extends Entity[] | undefined ? K : never; }[keyof OptsOf<T>];
 /** Return the Relation keys from `FooOpt` type, given a `Foo` entity */
-type RelationsOf<T extends Entity> = { [K in RelationsKeysOf<T>]: NonNullable<OptsOf<T>[K]>; };
+export type RelationsOf<T extends Entity> = { [K in RelationsKeysOf<T>]: NonNullable<OptsOf<T>[K]>; };
 //#endregion
-export { ActualFactoryOpts, ColumnsOf, EntityOf, FactoryExtrasOf, FieldsOf, FilterOf, GraphQLFilterOf, InheritanceTypeOf, OptIdsOf, OptsOf, OrderOf, RelationsOf, RootTypeNameOf, TypeMap, TypeMapEntry, TypeNameOf };
+export {};
 //# sourceMappingURL=typeMap.d.mts.map

package/build/typeMap.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"typeMap.d.mts","names":[],"sources":["../src/typeMap.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;UAoBiB;;;;;;;KAQZ,WAAW,KAAK;EAAY;IAAU,SAAS;;IAAQ,IAAI;EAAY;IAAU,SAAS;;IAAQ;;KAG3F,WAAW,KAAK,WAAW;;;;;;;;;;;;;KAc3B,eAAe,KAAK;EAAY;IAAU,SAAS;;IAAuB;;KAG1E,aAAa,GAAG,oBAC1B,WAAW,kBAAiB,KACxB,gBAAgB,UACd,gBAAgB,QAAQ,KACtB,QAAQ,GAAG;;KAMT,OAAO,KAAK,aAAa;;KAGzB,SAAS,KAAK,aAAa;;KAG3B,UAAU,KAAK,aAAa;;KAG5B,kBAAkB,KAAK,aAAa;KAEpC,SAAS,KAAK,aAAa;;KAG3B,SAAS,KAAK,aAAa;;KAG3B,gBAAgB,KAAK,aAAa;;KAGlC,QAAQ,KAAK,aAAa;;KAG1B,gBAAgB,KAAK,aAAa;;;;;;KAOlC,kBAAkB,KAAK,aAAa;;KAGpC,SAAS,KAAK,gBAAe,IAAI,eAAe,oBAAoB,KAAI;KAE/E,gBAAgB,QAClB,WAAW,OAAO,KAAK,OAAO,GAAG,WAAW,uBAAuB,mBAC9D,OAAO;;KAGH,YAAY,UAAU,aAC/B,KAAK,gBAAgB,KAAK,YAAY,OAAO,GAAG"}
+{"version":3,"file":"typeMap.d.mts","names":[],"sources":["../src/typeMap.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;iBAoBiB;;;;;;;KAQZ,WAAW,KAAK;EAAY;IAAU,SAAS;;IAAQ,IAAI;EAAY;IAAU,SAAS;;IAAQ;;YAG3F,WAAW,KAAK,WAAW;;;;;;;;;;;;;YAc3B,eAAe,KAAK;EAAY;IAAU,SAAS;;IAAuB;;YAG1E,aAAa,GAAG,oBAC1B,WAAW,kBAAiB,KACxB,gBAAgB,UACd,gBAAgB,QAAQ,KACtB,QAAQ,GAAG;;YAMT,OAAO,KAAK,aAAa;;YAGzB,SAAS,KAAK,aAAa;;YAG3B,UAAU,KAAK,aAAa;;YAG5B,kBAAkB,KAAK,aAAa;YAEpC,SAAS,KAAK,aAAa;;YAG3B,SAAS,KAAK,aAAa;;YAG3B,gBAAgB,KAAK,aAAa;;YAGlC,QAAQ,KAAK,aAAa;;YAG1B,gBAAgB,KAAK,aAAa;;;;;;YAOlC,kBAAkB,KAAK,aAAa;;YAGpC,SAAS,KAAK,gBAAe,IAAI,eAAe,oBAAoB,KAAI;KAE/E,gBAAgB,QAClB,WAAW,OAAO,KAAK,OAAO,GAAG,WAAW,uBAAuB,mBAC9D,OAAO;;YAGH,YAAY,UAAU,aAC/B,KAAK,gBAAgB,KAAK,YAAY,OAAO,GAAG"}

package/build/upsert.d.cts

@@ -12,7 +12,7 @@ import { Entity } from "./Entity.cjs";
  * any combination of 1) ids to existing entities, 2) entities directly, 3) null/undefined
  * with the appropriate partial-update behavior, or 4) partials.
  */
-type DeepPartialOrNull<T extends Entity> = {
+export type DeepPartialOrNull<T extends Entity> = {
   id?: IdOf<T> | null;
 } & AllowRelationsToBeIdsOrEntitiesOrPartials<PartialOrNull<OptsOf<T> & OptIdsOf<T>>> & OptIdsOf<T>;
 /** Flags that allow `upsert` to delete or remove entities. */
@@ -32,11 +32,11 @@ type AllowRelationsToBeIdsOrEntitiesOrPartials<T> = { [P in keyof T]: T[P] exten
  * The difference between this and `Entity.setPartial` is that we accept `DeepPartialOrNull`
  * updates, similar to `createOrUpdateUnsafe`, instead of just a flat/shallow list of opts.
  */
-declare function updatePartial<T extends Entity>(entity: T, input: DeepPartialOrNull<T>): Promise<void>;
+export declare function updatePartial<T extends Entity>(entity: T, input: DeepPartialOrNull<T>): Promise<void>;
 /**
  * A utility function to create-or-update/upsert entities coming from a partial-update style API.
  */
-declare function upsert<T extends Entity>(em: EntityManager<any, any, any>, constructor: MaybeAbstractEntityConstructor<T>, input: DeepPartialOrNull<T>): Promise<T>;
+export declare function upsert<T extends Entity>(em: EntityManager<any, any, any>, constructor: MaybeAbstractEntityConstructor<T>, input: DeepPartialOrNull<T>): Promise<T>;
 //#endregion
-export { DeepPartialOrNull, updatePartial, upsert };
+export {};
 //# sourceMappingURL=upsert.d.cts.map

package/build/upsert.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"upsert.d.cts","names":[],"sources":["../src/upsert.ts"],"mappings":";;;;;;;;;;;;;;KA+BY,kBAAkB,UAAU;EAAY,KAAK,KAAK;IAAc,0CAC1E,cAAc,OAAO,KAAK,SAAS,OAEnC,SAAS;;KAGN;EACH;EACA;EACA;;;KAIG;EACH;;KAGG,0CAA0C,QAC5C,WAAW,IAAI,EAAE,WAAW,sBAAsB,KAC/C,UAAU,YAAY,KACpB,UAAU,SACR,MAAM,KAAK,kBAAkB,KAAK,mBAAmB,KAAK,aAC1D,EAAE,KACJ,UAAU,SACR,KAAK,kBAAkB,KAAK,cAAc,KAAK,YAC/C,EAAE,KACN,EAAE;;;;;;;iBASc,cAAc,UAAU,QAAQ,QAAQ,GAAG,OAAO,kBAAkB,KAAK;;;;iBA8MzE,OAAO,UAAU,QACrC,IAAI,8BACJ,aAAa,+BAA+B,IAC5C,OAAO,kBAAkB,KACxB,QAAQ"}
+{"version":3,"file":"upsert.d.cts","names":[],"sources":["../src/upsert.ts"],"mappings":";;;;;;;;;;;;;;YA+BY,kBAAkB,UAAU;EAAY,KAAK,KAAK;IAAc,0CAC1E,cAAc,OAAO,KAAK,SAAS,OAEnC,SAAS;;KAGN;EACH;EACA;EACA;;;KAIG;EACH;;KAGG,0CAA0C,QAC5C,WAAW,IAAI,EAAE,WAAW,sBAAsB,KAC/C,UAAU,YAAY,KACpB,UAAU,SACR,MAAM,KAAK,kBAAkB,KAAK,mBAAmB,KAAK,aAC1D,EAAE,KACJ,UAAU,SACR,KAAK,kBAAkB,KAAK,cAAc,KAAK,YAC/C,EAAE,KACN,EAAE;;;;;;;wBASc,cAAc,UAAU,QAAQ,QAAQ,GAAG,OAAO,kBAAkB,KAAK;;;;wBA8MzE,OAAO,UAAU,QACrC,IAAI,8BACJ,aAAa,+BAA+B,IAC5C,OAAO,kBAAkB,KACxB,QAAQ"}

package/build/upsert.d.mts

@@ -12,7 +12,7 @@ import { Entity } from "./Entity.mjs";
  * any combination of 1) ids to existing entities, 2) entities directly, 3) null/undefined
  * with the appropriate partial-update behavior, or 4) partials.
  */
-type DeepPartialOrNull<T extends Entity> = {
+export type DeepPartialOrNull<T extends Entity> = {
   id?: IdOf<T> | null;
 } & AllowRelationsToBeIdsOrEntitiesOrPartials<PartialOrNull<OptsOf<T> & OptIdsOf<T>>> & OptIdsOf<T>;
 /** Flags that allow `upsert` to delete or remove entities. */
@@ -32,11 +32,11 @@ type AllowRelationsToBeIdsOrEntitiesOrPartials<T> = { [P in keyof T]: T[P] exten
  * The difference between this and `Entity.setPartial` is that we accept `DeepPartialOrNull`
  * updates, similar to `createOrUpdateUnsafe`, instead of just a flat/shallow list of opts.
  */
-declare function updatePartial<T extends Entity>(entity: T, input: DeepPartialOrNull<T>): Promise<void>;
+export declare function updatePartial<T extends Entity>(entity: T, input: DeepPartialOrNull<T>): Promise<void>;
 /**
  * A utility function to create-or-update/upsert entities coming from a partial-update style API.
  */
-declare function upsert<T extends Entity>(em: EntityManager<any, any, any>, constructor: MaybeAbstractEntityConstructor<T>, input: DeepPartialOrNull<T>): Promise<T>;
+export declare function upsert<T extends Entity>(em: EntityManager<any, any, any>, constructor: MaybeAbstractEntityConstructor<T>, input: DeepPartialOrNull<T>): Promise<T>;
 //#endregion
-export { DeepPartialOrNull, updatePartial, upsert };
+export {};
 //# sourceMappingURL=upsert.d.mts.map

package/build/upsert.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"upsert.d.mts","names":[],"sources":["../src/upsert.ts"],"mappings":";;;;;;;;;;;;;;KA+BY,kBAAkB,UAAU;EAAY,KAAK,KAAK;IAAc,0CAC1E,cAAc,OAAO,KAAK,SAAS,OAEnC,SAAS;;KAGN;EACH;EACA;EACA;;;KAIG;EACH;;KAGG,0CAA0C,QAC5C,WAAW,IAAI,EAAE,WAAW,sBAAsB,KAC/C,UAAU,YAAY,KACpB,UAAU,SACR,MAAM,KAAK,kBAAkB,KAAK,mBAAmB,KAAK,aAC1D,EAAE,KACJ,UAAU,SACR,KAAK,kBAAkB,KAAK,cAAc,KAAK,YAC/C,EAAE,KACN,EAAE;;;;;;;iBASc,cAAc,UAAU,QAAQ,QAAQ,GAAG,OAAO,kBAAkB,KAAK;;;;iBA8MzE,OAAO,UAAU,QACrC,IAAI,8BACJ,aAAa,+BAA+B,IAC5C,OAAO,kBAAkB,KACxB,QAAQ"}
+{"version":3,"file":"upsert.d.mts","names":[],"sources":["../src/upsert.ts"],"mappings":";;;;;;;;;;;;;;YA+BY,kBAAkB,UAAU;EAAY,KAAK,KAAK;IAAc,0CAC1E,cAAc,OAAO,KAAK,SAAS,OAEnC,SAAS;;KAGN;EACH;EACA;EACA;;;KAIG;EACH;;KAGG,0CAA0C,QAC5C,WAAW,IAAI,EAAE,WAAW,sBAAsB,KAC/C,UAAU,YAAY,KACpB,UAAU,SACR,MAAM,KAAK,kBAAkB,KAAK,mBAAmB,KAAK,aAC1D,EAAE,KACJ,UAAU,SACR,KAAK,kBAAkB,KAAK,cAAc,KAAK,YAC/C,EAAE,KACN,EAAE;;;;;;;wBASc,cAAc,UAAU,QAAQ,QAAQ,GAAG,OAAO,kBAAkB,KAAK;;;;wBA8MzE,OAAO,UAAU,QACrC,IAAI,8BACJ,aAAa,+BAA+B,IAC5C,OAAO,kBAAkB,KACxB,QAAQ"}

package/build/utils.d.cts

@@ -2,7 +2,7 @@ import { OrderBy } from "./queries/find/EntityFilter.cjs";
 import { New } from "./loading/loadHints.cjs";
 import { Entity } from "./Entity.cjs";
 //#region src/utils.d.ts
-type MaybePromise<T> = T | Promise<T>;
+export type MaybePromise<T> = T | Promise<T>;
 /**
  * Given a `MaybePromise` of T, invoke `callback` against `T` either immediately or via `then`.
  *
@@ -15,34 +15,34 @@ type MaybePromise<T> = T | Promise<T>;
  *
  * But saves an `await` if `maybePromise` is not actually a promise.
  */
-declare function maybePromiseThen<T, U>(promiseOrObj: MaybePromise<T>, callback: (obj: T) => U): MaybePromise<U>;
-declare function failIfAnyRejected<T>(results: PromiseSettledResult<T>[]): T[];
-declare function getOrSet<T extends Record<keyof unknown, unknown>>(record: T, key: keyof T, defaultValue: T[keyof T] | (() => T[keyof T])): T[keyof T];
+export declare function maybePromiseThen<T, U>(promiseOrObj: MaybePromise<T>, callback: (obj: T) => U): MaybePromise<U>;
+export declare function failIfAnyRejected<T>(results: PromiseSettledResult<T>[]): T[];
+export declare function getOrSet<T extends Record<keyof unknown, unknown>>(record: T, key: keyof T, defaultValue: T[keyof T] | (() => T[keyof T])): T[keyof T];
 /** Defines a getter that replaces itself with its computed value on first access. */
-declare function defineLazyGetter<T extends object, K extends keyof T>(obj: T, key: K, build: () => T[K]): void;
+export declare function defineLazyGetter<T extends object, K extends keyof T>(obj: T, key: K, build: () => T[K]): void;
 /**
  * A utility to ensure a Promise-returning method actually returns a promise and doesn't
  * early exit. Using `async function` guarantees these semantics, but sometimes we avoid
  * `async` as a likely-premature optimization to avoid the overhead.
  */
-declare function tryResolve<T>(fn: () => T): Promise<T>;
+export declare function tryResolve<T>(fn: () => T): Promise<T>;
 /** Returns whether `obj` has at least one key, without allocating a keys array. */
-declare function hasAnyKey(obj: Record<any, any> | undefined): boolean;
-declare function fail(message?: string): never;
-declare function remove<T>(array: T[], t: T): void;
-declare function maybeRemove<T>(array: T[] | undefined, t: T): void;
-declare function maybeAdd<T>(array: T[], t: T): void;
-declare function clear<T>(array: T[]): void;
+export declare function hasAnyKey(obj: Record<any, any> | undefined): boolean;
+export declare function fail(message?: string): never;
+export declare function remove<T>(array: T[], t: T): void;
+export declare function maybeRemove<T>(array: T[] | undefined, t: T): void;
+export declare function maybeAdd<T>(array: T[], t: T): void;
+export declare function clear<T>(array: T[]): void;
 /** Returns 0 inclusive to n exclusive. */
-declare function zeroTo(n: number): number[];
-declare function groupBy<T, Y = T, K = string>(list: readonly T[], fn: (x: T) => K, valueFn?: (x: T) => Y): Map<K, Y[]>;
-declare function indexBy<T, Y = T, K = string>(list: T[], fn: (x: T) => K, valueFn?: (x: T) => Y): Map<K, Y>;
-declare function batched<T>(list: Array<T>, n: number): T[][];
-declare function partition<T>(array: ReadonlyArray<T>, f: (el: T) => boolean): [T[], T[]];
-declare function toArray<T>(maybeArray: T | T[] | undefined | null): T[];
-type NullOrDefinedOr<T> = T | null | undefined;
-declare function assertNever(x: never): never;
-declare function abbreviation(tableName: string): string;
+export declare function zeroTo(n: number): number[];
+export declare function groupBy<T, Y = T, K = string>(list: readonly T[], fn: (x: T) => K, valueFn?: (x: T) => Y): Map<K, Y[]>;
+export declare function indexBy<T, Y = T, K = string>(list: T[], fn: (x: T) => K, valueFn?: (x: T) => Y): Map<K, Y>;
+export declare function batched<T>(list: Array<T>, n: number): T[][];
+export declare function partition<T>(array: ReadonlyArray<T>, f: (el: T) => boolean): [T[], T[]];
+export declare function toArray<T>(maybeArray: T | T[] | undefined | null): T[];
+export type NullOrDefinedOr<T> = T | null | undefined;
+export declare function assertNever(x: never): never;
+export declare function abbreviation(tableName: string): string;
 /**
  * Utility method for casting `entity` to a `New` entity.
  *
@@ -52,14 +52,13 @@ declare function abbreviation(tableName: string): string;
  *
  * Granted, we could do a runtime check that all relations are loaded.
  */
-declare function asNew<T extends Entity>(entity: T): New<T>;
-declare function compareValues(av: any, bv: any, direction: OrderBy): number;
+export declare function asNew<T extends Entity>(entity: T): New<T>;
+export declare function compareValues(av: any, bv: any, direction: OrderBy): number;
 /** A ~naive deep merge that requires already-normalized hints and will mutate `source`. */
-declare function mergeNormalizedHints(target: any, source: any): void;
-declare function cleanStringValue(value: unknown): string | undefined;
+export declare function mergeNormalizedHints(target: any, source: any): void;
+export declare function cleanStringValue(value: unknown): string | undefined;
 /** Strips new lines/indentation from our `UPDATE` string; doesn't do any actual SQL param escaping/etc. */
-declare function cleanSql(sql: string): string;
-declare function flatAndUnique<T extends unknown>(list: (T | T[] | undefined)[]): Set<T>;
+export declare function cleanSql(sql: string): string;
+export declare function flatAndUnique<T extends unknown>(list: (T | T[] | undefined)[]): Set<T>;
 //#endregion
-export { MaybePromise, NullOrDefinedOr, abbreviation, asNew, assertNever, batched, cleanSql, cleanStringValue, clear, compareValues, defineLazyGetter, fail, failIfAnyRejected, flatAndUnique, getOrSet, groupBy, hasAnyKey, indexBy, maybeAdd, maybePromiseThen, maybeRemove, mergeNormalizedHints, partition, remove, toArray, tryResolve, zeroTo };
 //# sourceMappingURL=utils.d.cts.map

package/build/utils.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.cts","names":[],"sources":["../src/utils.ts"],"mappings":";;;;KAMY,aAAa,KAAK,IAAI,QAAQ;;;;;;;;;;;;;iBAc1B,iBAAiB,GAAG,GAAG,cAAc,aAAa,IAAI,WAAW,KAAK,MAAM,IAAI,aAAa;iBAI7F,kBAAkB,GAAG,SAAS,qBAAqB,OAAO;iBAS1D,SAAS,UAAU,gCACjC,QAAQ,GACR,WAAW,GACX,cAAc,QAAQ,YAAY,QAAQ,MACzC,QAAQ;;iBAQK,iBAAiB,kBAAkB,gBAAgB,GAAG,KAAK,GAAG,KAAK,GAAG,aAAa,EAAE;;;;;;iBAgBrF,WAAW,GAAG,UAAU,IAAI,QAAQ;;iBASpC,UAAU,KAAK;iBAKf,KAAK;iBAIL,OAAO,GAAG,OAAO,KAAK,GAAG;iBAOzB,YAAY,GAAG,OAAO,iBAAiB,GAAG;iBAI1C,SAAS,GAAG,OAAO,KAAK,GAAG;iBAM3B,MAAM,GAAG,OAAO;;iBAKhB,OAAO;iBAIP,QAAQ,GAAG,IAAI,GAAG,YAAY,eAAe,KAAK,KAAK,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,IAAI,IAAI,GAAG;iBAYlG,QAAQ,GAAG,IAAI,GAAG,YAAY,MAAM,KAAK,KAAK,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,IAAI,IAAI,GAAG;iBASzF,QAAQ,GAAG,MAAM,MAAM,IAAI,YAAY;iBAQvC,UAAU,GAAG,OAAO,cAAc,IAAI,IAAI,IAAI,iBAAiB,KAAK;iBAcpE,QAAQ,GAAG,YAAY,IAAI,yBAAyB;KAKxD,gBAAgB,KAAK;iBAEjB,YAAY;iBAIZ,aAAa;;;;;;;;;;iBAgBb,MAAM,UAAU,QAAQ,QAAQ,IAAI,IAAI;iBAIxC,cAAc,SAAS,SAAS,WAAW;;iBAkC3C,qBAAqB,aAAa;iBAclC,iBAAiB;;iBAUjB,SAAS;iBAKT,cAAc,mBAAmB,OAAO,IAAI,qBAAqB,IAAI"}
+{"version":3,"file":"utils.d.cts","names":[],"sources":["../src/utils.ts"],"mappings":";;;;YAMY,aAAa,KAAK,IAAI,QAAQ;;;;;;;;;;;;;wBAc1B,iBAAiB,GAAG,GAAG,cAAc,aAAa,IAAI,WAAW,KAAK,MAAM,IAAI,aAAa;wBAI7F,kBAAkB,GAAG,SAAS,qBAAqB,OAAO;wBAS1D,SAAS,UAAU,gCACjC,QAAQ,GACR,WAAW,GACX,cAAc,QAAQ,YAAY,QAAQ,MACzC,QAAQ;;wBAQK,iBAAiB,kBAAkB,gBAAgB,GAAG,KAAK,GAAG,KAAK,GAAG,aAAa,EAAE;;;;;;wBAgBrF,WAAW,GAAG,UAAU,IAAI,QAAQ;;wBASpC,UAAU,KAAK;wBAKf,KAAK;wBAIL,OAAO,GAAG,OAAO,KAAK,GAAG;wBAOzB,YAAY,GAAG,OAAO,iBAAiB,GAAG;wBAI1C,SAAS,GAAG,OAAO,KAAK,GAAG;wBAM3B,MAAM,GAAG,OAAO;;wBAKhB,OAAO;wBAIP,QAAQ,GAAG,IAAI,GAAG,YAAY,eAAe,KAAK,KAAK,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,IAAI,IAAI,GAAG;wBAYlG,QAAQ,GAAG,IAAI,GAAG,YAAY,MAAM,KAAK,KAAK,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,IAAI,IAAI,GAAG;wBASzF,QAAQ,GAAG,MAAM,MAAM,IAAI,YAAY;wBAQvC,UAAU,GAAG,OAAO,cAAc,IAAI,IAAI,IAAI,iBAAiB,KAAK;wBAcpE,QAAQ,GAAG,YAAY,IAAI,yBAAyB;YAKxD,gBAAgB,KAAK;wBAEjB,YAAY;wBAIZ,aAAa;;;;;;;;;;wBAgBb,MAAM,UAAU,QAAQ,QAAQ,IAAI,IAAI;wBAIxC,cAAc,SAAS,SAAS,WAAW;;wBAkC3C,qBAAqB,aAAa;wBAclC,iBAAiB;;wBAUjB,SAAS;wBAKT,cAAc,mBAAmB,OAAO,IAAI,qBAAqB,IAAI"}

package/build/utils.d.mts

@@ -2,7 +2,7 @@ import { OrderBy } from "./queries/find/EntityFilter.mjs";
 import { New } from "./loading/loadHints.mjs";
 import { Entity } from "./Entity.mjs";
 //#region src/utils.d.ts
-type MaybePromise<T> = T | Promise<T>;
+export type MaybePromise<T> = T | Promise<T>;
 /**
  * Given a `MaybePromise` of T, invoke `callback` against `T` either immediately or via `then`.
  *
@@ -15,34 +15,34 @@ type MaybePromise<T> = T | Promise<T>;
  *
  * But saves an `await` if `maybePromise` is not actually a promise.
  */
-declare function maybePromiseThen<T, U>(promiseOrObj: MaybePromise<T>, callback: (obj: T) => U): MaybePromise<U>;
-declare function failIfAnyRejected<T>(results: PromiseSettledResult<T>[]): T[];
-declare function getOrSet<T extends Record<keyof unknown, unknown>>(record: T, key: keyof T, defaultValue: T[keyof T] | (() => T[keyof T])): T[keyof T];
+export declare function maybePromiseThen<T, U>(promiseOrObj: MaybePromise<T>, callback: (obj: T) => U): MaybePromise<U>;
+export declare function failIfAnyRejected<T>(results: PromiseSettledResult<T>[]): T[];
+export declare function getOrSet<T extends Record<keyof unknown, unknown>>(record: T, key: keyof T, defaultValue: T[keyof T] | (() => T[keyof T])): T[keyof T];
 /** Defines a getter that replaces itself with its computed value on first access. */
-declare function defineLazyGetter<T extends object, K extends keyof T>(obj: T, key: K, build: () => T[K]): void;
+export declare function defineLazyGetter<T extends object, K extends keyof T>(obj: T, key: K, build: () => T[K]): void;
 /**
  * A utility to ensure a Promise-returning method actually returns a promise and doesn't
  * early exit. Using `async function` guarantees these semantics, but sometimes we avoid
  * `async` as a likely-premature optimization to avoid the overhead.
  */
-declare function tryResolve<T>(fn: () => T): Promise<T>;
+export declare function tryResolve<T>(fn: () => T): Promise<T>;
 /** Returns whether `obj` has at least one key, without allocating a keys array. */
-declare function hasAnyKey(obj: Record<any, any> | undefined): boolean;
-declare function fail(message?: string): never;
-declare function remove<T>(array: T[], t: T): void;
-declare function maybeRemove<T>(array: T[] | undefined, t: T): void;
-declare function maybeAdd<T>(array: T[], t: T): void;
-declare function clear<T>(array: T[]): void;
+export declare function hasAnyKey(obj: Record<any, any> | undefined): boolean;
+export declare function fail(message?: string): never;
+export declare function remove<T>(array: T[], t: T): void;
+export declare function maybeRemove<T>(array: T[] | undefined, t: T): void;
+export declare function maybeAdd<T>(array: T[], t: T): void;
+export declare function clear<T>(array: T[]): void;
 /** Returns 0 inclusive to n exclusive. */
-declare function zeroTo(n: number): number[];
-declare function groupBy<T, Y = T, K = string>(list: readonly T[], fn: (x: T) => K, valueFn?: (x: T) => Y): Map<K, Y[]>;
-declare function indexBy<T, Y = T, K = string>(list: T[], fn: (x: T) => K, valueFn?: (x: T) => Y): Map<K, Y>;
-declare function batched<T>(list: Array<T>, n: number): T[][];
-declare function partition<T>(array: ReadonlyArray<T>, f: (el: T) => boolean): [T[], T[]];
-declare function toArray<T>(maybeArray: T | T[] | undefined | null): T[];
-type NullOrDefinedOr<T> = T | null | undefined;
-declare function assertNever(x: never): never;
-declare function abbreviation(tableName: string): string;
+export declare function zeroTo(n: number): number[];
+export declare function groupBy<T, Y = T, K = string>(list: readonly T[], fn: (x: T) => K, valueFn?: (x: T) => Y): Map<K, Y[]>;
+export declare function indexBy<T, Y = T, K = string>(list: T[], fn: (x: T) => K, valueFn?: (x: T) => Y): Map<K, Y>;
+export declare function batched<T>(list: Array<T>, n: number): T[][];
+export declare function partition<T>(array: ReadonlyArray<T>, f: (el: T) => boolean): [T[], T[]];
+export declare function toArray<T>(maybeArray: T | T[] | undefined | null): T[];
+export type NullOrDefinedOr<T> = T | null | undefined;
+export declare function assertNever(x: never): never;
+export declare function abbreviation(tableName: string): string;
 /**
  * Utility method for casting `entity` to a `New` entity.
  *
@@ -52,14 +52,13 @@ declare function abbreviation(tableName: string): string;
  *
  * Granted, we could do a runtime check that all relations are loaded.
  */
-declare function asNew<T extends Entity>(entity: T): New<T>;
-declare function compareValues(av: any, bv: any, direction: OrderBy): number;
+export declare function asNew<T extends Entity>(entity: T): New<T>;
+export declare function compareValues(av: any, bv: any, direction: OrderBy): number;
 /** A ~naive deep merge that requires already-normalized hints and will mutate `source`. */
-declare function mergeNormalizedHints(target: any, source: any): void;
-declare function cleanStringValue(value: unknown): string | undefined;
+export declare function mergeNormalizedHints(target: any, source: any): void;
+export declare function cleanStringValue(value: unknown): string | undefined;
 /** Strips new lines/indentation from our `UPDATE` string; doesn't do any actual SQL param escaping/etc. */
-declare function cleanSql(sql: string): string;
-declare function flatAndUnique<T extends unknown>(list: (T | T[] | undefined)[]): Set<T>;
+export declare function cleanSql(sql: string): string;
+export declare function flatAndUnique<T extends unknown>(list: (T | T[] | undefined)[]): Set<T>;
 //#endregion
-export { MaybePromise, NullOrDefinedOr, abbreviation, asNew, assertNever, batched, cleanSql, cleanStringValue, clear, compareValues, defineLazyGetter, fail, failIfAnyRejected, flatAndUnique, getOrSet, groupBy, hasAnyKey, indexBy, maybeAdd, maybePromiseThen, maybeRemove, mergeNormalizedHints, partition, remove, toArray, tryResolve, zeroTo };
 //# sourceMappingURL=utils.d.mts.map

package/build/utils.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.mts","names":[],"sources":["../src/utils.ts"],"mappings":";;;;KAMY,aAAa,KAAK,IAAI,QAAQ;;;;;;;;;;;;;iBAc1B,iBAAiB,GAAG,GAAG,cAAc,aAAa,IAAI,WAAW,KAAK,MAAM,IAAI,aAAa;iBAI7F,kBAAkB,GAAG,SAAS,qBAAqB,OAAO;iBAS1D,SAAS,UAAU,gCACjC,QAAQ,GACR,WAAW,GACX,cAAc,QAAQ,YAAY,QAAQ,MACzC,QAAQ;;iBAQK,iBAAiB,kBAAkB,gBAAgB,GAAG,KAAK,GAAG,KAAK,GAAG,aAAa,EAAE;;;;;;iBAgBrF,WAAW,GAAG,UAAU,IAAI,QAAQ;;iBASpC,UAAU,KAAK;iBAKf,KAAK;iBAIL,OAAO,GAAG,OAAO,KAAK,GAAG;iBAOzB,YAAY,GAAG,OAAO,iBAAiB,GAAG;iBAI1C,SAAS,GAAG,OAAO,KAAK,GAAG;iBAM3B,MAAM,GAAG,OAAO;;iBAKhB,OAAO;iBAIP,QAAQ,GAAG,IAAI,GAAG,YAAY,eAAe,KAAK,KAAK,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,IAAI,IAAI,GAAG;iBAYlG,QAAQ,GAAG,IAAI,GAAG,YAAY,MAAM,KAAK,KAAK,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,IAAI,IAAI,GAAG;iBASzF,QAAQ,GAAG,MAAM,MAAM,IAAI,YAAY;iBAQvC,UAAU,GAAG,OAAO,cAAc,IAAI,IAAI,IAAI,iBAAiB,KAAK;iBAcpE,QAAQ,GAAG,YAAY,IAAI,yBAAyB;KAKxD,gBAAgB,KAAK;iBAEjB,YAAY;iBAIZ,aAAa;;;;;;;;;;iBAgBb,MAAM,UAAU,QAAQ,QAAQ,IAAI,IAAI;iBAIxC,cAAc,SAAS,SAAS,WAAW;;iBAkC3C,qBAAqB,aAAa;iBAclC,iBAAiB;;iBAUjB,SAAS;iBAKT,cAAc,mBAAmB,OAAO,IAAI,qBAAqB,IAAI"}
+{"version":3,"file":"utils.d.mts","names":[],"sources":["../src/utils.ts"],"mappings":";;;;YAMY,aAAa,KAAK,IAAI,QAAQ;;;;;;;;;;;;;wBAc1B,iBAAiB,GAAG,GAAG,cAAc,aAAa,IAAI,WAAW,KAAK,MAAM,IAAI,aAAa;wBAI7F,kBAAkB,GAAG,SAAS,qBAAqB,OAAO;wBAS1D,SAAS,UAAU,gCACjC,QAAQ,GACR,WAAW,GACX,cAAc,QAAQ,YAAY,QAAQ,MACzC,QAAQ;;wBAQK,iBAAiB,kBAAkB,gBAAgB,GAAG,KAAK,GAAG,KAAK,GAAG,aAAa,EAAE;;;;;;wBAgBrF,WAAW,GAAG,UAAU,IAAI,QAAQ;;wBASpC,UAAU,KAAK;wBAKf,KAAK;wBAIL,OAAO,GAAG,OAAO,KAAK,GAAG;wBAOzB,YAAY,GAAG,OAAO,iBAAiB,GAAG;wBAI1C,SAAS,GAAG,OAAO,KAAK,GAAG;wBAM3B,MAAM,GAAG,OAAO;;wBAKhB,OAAO;wBAIP,QAAQ,GAAG,IAAI,GAAG,YAAY,eAAe,KAAK,KAAK,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,IAAI,IAAI,GAAG;wBAYlG,QAAQ,GAAG,IAAI,GAAG,YAAY,MAAM,KAAK,KAAK,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,IAAI,IAAI,GAAG;wBASzF,QAAQ,GAAG,MAAM,MAAM,IAAI,YAAY;wBAQvC,UAAU,GAAG,OAAO,cAAc,IAAI,IAAI,IAAI,iBAAiB,KAAK;wBAcpE,QAAQ,GAAG,YAAY,IAAI,yBAAyB;YAKxD,gBAAgB,KAAK;wBAEjB,YAAY;wBAIZ,aAAa;;;;;;;;;;wBAgBb,MAAM,UAAU,QAAQ,QAAQ,IAAI,IAAI;wBAIxC,cAAc,SAAS,SAAS,WAAW;;wBAkC3C,qBAAqB,aAAa;wBAclC,iBAAiB;;wBAUjB,SAAS;wBAKT,cAAc,mBAAmB,OAAO,IAAI,qBAAqB,IAAI"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "joist-core",
-  "version": "2.4.0-next.37",
+  "version": "2.4.0-next.39",
   "license": "MIT",
   "type": "module",
   "repository": {
@@ -42,7 +42,7 @@
     "build"
   ],
   "peerDependencies": {
-    "joist-utils": "2.4.0-next.37"
+    "joist-utils": "2.4.0-next.39"
   },
   "dependencies": {
     "ansis": "^4.4.0",
@@ -50,10 +50,10 @@
     "temporal-spec": "^1.0.1"
   },
   "devDependencies": {
-    "@swc/core": "^1.16.1",
+    "@swc/core": "1.16.18",
     "@swc/jest": "^0.2.39",
     "@types/jest": "^30.0.0",
-    "@types/node": "^26.2.0",
+    "@types/node": "^26.6.5",
     "jest": "30.4.2",
     "temporal-polyfill": "^1.0.5",
     "tsconfig-paths": "^4.2.0",