feathers-utils 10.1.0 → 10.3.0

package/dist/hooks.d.mts

@@ -4,7 +4,7 @@ import { a as IffHook, i as skippable, n as ThrowIfOptions, o as iff, r as throw
 import { i as transformData, n as transformResult, r as transformQuery, t as TransformResultOptions } from "./transform-result.hook-C9wMLWs2.mjs";
 import { i as resolveData, n as resolveQuery, r as resolveResult, t as resolve } from "./resolve-Cmxskunj.mjs";
 import { FeathersError } from "@feathersjs/errors";
-import { HookContext, NextFunction, Params } from "@feathersjs/feathers";
+import { HookContext, NextFunction, Params, Query } from "@feathersjs/feathers";
 import { RateLimiterAbstract } from "rate-limiter-flexible";
 import { PropertyPath } from "lodash";
 
@@ -249,6 +249,54 @@ declare function createRelated<H extends HookContext = HookContext>(options: May
  */
 declare const debug: <H extends HookContext = HookContext>(msg: string, ...fieldNames: string[]) => (context: H, next?: NextFunction) => Promise<void>;
 //#endregion
+//#region src/hooks/disable-pagination/disable-pagination.hook.d.ts
+/**
+ * Disables pagination when `query.$limit` is `-1` or `'-1'`.
+ * Removes the `$limit` from the query and sets `params.paginate = false`.
+ * Must be used as a `before` or `around` hook on the `find` method.
+ *
+ * @example
+ * ```ts
+ * import { disablePagination } from 'feathers-utils/hooks'
+ *
+ * app.service('users').hooks({
+ *   before: { find: [disablePagination()] }
+ * })
+ * // Then call: app.service('users').find({ query: { $limit: -1 } })
+ * ```
+ *
+ * @see https://utils.feathersjs.com/hooks/disable-pagination.html
+ */
+declare const disablePagination: <H extends HookContext = HookContext>() => {
+  (context: H): void;
+  (context: H, next: NextFunction): Promise<void>;
+};
+//#endregion
+//#region src/hooks/disallow/disallow.hook.d.ts
+/**
+ * Prevents access to a service method completely or for specific transports.
+ * When called without arguments, the method is blocked for all callers.
+ * When called with transport names, only those transports are blocked.
+ *
+ * @example
+ * ```ts
+ * import { disallow } from 'feathers-utils/hooks'
+ *
+ * app.service('users').hooks({
+ *   before: {
+ *     remove: [disallow('external')], // block external access
+ *     update: [disallow()],           // block completely
+ *   }
+ * })
+ * ```
+ *
+ * @see https://utils.feathersjs.com/hooks/disallow.html
+ */
+declare const disallow: <H extends HookContext = HookContext>(transports?: MaybeArray<TransportName>) => {
+  (context: H): void;
+  (context: H, next: NextFunction): Promise<void>;
+};
+//#endregion
 //#region src/hooks/find-or-create/find-or-create.hook.d.ts
 /**
  * The valid `uniqueBy` paths for a service's create data. Falls back to a plain
@@ -303,53 +351,42 @@ interface FindOrCreateOptions<H extends HookContext = HookContext, Services exte
  */
 declare function findOrCreate<H extends HookContext = HookContext>(options: FindOrCreateOptions<H>): (context: H, next?: NextFunction) => Promise<void>;
 //#endregion
-//#region src/hooks/disable-pagination/disable-pagination.hook.d.ts
-/**
- * Disables pagination when `query.$limit` is `-1` or `'-1'`.
- * Removes the `$limit` from the query and sets `params.paginate = false`.
- * Must be used as a `before` or `around` hook on the `find` method.
- *
- * @example
- * ```ts
- * import { disablePagination } from 'feathers-utils/hooks'
- *
- * app.service('users').hooks({
- *   before: { find: [disablePagination()] }
- * })
- * // Then call: app.service('users').find({ query: { $limit: -1 } })
- * ```
- *
- * @see https://utils.feathersjs.com/hooks/disable-pagination.html
- */
-declare const disablePagination: <H extends HookContext = HookContext>() => {
-  (context: H): void;
-  (context: H, next: NextFunction): Promise<void>;
+//#region src/hooks/mute-event/mute-event.hook.d.ts
+type MuteEventOptions<H extends HookContext = HookContext> = {
+  /**
+   * Only mute when this is truthy. Can be a boolean or a predicate that
+   * receives the `HookContext`. Defaults to always muting.
+   *
+   * @example isProvider('server')
+   */
+  when?: boolean | PredicateFn<H>;
 };
-//#endregion
-//#region src/hooks/disallow/disallow.hook.d.ts
 /**
- * Prevents access to a service method completely or for specific transports.
- * When called without arguments, the method is blocked for all callers.
- * When called with transport names, only those transports are blocked.
+ * Suppresses the service event for the current call by setting `context.event`
+ * to `null`. Feathers emits the standard `created`/`updated`/`patched`/`removed`
+ * event (the value of `context.event`) after the method runs; setting it to
+ * `null` prevents that emission so real-time subscribers and channels are not
+ * notified.
+ *
+ * Useful for seeding, migrations and internal syncs that should not trigger
+ * downstream listeners. Works as a `before`, `after` or `around` hook.
  *
  * @example
  * ```ts
- * import { disallow } from 'feathers-utils/hooks'
+ * import { muteEvent } from 'feathers-utils/hooks'
+ * import { isProvider } from 'feathers-utils/predicates'
  *
  * app.service('users').hooks({
  *   before: {
- *     remove: [disallow('external')], // block external access
- *     update: [disallow()],           // block completely
+ *     all: [muteEvent()],                              // mute every call
+ *     create: [muteEvent({ when: isProvider('server') })], // only server calls
  *   }
  * })
  * ```
  *
- * @see https://utils.feathersjs.com/hooks/disallow.html
+ * @see https://utils.feathersjs.com/hooks/mute-event.html
  */
-declare const disallow: <H extends HookContext = HookContext>(transports?: MaybeArray<TransportName>) => {
-  (context: H): void;
-  (context: H, next: NextFunction): Promise<void>;
-};
+declare const muteEvent: <H extends HookContext = HookContext>(options?: MuteEventOptions<H>) => (context: H, next?: NextFunction) => Promise<void>;
 //#endregion
 //#region src/hooks/on-delete/on-delete.hook.d.ts
 type OnDeleteAction = 'cascade' | 'set null';
@@ -644,6 +681,32 @@ declare const setField: <H extends HookContext = HookContext>({
   (context: H, next: NextFunction): Promise<void>;
 };
 //#endregion
+//#region src/hooks/set-query-defaults/set-query-defaults.hook.d.ts
+/**
+ * Adds default properties to `context.params.query` for fields the incoming query does
+ * not already constrain (including fields referenced nested in `$and`/`$or`/`$nor`).
+ * The query equivalent of the `defaults` transformer: e.g. hide template rows by default
+ * while still letting callers opt in via `{ isTemplate: true }`. This is the same pattern
+ * `softDelete` uses to filter out deleted rows. Works as a `before` or `around` hook.
+ *
+ * @example
+ * ```ts
+ * import { setQueryDefaults } from 'feathers-utils/hooks'
+ *
+ * app.service('posts').hooks({
+ *   before: { all: [setQueryDefaults({ isTemplate: false })] },
+ * })
+ * // find() => filters out templates
+ * // find({ query: { isTemplate: true } }) => caller keeps control
+ * ```
+ *
+ * @see https://utils.feathersjs.com/hooks/set-query-defaults.html
+ */
+declare const setQueryDefaults: <H extends HookContext = HookContext>(defaults: Query) => {
+  (context: H): void;
+  (context: H, next: NextFunction): Promise<void>;
+};
+//#endregion
 //#region src/hooks/set-result/set-result.hook.d.ts
 interface SetResultOptions {
   /**
@@ -759,6 +822,17 @@ interface SoftDeleteOptions<H extends HookContext = HookContext> {
    * If you set this option to `true`, it will use the `.patch()` method with hooks instead.
    */
   usePatchWithHooks?: boolean;
+  /**
+   * By default, if the incoming `params.query` already references a key of
+   * `deletedQuery` (e.g. `deletedAt`) — including nested inside `$and`/`$or`/`$nor` —
+   * the `deletedQuery` filter is NOT added, letting the caller read soft-deleted
+   * items while `remove` still soft-deletes them.
+   *
+   * Set this to `false` to always enforce the `deletedQuery` filter.
+   *
+   * @default true
+   */
+  allowQueryOverride?: boolean;
 }
 /**
  * Marks items as deleted instead of physically removing them. On `remove`, the hook
@@ -909,5 +983,5 @@ declare const traverse: <H extends HookContext = HookContext>({
   (context: H, next: NextFunction): Promise<void>;
 };
 //#endregion
-export { CacheEvent, CacheOptions, CheckMultiOptions, CreateRelatedOptions, FindOrCreateOptions, HookSetDataOptions, IffHook, OnDeleteAction, OnDeleteOptions, ParamsForServerOptions, PreventChangesOptions, RateLimitOptions, SetFieldOptions, SetResultOptions, SoftDeleteOptionFunction, SoftDeleteOptions, StashableOptions, ThrowIfIsIsProviderOptions, ThrowIfIsMultiOptions, ThrowIfOptions, TransformResultOptions, TraverseOptions, cache, checkMulti, checkRequired, combine, createRelated, debug, disablePagination, disallow, findOrCreate, iff, iff as when, iffElse, onDelete, paramsForServer, paramsFromClient, paramsFromClientOptions, preventChanges, rateLimit, resolve, resolveData, resolveQuery, resolveResult, setData, setField, setResult, setSlug, skippable, softDelete, stashable, throwIf, throwIfIsMulti, throwIfIsProvider, transformData, transformQuery, transformResult, traverse, unless };
+export { CacheEvent, CacheOptions, CheckMultiOptions, CreateRelatedOptions, FindOrCreateOptions, HookSetDataOptions, IffHook, MuteEventOptions, OnDeleteAction, OnDeleteOptions, ParamsForServerOptions, PreventChangesOptions, RateLimitOptions, SetFieldOptions, SetResultOptions, SoftDeleteOptionFunction, SoftDeleteOptions, StashableOptions, ThrowIfIsIsProviderOptions, ThrowIfIsMultiOptions, ThrowIfOptions, TransformResultOptions, TraverseOptions, cache, checkMulti, checkRequired, combine, createRelated, debug, disablePagination, disallow, findOrCreate, iff, iff as when, iffElse, muteEvent, onDelete, paramsForServer, paramsFromClient, paramsFromClientOptions, preventChanges, rateLimit, resolve, resolveData, resolveQuery, resolveResult, setData, setField, setQueryDefaults, setResult, setSlug, skippable, softDelete, stashable, throwIf, throwIfIsMulti, throwIfIsProvider, transformData, transformQuery, transformResult, traverse, unless };
 //# sourceMappingURL=hooks.d.mts.map

package/dist/hooks.mjs

@@ -1,5 +1,5 @@
-import { _ as combine, a as iffElse, i as iff, n as skippable, r as unless, t as throwIf } from "./predicates-puYa4nkf.mjs";
-import { S as cache, _ as findOrCreate, a as softDelete, b as checkRequired, c as setField, d as preventChanges, f as paramsFromClient, g as disablePagination, h as disallow, i as stashable, l as setData, m as onDelete, n as throwIfIsProvider, o as setSlug, p as paramsForServer, r as throwIfIsMulti, s as setResult, t as traverse, u as rateLimit, v as debug, x as checkMulti, y as createRelated } from "./hooks-Bg5XWcV7.mjs";
-import { n as transformQuery, r as transformData, t as transformResult } from "./transform-result.hook-B65pTRJO.mjs";
-import { i as resolveData, n as resolveQuery, r as resolveResult, t as resolve } from "./resolve-B9hRleHY.mjs";
-export { cache, checkMulti, checkRequired, combine, createRelated, debug, disablePagination, disallow, findOrCreate, iff, iff as when, iffElse, onDelete, paramsForServer, paramsFromClient, preventChanges, rateLimit, resolve, resolveData, resolveQuery, resolveResult, setData, setField, setResult, setSlug, skippable, softDelete, stashable, throwIf, throwIfIsMulti, throwIfIsProvider, transformData, transformQuery, transformResult, traverse, unless };
+import { _ as combine, a as iffElse, i as iff, n as throwIf, r as skippable, t as unless } from "./predicates-NOnUyMic.mjs";
+import { C as checkMulti, S as checkRequired, _ as findOrCreate, a as softDelete, b as debug, c as setQueryDefaults, d as rateLimit, f as preventChanges, g as muteEvent, h as onDelete, i as stashable, l as setField, m as paramsForServer, n as throwIfIsProvider, o as setSlug, p as paramsFromClient, r as throwIfIsMulti, s as setResult, t as traverse, u as setData, v as disallow, w as cache, x as createRelated, y as disablePagination } from "./hooks-DpFQfcFa.mjs";
+import { n as transformQuery, r as transformData, t as transformResult } from "./transform-result.hook-V2QYN2K0.mjs";
+import { i as resolveData, n as resolveQuery, r as resolveResult, t as resolve } from "./resolve-BflgIVD8.mjs";
+export { cache, checkMulti, checkRequired, combine, createRelated, debug, disablePagination, disallow, findOrCreate, iff, iff as when, iffElse, muteEvent, onDelete, paramsForServer, paramsFromClient, preventChanges, rateLimit, resolve, resolveData, resolveQuery, resolveResult, setData, setField, setQueryDefaults, setResult, setSlug, skippable, softDelete, stashable, throwIf, throwIfIsMulti, throwIfIsProvider, transformData, transformQuery, transformResult, traverse, unless };

package/dist/{index-DKA0E_ad.d.mts → index-C6MN6wag.d.mts}

@@ -23,45 +23,13 @@ type SkipHookName = 'all' | HookType | `${HookType}:${string}` | (string & {});
  */
 declare const addSkip: <H extends HookContext>(context: H, hooks: MaybeArray<SkipHookName>) => void;
 //#endregion
-//#region src/utils/chunk-find/chunk-find.util.d.ts
-type PaginateOption$1 = {
-  default?: number;
-  max?: number;
-};
-type ChunkFindOptions<P extends Params = Params> = {
-  params?: P & {
-    paginate?: PaginateOption$1;
-  };
-};
-/**
- * Use `for await` to iterate over chunks (pages) of results from a `find` method.
- *
- * This function is useful for processing large datasets in batches without loading everything into memory at once.
- * It uses pagination to fetch results in chunks, yielding each page's data array.
- *
- * @example
- * ```ts
- * import { chunkFind } from 'feathers-utils/utils'
- *
- * const app = feathers()
- *
- * // Assuming 'users' service has many records
- * for await (const users of chunkFind(app, 'users', {
- *  params: { query: { active: true }, // Custom query parameters
- * } })) {
- *  console.log(users) // Process each chunk of user records
- * }
- * ```
- *
- * @see https://utils.feathersjs.com/utils/chunk-find.html
- */
-declare function chunkFind<Services, Path extends KeyOf<Services>, Service extends Services[Path] = Services[Path], P extends Params = InferFindParams<Service>, Item = InferFindResultSingle<Service>>(app: Application<Services>, servicePath: Path, options?: ChunkFindOptions<P>): AsyncGenerator<Item[], void, unknown>;
-//#endregion
 //#region src/utils/add-to-query/add-to-query.util.d.ts
 /**
  * Safely merges properties into a Feathers query object. If a property already exists
  * with a different value, it wraps both in a `$and` array to preserve both conditions.
- * If the exact same key-value pair already exists, no changes are made.
+ * If the exact same key-value pair already exists, no changes are made. When the added
+ * query is itself a pure `$and` (`{ $and: [...] }`), its branches are flattened into the
+ * target's `$and` rather than nested.
  *
  * @example
  * ```ts
@@ -143,6 +111,40 @@ declare function checkContext<H extends HookContext, const T extends HookType$1
   method: M;
 }>;
 //#endregion
+//#region src/utils/chunk-find/chunk-find.util.d.ts
+type PaginateOption$1 = {
+  default?: number;
+  max?: number;
+};
+type ChunkFindOptions<P extends Params = Params> = {
+  params?: P & {
+    paginate?: PaginateOption$1;
+  };
+};
+/**
+ * Use `for await` to iterate over chunks (pages) of results from a `find` method.
+ *
+ * This function is useful for processing large datasets in batches without loading everything into memory at once.
+ * It uses pagination to fetch results in chunks, yielding each page's data array.
+ *
+ * @example
+ * ```ts
+ * import { chunkFind } from 'feathers-utils/utils'
+ *
+ * const app = feathers()
+ *
+ * // Assuming 'users' service has many records
+ * for await (const users of chunkFind(app, 'users', {
+ *  params: { query: { active: true }, // Custom query parameters
+ * } })) {
+ *  console.log(users) // Process each chunk of user records
+ * }
+ * ```
+ *
+ * @see https://utils.feathersjs.com/utils/chunk-find.html
+ */
+declare function chunkFind<Services, Path extends KeyOf<Services>, Service extends Services[Path] = Services[Path], P extends Params = InferFindParams<Service>, Item = InferFindResultSingle<Service>>(app: Application<Services>, servicePath: Path, options?: ChunkFindOptions<P>): AsyncGenerator<Item[], void, unknown>;
+//#endregion
 //#region src/utils/context-to-json/context-to-json.util.d.ts
 /**
  * Converts a FeathersJS HookContext to a plain JSON object by calling `toJSON()` if available.
@@ -308,6 +310,61 @@ type IterateFindOptions<P extends Params = Params> = {
  */
 declare function iterateFind<Services, Path extends KeyOf<Services>, Service extends Services[Path] = Services[Path], P extends Params = InferFindParams<Service>, Item = InferFindResultSingle<Service>>(app: Application<Services>, servicePath: Path, options?: IterateFindOptions<P>): AsyncGenerator<Item, void, unknown>;
 //#endregion
+//#region src/utils/merge-query/merge-query.util.d.ts
+type MergeQueryMode = 'target' | 'source' | 'combine' | 'intersect';
+interface MergeQueryOptions {
+  /**
+   * How to merge query properties that both queries constrain.
+   *
+   * - `combine` (default): broaden — the two queries always become branches of an `$or`.
+   * - `intersect`: narrow — non-conflicting properties merge flat, conflicts become an `$and`.
+   * - `target`: keep the target's value on conflict.
+   * - `source`: keep the source's value on conflict.
+   */
+  mode?: MergeQueryMode;
+}
+/**
+ * Properties are combined with a logical operator rather than merged at the value
+ * level, so the result is always a valid query: `combine` always wraps the two
+ * queries in `$or` (broaden — OR has no flat form), while `intersect` merges
+ * non-conflicting properties flat and wraps conflicts in `$and` (narrow). The
+ * special filters `$select`, `$limit`, `$skip` and `$sort` are merged separately.
+ * Inputs are never mutated.
+ *
+ * This is well suited to merging a client-provided query with a server-side
+ * restriction inside a hook.
+ *
+ * @param target Query to be merged into
+ * @param source Query to be merged from
+ * @param options
+ * @returns the merged query
+ *
+ * @example
+ * ```ts
+ * import { mergeQuery } from 'feathers-utils/utils'
+ *
+ * // combine (default): the two queries always become an $or
+ * mergeQuery({ id: 1 }, { id: 2 })
+ * // => { $or: [{ id: 1 }, { id: 2 }] }
+ *
+ * mergeQuery({ status: 'active' }, { authorId: 5 })
+ * // => { $or: [{ status: 'active' }, { authorId: 5 }] }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // intersect: non-conflicting properties merge flat, conflicts become an $and
+ * mergeQuery({ status: 'active' }, { authorId: 5 }, { mode: 'intersect' })
+ * // => { status: 'active', authorId: 5 }
+ *
+ * mergeQuery({ id: 1 }, { id: 2 }, { mode: 'intersect' })
+ * // => { $and: [{ id: 1 }, { id: 2 }] }
+ * ```
+ *
+ * @see https://utils.feathersjs.com/utils/merge-query.html
+ */
+declare function mergeQuery(target: Query, source: Query, options?: MergeQueryOptions): Query;
+//#endregion
 //#region src/utils/patch-batch/patch-batch.util.d.ts
 type PatchBatchOptions<IdKey extends string> = {
   /** the key of the id property */id?: IdKey;
@@ -340,6 +397,48 @@ type PatchBatchResultItem<T = Record<string, unknown>, P = Params> = [Id | null,
  */
 declare function patchBatch<T extends Record<string, any>, IdKey extends KeyOf<T>, P extends Params, R extends Omit<T, IdKey> = Omit<T, IdKey>>(items: T[], options?: PatchBatchOptions<IdKey>): PatchBatchResultItem<R, P>[];
 //#endregion
+//#region src/utils/query-defaults/query-defaults.util.d.ts
+/**
+ * Adds default properties to a Feathers query — but only for fields the query does
+ * not already constrain. Presence is checked with {@link queryHasProperty}, so a field
+ * referenced anywhere (including nested in `$and`/`$or`/`$nor`) is left untouched and
+ * the caller keeps control over it. The query is treated as the `data` equivalent of
+ * the `defaults` transformer. Each default is applied independently (per-field).
+ *
+ * @example
+ * ```ts
+ * import { queryDefaults } from 'feathers-utils/utils'
+ *
+ * queryDefaults({ status: 'active' }, { isTemplate: false })
+ * // => { status: 'active', isTemplate: false }
+ *
+ * queryDefaults({ $or: [{ isTemplate: true }] }, { isTemplate: false })
+ * // => { $or: [{ isTemplate: true }] } (untouched — already referenced)
+ * ```
+ *
+ * @see https://utils.feathersjs.com/utils/query-defaults.html
+ */
+declare const queryDefaults: (query: Query | undefined, defaults: Query) => Query;
+//#endregion
+//#region src/utils/query-has-property/query-has-property.util.d.ts
+/**
+ * Checks whether a Feathers query contains one or more properties — including
+ * properties nested inside `$and`/`$or`/`$nor` arrays. Returns `true` as soon as
+ * any of the given property names is found. The query is not mutated.
+ *
+ * @example
+ * ```ts
+ * import { queryHasProperty } from 'feathers-utils/utils'
+ *
+ * queryHasProperty({ isTemplate: true }, 'isTemplate') // true
+ * queryHasProperty({ $or: [{ isTemplate: true }] }, 'isTemplate') // true
+ * queryHasProperty({ age: { $gt: 18 } }, ['isTemplate', 'status']) // false
+ * ```
+ *
+ * @see https://utils.feathersjs.com/utils/query-has-property.html
+ */
+declare const queryHasProperty: (query: Query, property: MaybeArray<string>) => boolean;
+//#endregion
 //#region src/utils/replace-data/replace-data.util.d.ts
 /**
  * Replaces `context.data` wholesale with the given items, preserving the original
@@ -403,6 +502,32 @@ declare function replaceResult<H extends HookContext = HookContext>(context: H,
  */
 declare const skipResult: <H extends HookContext = HookContext>(context: H) => H;
 //#endregion
+//#region src/utils/sort-query-properties/sort-query-properties.util.d.ts
+/**
+ * Recursively normalizes a Feathers query object for order-independent comparison.
+ * Sorts object keys and sorts arrays within `$or`, `$and`, `$nor`, `$not`, `$in`,
+ * and `$nin` operators so that different orderings produce the same result.
+ *
+ * This is useful for generating stable cache keys where
+ * `{ $or: [{ a: 1 }, { b: 2 }] }` and `{ $or: [{ b: 2 }, { a: 1 }] }`
+ * should be treated as equivalent.
+ *
+ * @example
+ * ```ts
+ * import { sortQueryProperties } from 'feathers-utils/utils'
+ *
+ * const normalized = sortQueryProperties({
+ *   $or: [{ name: 'Jane' }, { name: 'John' }],
+ *   age: { $in: [30, 25] },
+ * })
+ * // => { $or: [{ name: 'John' }, { name: 'Jane' }], age: { $in: [25, 30] } }
+ * // (sorted by stable stringify comparison)
+ * ```
+ *
+ * @see https://utils.feathersjs.com/utils/sort-query-properties.html
+ */
+declare const sortQueryProperties: <Q extends Query>(query: Q) => Q;
+//#endregion
 //#region src/utils/to-paginated/to-paginated.util.d.ts
 /**
  * Ensures a result is in Feathers paginated format (`{ total, limit, skip, data }`).
@@ -438,32 +563,6 @@ declare function toPaginated<R>(result: R[] | Paginated<R>): Paginated<R>;
  */
 declare const transformParams: <P extends Params = Params>(params: P, fn: TransformParamsFn<P> | undefined) => P;
 //#endregion
-//#region src/utils/sort-query-properties/sort-query-properties.util.d.ts
-/**
- * Recursively normalizes a Feathers query object for order-independent comparison.
- * Sorts object keys and sorts arrays within `$or`, `$and`, `$nor`, `$not`, `$in`,
- * and `$nin` operators so that different orderings produce the same result.
- *
- * This is useful for generating stable cache keys where
- * `{ $or: [{ a: 1 }, { b: 2 }] }` and `{ $or: [{ b: 2 }, { a: 1 }] }`
- * should be treated as equivalent.
- *
- * @example
- * ```ts
- * import { sortQueryProperties } from 'feathers-utils/utils'
- *
- * const normalized = sortQueryProperties({
- *   $or: [{ name: 'Jane' }, { name: 'John' }],
- *   age: { $in: [30, 25] },
- * })
- * // => { $or: [{ name: 'John' }, { name: 'Jane' }], age: { $in: [25, 30] } }
- * // (sorted by stable stringify comparison)
- * ```
- *
- * @see https://utils.feathersjs.com/utils/sort-query-properties.html
- */
-declare const sortQueryProperties: <Q extends Query>(query: Q) => Q;
-//#endregion
 //#region src/utils/wait-for-service-event/wait-for-service-event.util.d.ts
 /**
  * The standard Feathers service events, plus any custom event name a service
@@ -539,12 +638,18 @@ type WalkQueryOptions = {
   operator: string | undefined;
   value: any;
   path: (string | number)[];
+  /**
+   * Stops the traversal. Any replacement value returned from the current walker
+   * call is still applied, but no further properties are visited.
+   */
+  stop: () => void;
 };
 type WalkQueryCallback = (options: WalkQueryOptions) => any;
 /**
  * Walks every property of a Feathers query (including nested `$and`/`$or`/`$nor` arrays)
  * and calls the `walker` function for each one. The walker receives the property name, operator,
- * value, and path, and can return a replacement value. Returns a new query only if changes were made.
+ * value, path, and a `stop` function, and can return a replacement value. Calling `stop()` halts
+ * the traversal early. Returns a new query only if changes were made.
  *
  * @example
  * ```ts
@@ -556,6 +661,18 @@ type WalkQueryCallback = (options: WalkQueryOptions) => any;
  * // => { age: { $gt: 18 } }
  * ```
  *
+ * @example
+ * ```ts
+ * // stop early once a property is found
+ * let found = false
+ * walkQuery(query, ({ property, stop }) => {
+ *   if (property === 'isTemplate') {
+ *     found = true
+ *     stop()
+ *   }
+ * })
+ * ```
+ *
  * @see https://utils.feathersjs.com/utils/walk-query.html
  */
 declare const walkQuery: <Q extends Query>(query: Q, walker: WalkQueryCallback) => Q;
@@ -585,5 +702,5 @@ type ZipDataResultItem<D, R> = {
  */
 declare function zipDataResult<H extends HookContext, D extends DataSingleHookContext<H> = DataSingleHookContext<H>, R extends ResultSingleHookContext<H> = ResultSingleHookContext<H>>(context: H, options?: ZipDataResultOptions): ZipDataResultItem<D, R>[];
 //#endregion
-export { defineHooks as A, GetResultIsArrayOptions as C, getExposedMethods as D, getPaginate as E, isContext as F, addToQuery as I, chunkFind as L, CheckContextOptions as M, checkContext as N, GetDataIsArrayReturn as O, IsContextOptions as P, SkipHookName as R, iterateFind as S, getResultIsArray as T, replaceResult as _, WalkQueryOptions as a, PatchBatchResultItem as b, WaitForServiceEventDefaults as c, waitForServiceEvent as d, sortQueryProperties as f, ReplaceResultOptions as g, skipResult as h, WalkQueryCallback as i, contextToJson as j, getDataIsArray as k, WaitForServiceEventOptions as l, toPaginated as m, ZipDataResultOptions as n, walkQuery as o, transformParams as p, zipDataResult as r, ServiceEventName as s, ZipDataResultItem as t, WaitForServiceEventResult as u, replaceData as v, GetResultIsArrayReturn as w, patchBatch as x, PatchBatchOptions as y, addSkip as z };
-//# sourceMappingURL=index-DKA0E_ad.d.mts.map
+export { getResultIsArray as A, IsContextOptions as B, patchBatch as C, iterateFind as D, mergeQuery as E, defineHooks as F, addToQuery as H, contextToJson as I, chunkFind as L, getExposedMethods as M, GetDataIsArrayReturn as N, GetResultIsArrayOptions as O, getDataIsArray as P, CheckContextOptions as R, PatchBatchResultItem as S, MergeQueryOptions as T, SkipHookName as U, isContext as V, addSkip as W, replaceResult as _, WalkQueryOptions as a, queryDefaults as b, WaitForServiceEventDefaults as c, waitForServiceEvent as d, transformParams as f, ReplaceResultOptions as g, skipResult as h, WalkQueryCallback as i, getPaginate as j, GetResultIsArrayReturn as k, WaitForServiceEventOptions as l, sortQueryProperties as m, ZipDataResultOptions as n, walkQuery as o, toPaginated as p, zipDataResult as r, ServiceEventName as s, ZipDataResultItem as t, WaitForServiceEventResult as u, replaceData as v, MergeQueryMode as w, PatchBatchOptions as x, queryHasProperty as y, checkContext as z };
+//# sourceMappingURL=index-C6MN6wag.d.mts.map

package/dist/index.d.mts

@@ -3,8 +3,8 @@ import { C as InferResultFromPath, D as InferUpdateResultFromPath, E as InferUpd
 import { a as IffHook, i as skippable, n as ThrowIfOptions, o as iff, r as throwIf, s as iffElse, t as unless } from "./unless.hook-CVw1wX_x.mjs";
 import { i as transformData, n as transformResult, r as transformQuery, t as TransformResultOptions } from "./transform-result.hook-C9wMLWs2.mjs";
 import { i as resolveData, n as resolveQuery, r as resolveResult, t as resolve } from "./resolve-Cmxskunj.mjs";
-import { CacheEvent, CacheOptions, CheckMultiOptions, CreateRelatedOptions, FindOrCreateOptions, HookSetDataOptions, OnDeleteAction, OnDeleteOptions, ParamsForServerOptions, PreventChangesOptions, RateLimitOptions, SetFieldOptions, SetResultOptions, SoftDeleteOptionFunction, SoftDeleteOptions, StashableOptions, ThrowIfIsIsProviderOptions, ThrowIfIsMultiOptions, TraverseOptions, cache, checkMulti, checkRequired, combine, createRelated, debug, disablePagination, disallow, findOrCreate, onDelete, paramsForServer, paramsFromClient, paramsFromClientOptions, preventChanges, rateLimit, setData, setField, setResult, setSlug, softDelete, stashable, throwIfIsMulti, throwIfIsProvider, traverse } from "./hooks.mjs";
-import { A as defineHooks, C as GetResultIsArrayOptions, D as getExposedMethods, E as getPaginate, I as addToQuery, L as chunkFind, M as CheckContextOptions, N as checkContext, O as GetDataIsArrayReturn, R as SkipHookName, S as iterateFind, T as getResultIsArray, _ as replaceResult, a as WalkQueryOptions, b as PatchBatchResultItem, c as WaitForServiceEventDefaults, d as waitForServiceEvent, f as sortQueryProperties, g as ReplaceResultOptions, h as skipResult, i as WalkQueryCallback, j as contextToJson, k as getDataIsArray, l as WaitForServiceEventOptions, m as toPaginated, n as ZipDataResultOptions, o as walkQuery, p as transformParams, r as zipDataResult, s as ServiceEventName, t as ZipDataResultItem, u as WaitForServiceEventResult, v as replaceData, w as GetResultIsArrayReturn, x as patchBatch, y as PatchBatchOptions, z as addSkip } from "./index-DKA0E_ad.mjs";
+import { CacheEvent, CacheOptions, CheckMultiOptions, CreateRelatedOptions, FindOrCreateOptions, HookSetDataOptions, MuteEventOptions, OnDeleteAction, OnDeleteOptions, ParamsForServerOptions, PreventChangesOptions, RateLimitOptions, SetFieldOptions, SetResultOptions, SoftDeleteOptionFunction, SoftDeleteOptions, StashableOptions, ThrowIfIsIsProviderOptions, ThrowIfIsMultiOptions, TraverseOptions, cache, checkMulti, checkRequired, combine, createRelated, debug, disablePagination, disallow, findOrCreate, muteEvent, onDelete, paramsForServer, paramsFromClient, paramsFromClientOptions, preventChanges, rateLimit, setData, setField, setQueryDefaults, setResult, setSlug, softDelete, stashable, throwIfIsMulti, throwIfIsProvider, traverse } from "./hooks.mjs";
+import { A as getResultIsArray, C as patchBatch, D as iterateFind, E as mergeQuery, F as defineHooks, H as addToQuery, I as contextToJson, L as chunkFind, M as getExposedMethods, N as GetDataIsArrayReturn, O as GetResultIsArrayOptions, P as getDataIsArray, R as CheckContextOptions, S as PatchBatchResultItem, T as MergeQueryOptions, U as SkipHookName, W as addSkip, _ as replaceResult, a as WalkQueryOptions, b as queryDefaults, c as WaitForServiceEventDefaults, d as waitForServiceEvent, f as transformParams, g as ReplaceResultOptions, h as skipResult, i as WalkQueryCallback, j as getPaginate, k as GetResultIsArrayReturn, l as WaitForServiceEventOptions, m as sortQueryProperties, n as ZipDataResultOptions, o as walkQuery, p as toPaginated, r as zipDataResult, s as ServiceEventName, t as ZipDataResultItem, u as WaitForServiceEventResult, v as replaceData, w as MergeQueryMode, x as PatchBatchOptions, y as queryHasProperty, z as checkContext } from "./index-C6MN6wag.mjs";
 import { n as mutateResult, r as mutateData, t as MutateResultOptions } from "./mutate-result.util-DR9JMsvl.mjs";
 import { Paginated, PaginationOptions } from "@feathersjs/feathers";
 
@@ -15,5 +15,5 @@ type PaginatedOrArray<R, P = undefined> = P extends {
   paginate: PaginationOptions;
 } ? Paginated<R> : Paginated<R> | R[];
 //#endregion
-export { CacheEvent, CacheOptions, CheckContextOptions, CheckMultiOptions, ContextFunction, ContextFunctionAsync, ContextFunctionSync, CreateRelatedOptions, DataSingleHookContext, DefaultsInput, DispatchOption, FieldKey, FindOrCreateOptions, GetDataIsArrayReturn, GetResultIsArrayOptions, GetResultIsArrayReturn, GetService, HookFunction, HookSetDataOptions, HookType, IffHook, InferCreateData, InferCreateDataFromPath, InferCreateDataSingle, InferCreateDataSingleFromPath, InferCreateResult, InferCreateResultFromPath, InferCreateResultSingle, InferCreateResultSingleFromPath, InferDataFromPath, InferFindParams, InferFindResult, InferFindResultFromPath, InferFindResultSingle, InferGetResult, InferGetResultFromPath, InferPatchData, InferPatchDataFromPath, InferPatchResult, InferPatchResultFromPath, InferRemoveResult, InferRemoveResultFromPath, InferResultFromPath, InferUpdateData, InferUpdateDataFromPath, InferUpdateResult, InferUpdateResultFromPath, MethodName, MutateResultOptions, OnDeleteAction, OnDeleteOptions, PaginatedOrArray, ParamsForServerOptions, PatchBatchOptions, PatchBatchResultItem, PredicateContextAsync, PredicateContextSync, PredicateFn, PredicateItemWithContext, PreventChangesOptions, RateLimitOptions, ReplaceResultOptions, ResultSingleHookContext, ServiceEventName, SetFieldOptions, SetResultOptions, SkipHookName, SoftDeleteOptionFunction, SoftDeleteOptions, StashableOptions, StringFieldKey, ThrowIfIsIsProviderOptions, ThrowIfIsMultiOptions, ThrowIfOptions, TransformParamsFn, TransformResultOptions, TransformerFn, TransformerInputFn, TransportName, TraverseOptions, UnwrapPaginated, UnwrapPaginatedOrArray, WaitForServiceEventDefaults, WaitForServiceEventOptions, WaitForServiceEventResult, WalkQueryCallback, WalkQueryOptions, ZipDataResultItem, ZipDataResultOptions, addSkip, addToQuery, cache, checkContext, checkMulti, checkRequired, chunkFind, combine, contextToJson, createRelated, debug, defineHooks, disablePagination, disallow, findOrCreate, getDataIsArray, getExposedMethods, getPaginate, getResultIsArray, hookTypes, iff, iff as when, iffElse, iterateFind, methodNames, mutateData, mutateResult, onDelete, paramsForServer, paramsFromClient, paramsFromClientOptions, patchBatch, preventChanges, rateLimit, replaceData, replaceResult, resolve, resolveData, resolveQuery, resolveResult, setData, setField, setResult, setSlug, skipResult, skippable, softDelete, sortQueryProperties, stashable, throwIf, throwIfIsMulti, throwIfIsProvider, toPaginated, transformData, transformParams, transformQuery, transformResult, traverse, unless, waitForServiceEvent, walkQuery, zipDataResult };
+export { CacheEvent, CacheOptions, CheckContextOptions, CheckMultiOptions, ContextFunction, ContextFunctionAsync, ContextFunctionSync, CreateRelatedOptions, DataSingleHookContext, DefaultsInput, DispatchOption, FieldKey, FindOrCreateOptions, GetDataIsArrayReturn, GetResultIsArrayOptions, GetResultIsArrayReturn, GetService, HookFunction, HookSetDataOptions, HookType, IffHook, InferCreateData, InferCreateDataFromPath, InferCreateDataSingle, InferCreateDataSingleFromPath, InferCreateResult, InferCreateResultFromPath, InferCreateResultSingle, InferCreateResultSingleFromPath, InferDataFromPath, InferFindParams, InferFindResult, InferFindResultFromPath, InferFindResultSingle, InferGetResult, InferGetResultFromPath, InferPatchData, InferPatchDataFromPath, InferPatchResult, InferPatchResultFromPath, InferRemoveResult, InferRemoveResultFromPath, InferResultFromPath, InferUpdateData, InferUpdateDataFromPath, InferUpdateResult, InferUpdateResultFromPath, MergeQueryMode, MergeQueryOptions, MethodName, MutateResultOptions, MuteEventOptions, OnDeleteAction, OnDeleteOptions, PaginatedOrArray, ParamsForServerOptions, PatchBatchOptions, PatchBatchResultItem, PredicateContextAsync, PredicateContextSync, PredicateFn, PredicateItemWithContext, PreventChangesOptions, RateLimitOptions, ReplaceResultOptions, ResultSingleHookContext, ServiceEventName, SetFieldOptions, SetResultOptions, SkipHookName, SoftDeleteOptionFunction, SoftDeleteOptions, StashableOptions, StringFieldKey, ThrowIfIsIsProviderOptions, ThrowIfIsMultiOptions, ThrowIfOptions, TransformParamsFn, TransformResultOptions, TransformerFn, TransformerInputFn, TransportName, TraverseOptions, UnwrapPaginated, UnwrapPaginatedOrArray, WaitForServiceEventDefaults, WaitForServiceEventOptions, WaitForServiceEventResult, WalkQueryCallback, WalkQueryOptions, ZipDataResultItem, ZipDataResultOptions, addSkip, addToQuery, cache, checkContext, checkMulti, checkRequired, chunkFind, combine, contextToJson, createRelated, debug, defineHooks, disablePagination, disallow, findOrCreate, getDataIsArray, getExposedMethods, getPaginate, getResultIsArray, hookTypes, iff, iff as when, iffElse, iterateFind, mergeQuery, methodNames, mutateData, mutateResult, muteEvent, onDelete, paramsForServer, paramsFromClient, paramsFromClientOptions, patchBatch, preventChanges, queryDefaults, queryHasProperty, rateLimit, replaceData, replaceResult, resolve, resolveData, resolveQuery, resolveResult, setData, setField, setQueryDefaults, setResult, setSlug, skipResult, skippable, softDelete, sortQueryProperties, stashable, throwIf, throwIfIsMulti, throwIfIsProvider, toPaginated, transformData, transformParams, transformQuery, transformResult, traverse, unless, waitForServiceEvent, walkQuery, zipDataResult };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -1,9 +1,9 @@
-import { _ as combine, a as iffElse, f as getPaginate, i as iff, n as skippable, r as unless, t as throwIf } from "./predicates-puYa4nkf.mjs";
-import { a as toPaginated, c as iterateFind, d as contextToJson, f as checkContext, g as sortQueryProperties, h as addSkip, i as transformParams, l as getExposedMethods, m as chunkFind, n as walkQuery, o as skipResult, p as addToQuery, r as waitForServiceEvent, s as patchBatch, t as zipDataResult, u as defineHooks } from "./utils-Br6DNQ1B.mjs";
-import { S as cache, _ as findOrCreate, a as softDelete, b as checkRequired, c as setField, d as preventChanges, f as paramsFromClient, g as disablePagination, h as disallow, i as stashable, l as setData, m as onDelete, n as throwIfIsProvider, o as setSlug, p as paramsForServer, r as throwIfIsMulti, s as setResult, t as traverse, u as rateLimit, v as debug, x as checkMulti, y as createRelated } from "./hooks-Bg5XWcV7.mjs";
-import { a as getResultIsArray, i as replaceData, n as replaceResult, o as getDataIsArray, r as mutateData, t as mutateResult } from "./mutate-result.util-Dqzepn1M.mjs";
-import { n as transformQuery, r as transformData, t as transformResult } from "./transform-result.hook-B65pTRJO.mjs";
-import { i as resolveData, n as resolveQuery, r as resolveResult, t as resolve } from "./resolve-B9hRleHY.mjs";
+import { _ as combine, a as iffElse, f as getPaginate, i as iff, n as throwIf, r as skippable, t as unless } from "./predicates-NOnUyMic.mjs";
+import { _ as addToQuery, a as skipResult, c as walkQuery, d as iterateFind, f as getExposedMethods, g as checkContext, h as chunkFind, i as toPaginated, l as patchBatch, m as contextToJson, n as waitForServiceEvent, o as queryDefaults, p as defineHooks, r as transformParams, s as queryHasProperty, t as zipDataResult, u as mergeQuery, v as addSkip, y as sortQueryProperties } from "./utils-DByCpAsf.mjs";
+import { C as checkMulti, S as checkRequired, _ as findOrCreate, a as softDelete, b as debug, c as setQueryDefaults, d as rateLimit, f as preventChanges, g as muteEvent, h as onDelete, i as stashable, l as setField, m as paramsForServer, n as throwIfIsProvider, o as setSlug, p as paramsFromClient, r as throwIfIsMulti, s as setResult, t as traverse, u as setData, v as disallow, w as cache, x as createRelated, y as disablePagination } from "./hooks-DpFQfcFa.mjs";
+import { a as getResultIsArray, i as replaceData, n as replaceResult, o as getDataIsArray, r as mutateData, t as mutateResult } from "./mutate-result.util-C0nY6L7i.mjs";
+import { n as transformQuery, r as transformData, t as transformResult } from "./transform-result.hook-V2QYN2K0.mjs";
+import { i as resolveData, n as resolveQuery, r as resolveResult, t as resolve } from "./resolve-BflgIVD8.mjs";
 //#region src/types.ts
 const hookTypes = [
 	"around",
@@ -20,6 +20,6 @@ const methodNames = [
 	"remove"
 ];
 //#endregion
-export { addSkip, addToQuery, cache, checkContext, checkMulti, checkRequired, chunkFind, combine, contextToJson, createRelated, debug, defineHooks, disablePagination, disallow, findOrCreate, getDataIsArray, getExposedMethods, getPaginate, getResultIsArray, hookTypes, iff, iff as when, iffElse, iterateFind, methodNames, mutateData, mutateResult, onDelete, paramsForServer, paramsFromClient, patchBatch, preventChanges, rateLimit, replaceData, replaceResult, resolve, resolveData, resolveQuery, resolveResult, setData, setField, setResult, setSlug, skipResult, skippable, softDelete, sortQueryProperties, stashable, throwIf, throwIfIsMulti, throwIfIsProvider, toPaginated, transformData, transformParams, transformQuery, transformResult, traverse, unless, waitForServiceEvent, walkQuery, zipDataResult };
+export { addSkip, addToQuery, cache, checkContext, checkMulti, checkRequired, chunkFind, combine, contextToJson, createRelated, debug, defineHooks, disablePagination, disallow, findOrCreate, getDataIsArray, getExposedMethods, getPaginate, getResultIsArray, hookTypes, iff, iff as when, iffElse, iterateFind, mergeQuery, methodNames, mutateData, mutateResult, muteEvent, onDelete, paramsForServer, paramsFromClient, patchBatch, preventChanges, queryDefaults, queryHasProperty, rateLimit, replaceData, replaceResult, resolve, resolveData, resolveQuery, resolveResult, setData, setField, setQueryDefaults, setResult, setSlug, skipResult, skippable, softDelete, sortQueryProperties, stashable, throwIf, throwIfIsMulti, throwIfIsProvider, toPaginated, transformData, transformParams, transformQuery, transformResult, traverse, unless, waitForServiceEvent, walkQuery, zipDataResult };
 
 //# sourceMappingURL=index.mjs.map

package/dist/{internal.utils-BMzV_-xp.mjs → internal.utils-BBB-b6Ud.mjs}

@@ -15,6 +15,20 @@ function traverse(items, converter) {
 	});
 }
 //#endregion
+//#region src/common/is-empty-object.ts
+/**
+* Returns `true` only for a plain empty object (`{}`). Arrays, `null`, primitives
+* and non-empty objects are all `false`.
+*
+* @example
+* ```ts
+* isEmptyObject({}) // => true
+* isEmptyObject({ a: 1 }) // => false
+* isEmptyObject([]) // => false
+* ```
+*/
+const isEmptyObject = (obj) => !!obj && typeof obj === "object" && !Array.isArray(obj) && Object.keys(obj).length === 0;
+//#endregion
 //#region src/common/index.ts
 /**
 * Type guard that checks if a value is a `Promise` instance.
@@ -50,6 +64,6 @@ const early = (context, next) => {
 	if (next) return next(context);
 };
 //#endregion
-export { traverse as a, isPromise as i, hasOwnProperty as n, toArray as r, early as t };
+export { isEmptyObject as a, isPromise as i, hasOwnProperty as n, traverse as o, toArray as r, early as t };
 
-//# sourceMappingURL=internal.utils-BMzV_-xp.mjs.map
+//# sourceMappingURL=internal.utils-BBB-b6Ud.mjs.map

package/dist/internal.utils-BBB-b6Ud.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.utils-BBB-b6Ud.mjs","names":[],"sources":["../src/common/traverse.ts","../src/common/is-empty-object.ts","../src/common/index.ts","../src/internal.utils.ts"],"sourcesContent":["import _traverse from 'neotraverse'\n\n/**\n * Recursively traverses items (or an array of items) and applies a converter function\n * to every node using `neotraverse`. Modifications happen in place.\n *\n * @example\n * ```ts\n * traverse(items, function () { if (this.key === 'secret') this.remove() })\n * ```\n */\nexport function traverse<T extends Record<string, any>>(\n  items: T | T[],\n  converter: (item: T) => void,\n) {\n  ;(Array.isArray(items) ? items : [items]).forEach((item) => {\n    _traverse(item).forEach(converter) // replacement is in place\n  })\n}\n","/**\n * Returns `true` only for a plain empty object (`{}`). Arrays, `null`, primitives\n * and non-empty objects are all `false`.\n *\n * @example\n * ```ts\n * isEmptyObject({}) // => true\n * isEmptyObject({ a: 1 }) // => false\n * isEmptyObject([]) // => false\n * ```\n */\nexport const isEmptyObject = (obj: unknown): boolean =>\n  !!obj &&\n  typeof obj === 'object' &&\n  !Array.isArray(obj) &&\n  Object.keys(obj).length === 0\n\nif (import.meta.vitest) {\n  const { describe, it, expect } = import.meta.vitest\n\n  describe('isEmptyObject', () => {\n    it('is true only for a plain empty object', () => {\n      expect(isEmptyObject({})).toBe(true)\n    })\n\n    it('is false for a non-empty object', () => {\n      expect(isEmptyObject({ a: 1 })).toBe(false)\n    })\n\n    it('is false for arrays, null, undefined and primitives', () => {\n      expect(isEmptyObject([])).toBe(false)\n      expect(isEmptyObject(null)).toBe(false)\n      expect(isEmptyObject(undefined)).toBe(false)\n      expect(isEmptyObject('')).toBe(false)\n      expect(isEmptyObject(0)).toBe(false)\n    })\n  })\n}\n","/**\n * Type guard that checks if a value is a `Promise` instance.\n *\n * @example\n * ```ts\n * const result = maybeSyncFn()\n * if (isPromise(result)) {\n *   await result\n * }\n * ```\n */\nexport function isPromise(p: any): p is Promise<any> {\n  return p instanceof Promise\n}\n\nexport { traverse } from './traverse.js'\nexport { clone } from './clone.js'\nexport { isEmptyObject } from './is-empty-object.js'\n","import type { HookContext } from '@feathersjs/feathers'\n\nexport const hasOwnProperty = (\n  obj: Record<string, unknown>,\n  ...keys: string[]\n): boolean => {\n  return keys.some((x) => Object.prototype.hasOwnProperty.call(obj, x))\n}\n\nexport type MaybeArray<T> = T | readonly T[]\nexport type UnpackMaybeArray<T> = T extends readonly (infer E)[] ? E : T\n/**\n * Normalizes a value or array into an array. The returned array MUST be treated\n * as read-only — when the input is already an array it is returned as-is (no copy)\n * to avoid a per-call allocation on hook hot paths.\n */\nexport const toArray = <T>(value: T | readonly T[]): T[] =>\n  Array.isArray(value) ? (value as T[]) : [value as T]\n\nexport type Promisable<T> = T | Promise<T>\nexport type KeyOf<T> = Extract<keyof T, string>\n\nexport type UnwrapArray<T> = T extends Array<infer U> ? U : T\n\nexport type IsAny<T> = 0 extends 1 & T ? true : false\n\nexport type AnyFallback<T, Fallback> = IsAny<T> extends true ? Fallback : T\n\nexport type NeverFallback<Never, Fallback> = [Never] extends [never]\n  ? Fallback\n  : Never\n\nexport type KeyOfOrDotNotation<D> = KeyOf<D> | `${KeyOf<D>}.${string}`\n\n/**+\n * Can be used to early return a hook.\n *\n * If it's an around hook, it will call `next` if provided.\n */\nexport const early = <H extends HookContext>(\n  context: H,\n  next?: (context: H) => Promisable<void>,\n): Promisable<void> => {\n  if (next) {\n    return next(context)\n  }\n  return\n}\n"],"mappings":";;;;;;;;;;;AAWA,SAAgB,SACd,OACA,WACA;CACC,CAAC,MAAM,QAAQ,KAAK,IAAI,QAAQ,CAAC,KAAK,EAAA,CAAG,SAAS,SAAS;EAC1D,UAAU,IAAI,CAAC,CAAC,QAAQ,SAAS;CACnC,CAAC;AACH;;;;;;;;;;;;;;ACPA,MAAa,iBAAiB,QAC5B,CAAC,CAAC,OACF,OAAO,QAAQ,YACf,CAAC,MAAM,QAAQ,GAAG,KAClB,OAAO,KAAK,GAAG,CAAC,CAAC,WAAW;;;;;;;;;;;;;;ACJ9B,SAAgB,UAAU,GAA2B;CACnD,OAAO,aAAa;AACtB;;;ACXA,MAAa,kBACX,KACA,GAAG,SACS;CACZ,OAAO,KAAK,MAAM,MAAM,OAAO,UAAU,eAAe,KAAK,KAAK,CAAC,CAAC;AACtE;;;;;;AASA,MAAa,WAAc,UACzB,MAAM,QAAQ,KAAK,IAAK,QAAgB,CAAC,KAAU;;;;;;AAsBrD,MAAa,SACX,SACA,SACqB;CACrB,IAAI,MACF,OAAO,KAAK,OAAO;AAGvB"}