@warp-drive/utilities 5.10.0-alpha.19 → 5.10.0-alpha.20

package/dist/unpkg/prod/rest.js.map

@@ -1 +1 @@
-{"version":3,"file":"rest.js","names":["recordIdentifierFor","buildBaseURL","camelize","pluralize","copyForwardUrlOptions","isExisting","identifier","id","type","deleteRecord","record","options","urlOptions","op","resourcePath","url","headers","Headers","append","method","data","records","createRecord","updateRecord","patch"],"sources":["../../../src/-private/rest/find-record.ts","../../../src/-private/rest/query.ts","../../../src/-private/rest/save-record.ts"],"sourcesContent":["import type { ReactiveDataDocument } from '@warp-drive/core/reactive';\nimport type { TypeFromInstance } from '@warp-drive/core/types/record';\nimport type {\n  FindRecordOptions,\n  FindRecordRequestOptions,\n  RemotelyAccessibleIdentifier,\n} from '@warp-drive/core/types/request';\nimport type { Meta } from '@warp-drive/core/types/spec/json-api-raw';\n\nimport { buildBaseURL, buildQueryParams, type FindRecordUrlOptions } from '../../index.ts';\nimport { camelize, pluralize } from '../../string';\nimport { copyForwardUrlOptions, extractCacheOptions } from '../builder-utils.ts';\n\n/**\n * Builds request options to fetch a single resource by a known id or identifier\n * configured for the url and header expectations of most REST APIs.\n *\n * See the [Builders](/guides/the-manual/requests/builders) guide for what request builders do and\n * when to use one.\n *\n * **Basic Usage**\n *\n * ```ts\n * import { findRecord } from '@warp-drive/utilities/rest';\n *\n * const data = await store.request(findRecord('person', '1'));\n * ```\n *\n * **With Options**\n *\n * ```ts\n * import { findRecord } from '@warp-drive/utilities/rest';\n *\n * const options = findRecord('person', '1', { include: ['pets', 'friends'] });\n * const data = await store.request(options);\n * ```\n *\n * **With an Identifier**\n *\n * ```ts\n * import { findRecord } from '@warp-drive/utilities/rest';\n *\n * const options = findRecord({ type: 'person', id: '1' }, { include: ['pets', 'friends'] });\n * const data = await store.request(options);\n * ```\n *\n * **Supplying Options to Modify the Request Behavior**\n *\n * The following options are supported:\n *\n * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.\n * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.\n * - `resourcePath` - The resource path to use for the request, defaults to pluralizing and camelCasing the supplied type\n * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this\n *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.\n * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the\n *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,\n *      defaulting to `false` if none is configured.\n * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)\n *\n * ```ts\n * import { findRecord } from '@warp-drive/utilities/rest';\n *\n * const options = findRecord('person', '1', { include: ['pets', 'friends'] }, { namespace: 'api/v2' });\n * const data = await store.request(options);\n * ```\n *\n * @summary Builds a `GET` request for one resource by type and id, using REST-style pluralized, camelCased URLs.\n * @public\n */\nexport function findRecord<T, M extends Meta | undefined = Meta | undefined, E extends object = object>(\n  identifier: RemotelyAccessibleIdentifier<TypeFromInstance<T>>,\n  options?: FindRecordOptions\n): FindRecordRequestOptions<ReactiveDataDocument<T, M, E>, T>;\nexport function findRecord(\n  identifier: RemotelyAccessibleIdentifier,\n  options?: FindRecordOptions\n): FindRecordRequestOptions;\nexport function findRecord<T, M extends Meta | undefined = Meta | undefined, E extends object = object>(\n  type: TypeFromInstance<T>,\n  id: string,\n  options?: FindRecordOptions\n): FindRecordRequestOptions<ReactiveDataDocument<T, M, E>, T>;\nexport function findRecord(type: string, id: string, options?: FindRecordOptions): FindRecordRequestOptions;\nexport function findRecord<T, M extends Meta | undefined = Meta | undefined, E extends object = object>(\n  arg1: TypeFromInstance<T> | RemotelyAccessibleIdentifier<TypeFromInstance<T>>,\n  arg2: string | FindRecordOptions | undefined,\n  arg3?: FindRecordOptions\n): FindRecordRequestOptions<ReactiveDataDocument<T, M, E>, T> {\n  const identifier: RemotelyAccessibleIdentifier<TypeFromInstance<T>> =\n    typeof arg1 === 'string' ? { type: arg1, id: arg2 as string } : arg1;\n  const options: FindRecordOptions = (typeof arg1 === 'string' ? arg3 : (arg2 as FindRecordOptions)) || {};\n  const cacheOptions = extractCacheOptions(options);\n  const urlOptions: FindRecordUrlOptions = {\n    identifier,\n    op: 'findRecord',\n    resourcePath: pluralize(camelize(identifier.type)),\n  };\n\n  copyForwardUrlOptions(urlOptions, options);\n\n  const url = buildBaseURL(urlOptions);\n  const headers = new Headers();\n  headers.append('Accept', 'application/json;charset=utf-8');\n\n  return {\n    url: options.include?.length\n      ? `${url}?${buildQueryParams({ include: options.include }, options.urlParamsSettings)}`\n      : url,\n    method: 'GET',\n    headers,\n    cacheOptions,\n    op: 'findRecord',\n    records: [identifier],\n  };\n}\n\n/** @deprecated use {@link ReactiveDataDocument} instead */\nexport type FindRecordResultDocument<\n  T,\n  M extends Meta | undefined = Meta | undefined,\n  E extends object = object,\n> = ReactiveDataDocument<T, M, E>;\n","import type { ReactiveDataDocument } from '@warp-drive/core/reactive';\nimport type { QueryParamsSource } from '@warp-drive/core/types/params';\nimport type { TypeFromInstance } from '@warp-drive/core/types/record';\nimport type { ConstrainedRequestOptions, QueryRequestOptions } from '@warp-drive/core/types/request';\nimport type { Meta } from '@warp-drive/core/types/spec/json-api-raw';\n\nimport { buildBaseURL, buildQueryParams, type QueryUrlOptions } from '../../index.ts';\nimport { camelize, pluralize } from '../../string';\nimport { copyForwardUrlOptions, extractCacheOptions } from '../builder-utils.ts';\n\n/**\n * Builds request options to query for resources, usually by a primary\n * type, configured for the url and header expectations of most REST APIs.\n *\n * See the [Builders](/guides/the-manual/requests/builders) guide for what request builders do and\n * when to use one.\n *\n * **Basic Usage**\n *\n * ```ts\n * import { query } from '@warp-drive/utilities/rest';\n *\n * const data = await store.request(query('person'));\n * ```\n *\n * **With Query Params**\n *\n * ```ts\n * import { query } from '@warp-drive/utilities/rest';\n *\n * const options = query('person', { include: ['pets', 'friends'] });\n * const data = await store.request(options);\n * ```\n *\n * **Supplying Options to Modify the Request Behavior**\n *\n * The following options are supported:\n *\n * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.\n * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.\n * - `resourcePath` - The resource path to use for the request, defaults to pluralizing and camelCasing the supplied type\n * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this\n *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.\n * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the\n *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,\n *      defaulting to `false` if none is configured.\n * - `urlParamsSettings` - an object containing options for how to serialize the query params (see `buildQueryParams`)\n *\n * ```ts\n * import { query } from '@warp-drive/utilities/rest';\n *\n * const options = query('person', { include: ['pets', 'friends'] }, { reload: true });\n * const data = await store.request(options);\n * ```\n *\n * @summary Builds a `GET` request that queries a resource type with query params, using REST-style URLs.\n * @public\n * @param identifier\n * @param query\n * @param options\n */\nexport function query<T, M extends Meta | undefined = Meta | undefined, E extends object = object>(\n  type: TypeFromInstance<T>,\n  query?: QueryParamsSource,\n  options?: ConstrainedRequestOptions\n): QueryRequestOptions<ReactiveDataDocument<T[], M, E>>;\nexport function query(\n  type: string,\n  query?: QueryParamsSource,\n  options?: ConstrainedRequestOptions\n): QueryRequestOptions;\nexport function query(\n  type: string,\n  // oxlint-disable-next-line no-shadow\n  query: QueryParamsSource = {},\n  options: ConstrainedRequestOptions = {}\n): QueryRequestOptions {\n  const cacheOptions = extractCacheOptions(options);\n  const urlOptions: QueryUrlOptions = {\n    identifier: { type },\n    op: 'query',\n    resourcePath: pluralize(camelize(type)),\n  };\n\n  copyForwardUrlOptions(urlOptions, options);\n\n  const url = buildBaseURL(urlOptions);\n  const headers = new Headers();\n  headers.append('Accept', 'application/json;charset=utf-8');\n  const queryString = buildQueryParams(query, options.urlParamsSettings);\n\n  return {\n    url: queryString ? `${url}?${queryString}` : url,\n    method: 'GET',\n    headers,\n    cacheOptions,\n    op: 'query',\n  };\n}\n","import { recordIdentifierFor } from '@warp-drive/core';\nimport { assert } from '@warp-drive/core/build-config/macros';\nimport type { ReactiveDataDocument } from '@warp-drive/core/reactive';\nimport type { PersistedResourceKey, ResourceKey } from '@warp-drive/core/types/identifier';\nimport type { TypedRecordInstance } from '@warp-drive/core/types/record';\nimport type {\n  ConstrainedRequestOptions,\n  CreateRequestOptions,\n  DeleteRequestOptions,\n  UpdateRequestOptions,\n} from '@warp-drive/core/types/request';\nimport type { Meta } from '@warp-drive/core/types/spec/json-api-raw';\n\nimport {\n  buildBaseURL,\n  type CreateRecordUrlOptions,\n  type DeleteRecordUrlOptions,\n  type UpdateRecordUrlOptions,\n} from '../../index.ts';\nimport { camelize, pluralize } from '../../string';\nimport { copyForwardUrlOptions } from '../builder-utils.ts';\n\nfunction isExisting(identifier: ResourceKey): identifier is PersistedResourceKey {\n  return 'id' in identifier && identifier.id !== null && 'type' in identifier && identifier.type !== null;\n}\n\n/**\n * Builds request options to delete record for resources,\n * configured for the url, method and header expectations of REST APIs.\n *\n * See the [Builders](/guides/the-manual/requests/builders) guide for what request builders do and\n * when to use one.\n *\n * **Basic Usage**\n *\n * ```ts\n * import { deleteRecord } from '@warp-drive/utilities/rest';\n *\n * const person = store.peekRecord('person', '1');\n *\n * // mark record as deleted\n * store.deleteRecord(person);\n *\n * // persist deletion\n * const data = await store.request(deleteRecord(person));\n * ```\n *\n * **Supplying Options to Modify the Request Behavior**\n *\n * The following options are supported:\n *\n * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.\n * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.\n * - `resourcePath` - The resource path to use for the request, defaults to pluralizing the supplied type\n * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this\n *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.\n * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the\n *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,\n *      defaulting to `false` if none is configured.\n * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)\n *\n * ```ts\n * import { deleteRecord } from '@warp-drive/utilities/rest';\n *\n * const person = store.peekRecord('person', '1');\n *\n * // mark record as deleted\n * store.deleteRecord(person);\n *\n * // persist deletion\n * const options = deleteRecord(person, { namespace: 'api/v1' });\n * const data = await store.request(options);\n * ```\n *\n * @summary Builds a `DELETE` request that persists deletion of an existing record, using REST-style URLs.\n * @public\n * @param record\n * @param options\n */\nexport function deleteRecord<T>(record: T, options?: ConstrainedRequestOptions): DeleteRequestOptions<T>;\nexport function deleteRecord(record: unknown, options?: ConstrainedRequestOptions): DeleteRequestOptions;\nexport function deleteRecord(record: unknown, options: ConstrainedRequestOptions = {}): DeleteRequestOptions {\n  const identifier = recordIdentifierFor(record);\n  assert(`Expected to be given a record instance`, identifier);\n  assert(`Cannot delete a record that does not have an associated type and id.`, isExisting(identifier));\n\n  const urlOptions: DeleteRecordUrlOptions = {\n    identifier: identifier,\n    op: 'deleteRecord',\n    resourcePath: pluralize(camelize(identifier.type)),\n  };\n\n  copyForwardUrlOptions(urlOptions, options);\n\n  const url = buildBaseURL(urlOptions);\n  const headers = new Headers();\n  headers.append('Accept', 'application/json;charset=utf-8');\n\n  return {\n    url,\n    method: 'DELETE',\n    headers,\n    op: 'deleteRecord',\n    data: {\n      record: identifier,\n    },\n    records: [identifier],\n  };\n}\n\n/**\n * Builds request options to create new record for resources,\n * configured for the url, method and header expectations of most REST APIs.\n *\n * See the [Builders](/guides/the-manual/requests/builders) guide for what request builders do and\n * when to use one.\n *\n * **Basic Usage**\n *\n * ```ts\n * import { createRecord } from '@warp-drive/utilities/rest';\n *\n * const person = store.createRecord('person', { name: 'Ted' });\n * const data = await store.request(createRecord(person));\n * ```\n *\n * **Supplying Options to Modify the Request Behavior**\n *\n * The following options are supported:\n *\n * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.\n * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.\n * - `resourcePath` - The resource path to use for the request, defaults to pluralizing the supplied type\n * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this\n *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.\n * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the\n *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,\n *      defaulting to `false` if none is configured.\n * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)\n *\n * ```ts\n * import { createRecord } from '@warp-drive/utilities/rest';\n *\n * const person = store.createRecord('person', { name: 'Ted' });\n * const options = createRecord(person, { namespace: 'api/v1' });\n * const data = await store.request(options);\n * ```\n *\n * @summary Builds a `POST` request that saves a newly created record, using REST-style URLs.\n * @public\n * @param record\n * @param options\n */\nexport function createRecord<T>(record: T, options?: ConstrainedRequestOptions): CreateRequestOptions<T>;\nexport function createRecord(record: unknown, options?: ConstrainedRequestOptions): CreateRequestOptions;\nexport function createRecord(record: unknown, options: ConstrainedRequestOptions = {}): CreateRequestOptions {\n  const identifier = recordIdentifierFor(record);\n  assert(`Expected to be given a record instance`, identifier);\n\n  const urlOptions: CreateRecordUrlOptions = {\n    identifier: identifier,\n    op: 'createRecord',\n    resourcePath: pluralize(camelize(identifier.type)),\n  };\n\n  copyForwardUrlOptions(urlOptions, options);\n\n  const url = buildBaseURL(urlOptions);\n  const headers = new Headers();\n  headers.append('Accept', 'application/json;charset=utf-8');\n\n  return {\n    url,\n    method: 'POST',\n    headers,\n    op: 'createRecord',\n    data: {\n      record: identifier,\n    },\n    records: [identifier],\n  };\n}\n\n/**\n * Builds request options to update existing record for resources,\n * configured for the url, method and header expectations of most REST APIs.\n *\n * See the [Builders](/guides/the-manual/requests/builders) guide for what request builders do and\n * when to use one.\n *\n * **Basic Usage**\n *\n * ```ts\n * import { updateRecord } from '@warp-drive/utilities/rest';\n *\n * const person = store.peekRecord('person', '1');\n * person.name = 'Chris';\n * const data = await store.request(updateRecord(person));\n * ```\n *\n * **Supplying Options to Modify the Request Behavior**\n *\n * The following options are supported:\n *\n * - `patch` - Allows caller to specify whether to use a PATCH request instead of a PUT request, defaults to `false`.\n * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.\n * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.\n * - `resourcePath` - The resource path to use for the request, defaults to pluralizing the supplied type\n * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this\n *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.\n * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the\n *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,\n *      defaulting to `false` if none is configured.\n * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)\n *\n * ```ts\n * import { updateRecord } from '@warp-drive/utilities/rest';\n *\n * const person = store.peekRecord('person', '1');\n * person.name = 'Chris';\n * const options = updateRecord(person, { patch: true });\n * const data = await store.request(options);\n * ```\n *\n * @summary Builds a `PUT` (or `PATCH`) request that saves changes to an existing record, using REST-style URLs.\n * @public\n * @param record\n * @param options\n */\nexport function updateRecord<\n  T extends TypedRecordInstance,\n  RT extends TypedRecordInstance = T,\n  M extends Meta | undefined = Meta | undefined,\n  E extends object = object,\n>(\n  record: T,\n  options?: ConstrainedRequestOptions & { patch?: boolean }\n): UpdateRequestOptions<ReactiveDataDocument<RT, M, E>, T>;\nexport function updateRecord(\n  record: unknown,\n  options?: ConstrainedRequestOptions & { patch?: boolean }\n): UpdateRequestOptions;\nexport function updateRecord(\n  record: unknown,\n  options: ConstrainedRequestOptions & { patch?: boolean } = {}\n): UpdateRequestOptions {\n  const identifier = recordIdentifierFor(record);\n  assert(`Expected to be given a record instance`, identifier);\n  assert(`Cannot update a record that does not have an associated type and id.`, isExisting(identifier));\n\n  const urlOptions: UpdateRecordUrlOptions = {\n    identifier: identifier,\n    op: 'updateRecord',\n    resourcePath: pluralize(camelize(identifier.type)),\n  };\n\n  copyForwardUrlOptions(urlOptions, options);\n\n  const url = buildBaseURL(urlOptions);\n  const headers = new Headers();\n  headers.append('Accept', 'application/json;charset=utf-8');\n\n  return {\n    url,\n    method: options.patch ? 'PATCH' : 'PUT',\n    headers,\n    op: 'updateRecord',\n    data: {\n      record: identifier,\n    },\n    records: [identifier],\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"rest.js","names":["recordIdentifierFor","buildBaseURL","camelize","pluralize","copyForwardUrlOptions","isExisting","identifier","id","type","deleteRecord","record","options","urlOptions","op","resourcePath","url","headers","Headers","append","method","data","records","createRecord","updateRecord","patch"],"sources":["../../../src/-private/rest/find-record.ts","../../../src/-private/rest/query.ts","../../../src/-private/rest/save-record.ts"],"sourcesContent":["import type { ReactiveDataDocument } from '@warp-drive/core/reactive';\nimport type { TypeFromInstance } from '@warp-drive/core/types/record';\nimport type {\n  FindRecordOptions,\n  FindRecordRequestOptions,\n  RemotelyAccessibleIdentifier,\n} from '@warp-drive/core/types/request';\nimport type { Meta } from '@warp-drive/core/types/spec/json-api-raw';\n\nimport { buildBaseURL, buildQueryParams, type FindRecordUrlOptions } from '../../index.ts';\nimport { camelize, pluralize } from '../../string';\nimport { copyForwardUrlOptions, extractCacheOptions } from '../builder-utils.ts';\n\n/**\n * Builds request options to fetch a single resource by a known id or identifier\n * configured for the url and header expectations of most REST APIs.\n *\n * See the [Builders](/guides/the-manual/requests/builders) guide for what request builders do and\n * when to use one.\n *\n * **Basic Usage**\n *\n * ```ts\n * import { findRecord } from '@warp-drive/utilities/rest';\n *\n * const data = await store.request(findRecord('person', '1'));\n * ```\n *\n * **With Options**\n *\n * ```ts\n * import { findRecord } from '@warp-drive/utilities/rest';\n *\n * const options = findRecord('person', '1', { include: ['pets', 'friends'] });\n * const data = await store.request(options);\n * ```\n *\n * **With an Identifier**\n *\n * ```ts\n * import { findRecord } from '@warp-drive/utilities/rest';\n *\n * const options = findRecord({ type: 'person', id: '1' }, { include: ['pets', 'friends'] });\n * const data = await store.request(options);\n * ```\n *\n * **Supplying Options to Modify the Request Behavior**\n *\n * The following options are supported:\n *\n * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.\n * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.\n * - `resourcePath` - The resource path to use for the request, defaults to pluralizing and camelCasing the supplied type\n * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this\n *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.\n * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the\n *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,\n *      defaulting to `false` if none is configured.\n * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)\n *\n * ```ts\n * import { findRecord } from '@warp-drive/utilities/rest';\n *\n * const options = findRecord('person', '1', { include: ['pets', 'friends'] }, { namespace: 'api/v2' });\n * const data = await store.request(options);\n * ```\n *\n * @summary Builds a `GET` request for one resource by type and id, using REST-style pluralized, camelCased URLs.\n * @public\n */\nexport function findRecord<T, M extends Meta | undefined = Meta | undefined, E extends object = object>(\n  identifier: RemotelyAccessibleIdentifier<TypeFromInstance<T>>,\n  options?: FindRecordOptions\n): FindRecordRequestOptions<ReactiveDataDocument<T, M, E>, T>;\nexport function findRecord(\n  identifier: RemotelyAccessibleIdentifier,\n  options?: FindRecordOptions\n): FindRecordRequestOptions;\nexport function findRecord<T, M extends Meta | undefined = Meta | undefined, E extends object = object>(\n  type: TypeFromInstance<T>,\n  id: string,\n  options?: FindRecordOptions\n): FindRecordRequestOptions<ReactiveDataDocument<T, M, E>, T>;\nexport function findRecord(type: string, id: string, options?: FindRecordOptions): FindRecordRequestOptions;\nexport function findRecord<T, M extends Meta | undefined = Meta | undefined, E extends object = object>(\n  arg1: TypeFromInstance<T> | RemotelyAccessibleIdentifier<TypeFromInstance<T>>,\n  arg2: string | FindRecordOptions | undefined,\n  arg3?: FindRecordOptions\n): FindRecordRequestOptions<ReactiveDataDocument<T, M, E>, T> {\n  const identifier: RemotelyAccessibleIdentifier<TypeFromInstance<T>> =\n    typeof arg1 === 'string' ? { type: arg1, id: arg2 as string } : arg1;\n  const options: FindRecordOptions = (typeof arg1 === 'string' ? arg3 : (arg2 as FindRecordOptions)) || {};\n  const cacheOptions = extractCacheOptions(options);\n  const urlOptions: FindRecordUrlOptions = {\n    identifier,\n    op: 'findRecord',\n    resourcePath: pluralize(camelize(identifier.type)),\n  };\n\n  copyForwardUrlOptions(urlOptions, options);\n\n  const url = buildBaseURL(urlOptions);\n  const headers = new Headers();\n  headers.append('Accept', 'application/json;charset=utf-8');\n\n  return {\n    url: options.include?.length\n      ? `${url}?${buildQueryParams({ include: options.include }, options.urlParamsSettings)}`\n      : url,\n    method: 'GET',\n    headers,\n    cacheOptions,\n    op: 'findRecord',\n    records: [identifier],\n  };\n}\n\n/** @deprecated use {@link ReactiveDataDocument} instead */\nexport type FindRecordResultDocument<\n  T,\n  M extends Meta | undefined = Meta | undefined,\n  E extends object = object,\n> = ReactiveDataDocument<T, M, E>;\n","import type { ReactiveDataDocument } from '@warp-drive/core/reactive';\nimport type { QueryParamsSource } from '@warp-drive/core/types/params';\nimport type { TypeFromInstance } from '@warp-drive/core/types/record';\nimport type { ConstrainedRequestOptions, QueryRequestOptions } from '@warp-drive/core/types/request';\nimport type { Meta } from '@warp-drive/core/types/spec/json-api-raw';\n\nimport { buildBaseURL, buildQueryParams, type QueryUrlOptions } from '../../index.ts';\nimport { camelize, pluralize } from '../../string';\nimport { copyForwardUrlOptions, extractCacheOptions } from '../builder-utils.ts';\n\n/**\n * Builds request options to query for resources, usually by a primary\n * type, configured for the url and header expectations of most REST APIs.\n *\n * See the [Builders](/guides/the-manual/requests/builders) guide for what request builders do and\n * when to use one.\n *\n * **Basic Usage**\n *\n * ```ts\n * import { query } from '@warp-drive/utilities/rest';\n *\n * const data = await store.request(query('person'));\n * ```\n *\n * **With Query Params**\n *\n * ```ts\n * import { query } from '@warp-drive/utilities/rest';\n *\n * const options = query('person', { include: ['pets', 'friends'] });\n * const data = await store.request(options);\n * ```\n *\n * **Supplying Options to Modify the Request Behavior**\n *\n * The following options are supported:\n *\n * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.\n * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.\n * - `resourcePath` - The resource path to use for the request, defaults to pluralizing and camelCasing the supplied type\n * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this\n *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.\n * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the\n *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,\n *      defaulting to `false` if none is configured.\n * - `urlParamsSettings` - an object containing options for how to serialize the query params (see `buildQueryParams`)\n *\n * ```ts\n * import { query } from '@warp-drive/utilities/rest';\n *\n * const options = query('person', { include: ['pets', 'friends'] }, { reload: true });\n * const data = await store.request(options);\n * ```\n *\n * @summary Builds a `GET` request that queries a resource type with query params, using REST-style URLs.\n * @public\n * @param identifier\n * @param query\n * @param options\n */\nexport function query<T, M extends Meta | undefined = Meta | undefined, E extends object = object>(\n  type: TypeFromInstance<T>,\n  query?: QueryParamsSource,\n  options?: ConstrainedRequestOptions\n): QueryRequestOptions<ReactiveDataDocument<T[], M, E>>;\nexport function query(\n  type: string,\n  query?: QueryParamsSource,\n  options?: ConstrainedRequestOptions\n): QueryRequestOptions;\nexport function query(\n  type: string,\n  // oxlint-disable-next-line no-shadow\n  query: QueryParamsSource = {},\n  options: ConstrainedRequestOptions = {}\n): QueryRequestOptions {\n  const cacheOptions = extractCacheOptions(options);\n  const urlOptions: QueryUrlOptions = {\n    identifier: { type },\n    op: 'query',\n    resourcePath: pluralize(camelize(type)),\n  };\n\n  copyForwardUrlOptions(urlOptions, options);\n\n  const url = buildBaseURL(urlOptions);\n  const headers = new Headers();\n  headers.append('Accept', 'application/json;charset=utf-8');\n  const queryString = buildQueryParams(query, options.urlParamsSettings);\n\n  return {\n    url: queryString ? `${url}?${queryString}` : url,\n    method: 'GET',\n    headers,\n    cacheOptions,\n    op: 'query',\n  };\n}\n","import { recordIdentifierFor } from '@warp-drive/core';\nimport { assert } from '@warp-drive/core/build-config/macros';\nimport type { ReactiveDataDocument } from '@warp-drive/core/reactive';\nimport type { PersistedResourceKey, ResourceKey } from '@warp-drive/core/types/identifier';\nimport type { TypedRecordInstance } from '@warp-drive/core/types/record';\nimport type {\n  ConstrainedRequestOptions,\n  CreateRequestOptions,\n  DeleteRequestOptions,\n  UpdateRequestOptions,\n} from '@warp-drive/core/types/request';\nimport type { Meta } from '@warp-drive/core/types/spec/json-api-raw';\n\nimport {\n  buildBaseURL,\n  type CreateRecordUrlOptions,\n  type DeleteRecordUrlOptions,\n  type UpdateRecordUrlOptions,\n} from '../../index.ts';\nimport { camelize, pluralize } from '../../string';\nimport { copyForwardUrlOptions } from '../builder-utils.ts';\n\nfunction isExisting(identifier: ResourceKey): identifier is PersistedResourceKey {\n  return 'id' in identifier && identifier.id !== null && 'type' in identifier && identifier.type !== null;\n}\n\n/**\n * Builds request options to delete record for resources,\n * configured for the url, method and header expectations of REST APIs.\n *\n * See the [Builders](/guides/the-manual/requests/builders) guide for what request builders do and\n * when to use one.\n *\n * **Basic Usage**\n *\n * ```ts\n * import { deleteRecord } from '@warp-drive/utilities/rest';\n *\n * const person = store.peekRecord('person', '1');\n *\n * // mark record as deleted\n * store.deleteRecord(person);\n *\n * // persist deletion\n * const data = await store.request(deleteRecord(person));\n * ```\n *\n * **Supplying Options to Modify the Request Behavior**\n *\n * The following options are supported:\n *\n * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.\n * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.\n * - `resourcePath` - The resource path to use for the request, defaults to pluralizing the supplied type\n * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this\n *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.\n * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the\n *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,\n *      defaulting to `false` if none is configured.\n * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)\n *\n * ```ts\n * import { deleteRecord } from '@warp-drive/utilities/rest';\n *\n * const person = store.peekRecord('person', '1');\n *\n * // mark record as deleted\n * store.deleteRecord(person);\n *\n * // persist deletion\n * const options = deleteRecord(person, { namespace: 'api/v1' });\n * const data = await store.request(options);\n * ```\n *\n * @summary Builds a `DELETE` request that persists deletion of an existing record, using REST-style URLs.\n * @public\n * @param record\n * @param options\n */\nexport function deleteRecord<T>(record: T, options?: ConstrainedRequestOptions): DeleteRequestOptions<T>;\nexport function deleteRecord(record: unknown, options?: ConstrainedRequestOptions): DeleteRequestOptions;\nexport function deleteRecord(record: unknown, options: ConstrainedRequestOptions = {}): DeleteRequestOptions {\n  const identifier = recordIdentifierFor(record);\n  assert(`Expected to be given a record instance`, identifier);\n  assert(`Cannot delete a record that does not have an associated type and id.`, isExisting(identifier));\n\n  const urlOptions: DeleteRecordUrlOptions = {\n    identifier: identifier,\n    op: 'deleteRecord',\n    resourcePath: pluralize(camelize(identifier.type)),\n  };\n\n  copyForwardUrlOptions(urlOptions, options);\n\n  const url = buildBaseURL(urlOptions);\n  const headers = new Headers();\n  headers.append('Accept', 'application/json;charset=utf-8');\n\n  return {\n    url,\n    method: 'DELETE',\n    headers,\n    op: 'deleteRecord',\n    data: {\n      record: identifier,\n    },\n    records: [identifier],\n  };\n}\n\n/**\n * Builds request options to create new record for resources,\n * configured for the url, method and header expectations of most REST APIs.\n *\n * See the [Builders](/guides/the-manual/requests/builders) guide for what request builders do and\n * when to use one.\n *\n * **Basic Usage**\n *\n * ```ts\n * import { createRecord } from '@warp-drive/utilities/rest';\n *\n * const person = store.createRecord('person', { name: 'Ted' });\n * const data = await store.request(createRecord(person));\n * ```\n *\n * **Supplying Options to Modify the Request Behavior**\n *\n * The following options are supported:\n *\n * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.\n * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.\n * - `resourcePath` - The resource path to use for the request, defaults to pluralizing the supplied type\n * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this\n *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.\n * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the\n *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,\n *      defaulting to `false` if none is configured.\n * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)\n *\n * ```ts\n * import { createRecord } from '@warp-drive/utilities/rest';\n *\n * const person = store.createRecord('person', { name: 'Ted' });\n * const options = createRecord(person, { namespace: 'api/v1' });\n * const data = await store.request(options);\n * ```\n *\n * @summary Builds a `POST` request that saves a newly created record, using REST-style URLs.\n * @public\n * @param record\n * @param options\n */\nexport function createRecord<T>(record: T, options?: ConstrainedRequestOptions): CreateRequestOptions<T>;\nexport function createRecord(record: unknown, options?: ConstrainedRequestOptions): CreateRequestOptions;\nexport function createRecord(record: unknown, options: ConstrainedRequestOptions = {}): CreateRequestOptions {\n  const identifier = recordIdentifierFor(record);\n  assert(`Expected to be given a record instance`, identifier);\n\n  const urlOptions: CreateRecordUrlOptions = {\n    identifier: identifier,\n    op: 'createRecord',\n    resourcePath: pluralize(camelize(identifier.type)),\n  };\n\n  copyForwardUrlOptions(urlOptions, options);\n\n  const url = buildBaseURL(urlOptions);\n  const headers = new Headers();\n  headers.append('Accept', 'application/json;charset=utf-8');\n\n  return {\n    url,\n    method: 'POST',\n    headers,\n    op: 'createRecord',\n    data: {\n      record: identifier,\n    },\n    records: [identifier],\n  };\n}\n\n/**\n * Builds request options to update existing record for resources,\n * configured for the url, method and header expectations of most REST APIs.\n *\n * See the [Builders](/guides/the-manual/requests/builders) guide for what request builders do and\n * when to use one.\n *\n * **Basic Usage**\n *\n * ```ts\n * import { updateRecord } from '@warp-drive/utilities/rest';\n *\n * const person = store.peekRecord('person', '1');\n * person.name = 'Chris';\n * const data = await store.request(updateRecord(person));\n * ```\n *\n * **Supplying Options to Modify the Request Behavior**\n *\n * The following options are supported:\n *\n * - `patch` - Allows caller to specify whether to use a PATCH request instead of a PUT request, defaults to `false`.\n * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.\n * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.\n * - `resourcePath` - The resource path to use for the request, defaults to pluralizing the supplied type\n * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this\n *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.\n * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the\n *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,\n *      defaulting to `false` if none is configured.\n * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)\n *\n * ```ts\n * import { updateRecord } from '@warp-drive/utilities/rest';\n *\n * const person = store.peekRecord('person', '1');\n * person.name = 'Chris';\n * const options = updateRecord(person, { patch: true });\n * const data = await store.request(options);\n * ```\n *\n * @summary Builds a `PUT` (or `PATCH`) request that saves changes to an existing record, using REST-style URLs.\n * @public\n * @param record\n * @param options\n */\nexport function updateRecord<\n  T extends TypedRecordInstance,\n  RT extends TypedRecordInstance = T,\n  M extends Meta | undefined = Meta | undefined,\n  E extends object = object,\n>(\n  record: T,\n  options?: ConstrainedRequestOptions & { patch?: boolean }\n): UpdateRequestOptions<ReactiveDataDocument<RT, M, E>, T>;\nexport function updateRecord(\n  record: unknown,\n  options?: ConstrainedRequestOptions & { patch?: boolean }\n): UpdateRequestOptions;\nexport function updateRecord(\n  record: unknown,\n  options: ConstrainedRequestOptions & { patch?: boolean } = {}\n): UpdateRequestOptions {\n  const identifier = recordIdentifierFor(record);\n  assert(`Expected to be given a record instance`, identifier);\n  assert(`Cannot update a record that does not have an associated type and id.`, isExisting(identifier));\n\n  const urlOptions: UpdateRecordUrlOptions = {\n    identifier: identifier,\n    op: 'updateRecord',\n    resourcePath: pluralize(camelize(identifier.type)),\n  };\n\n  copyForwardUrlOptions(urlOptions, options);\n\n  const url = buildBaseURL(urlOptions);\n  const headers = new Headers();\n  headers.append('Accept', 'application/json;charset=utf-8');\n\n  return {\n    url,\n    method: options.patch ? 'PATCH' : 'PUT',\n    headers,\n    op: 'updateRecord',\n    data: {\n      record: identifier,\n    },\n    records: [identifier],\n  };\n}\n"],"mappings":"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"}

package/dist/unpkg/{prod-deprecated/string-D8BEYx2W.js → prod/string-Du9nRZEd.js}

@@ -1,7 +1,7 @@
-import { t as defaultRules } from "./inflections-DzBsjJqj.js";
+import { t as defaultRules } from "./inflections-CWdUh2K_.js";
 import { LRUCache, STRING_DASHERIZE_CACHE, dasherize } from "@warp-drive/core/utils/string";
 
-//#region src/-private/string/transform.ts
+// src/-private/string/transform.ts
 const STRING_CAMELIZE_REGEXP_1 = /(\-|\_|\.|\s)+(.)?/g;
 const STRING_CAMELIZE_REGEXP_2 = /(^|\/)([A-Z])/g;
 const CAMELIZE_CACHE = new LRUCache((key) => key.replace(STRING_CAMELIZE_REGEXP_1, (_match, _separator, chr) => chr ? chr.toUpperCase() : "").replace(STRING_CAMELIZE_REGEXP_2, (match) => match.toLowerCase()));
@@ -106,8 +106,7 @@ function setMaxLRUCacheSize(size) {
 	STRING_DASHERIZE_CACHE.size = size;
 }
 
-//#endregion
-//#region src/-private/string/inflect.ts
+// src/-private/string/inflect.ts
 const BLANK_REGEX = /^\s*$/;
 const LAST_WORD_DASHED_REGEX = /([\w/-]+[_/\s-])([a-z\d]+$)/;
 const LAST_WORD_CAMELIZED_REGEX = /([\w/\s-]+)([A-Z][a-z\d]*$)/;
@@ -297,6 +296,5 @@ function inflect(word, typeRules, irregulars) {
 	return word;
 }
 
-//#endregion
 export { loadUncountable as a, resetToDefaults as c, uncountable as d, camelize as f, underscore as g, setMaxLRUCacheSize as h, loadIrregular as i, singular as l, dasherize$1 as m, clearRules as n, plural as o, capitalize as p, irregular as r, pluralize as s, clear as t, singularize as u };
-//# sourceMappingURL=string-D8BEYx2W.js.map
+//# sourceMappingURL=string-Du9nRZEd.js.map

package/dist/unpkg/prod/{string-D8BEYx2W.js.map → string-Du9nRZEd.js.map}

@@ -1 +1 @@
-{"version":3,"file":"string-D8BEYx2W.js","names":["dasherize","internalDasherize","LRUCache","defaultRules","capitalize","BLANK_REGEX","LAST_WORD_DASHED_REGEX","LAST_WORD_CAMELIZED_REGEX","CAMELIZED_REGEX","SINGULARS","word","_singularize","PLURALS","_pluralize","UNCOUNTABLE","Set","uncountable","IRREGULAR","Map","INVERSE_IRREGULAR","SINGULAR_RULES","singular","reverse","PLURAL_RULES","plurals","add","toLowerCase","loadUncountable","uncountables","forEach","irregular","single","plur","set","loadIrregular","irregularPairs","pair","clear","resetToDefaults","clearRules","v","singularize","get","pluralize","unshiftMap","map","rules","entries","rule","plural","regex","string","has","delete","inflect","typeRules","irregulars","isBlank","test","lowercase","wordSplit","exec","lastWord","isCamelized","substitution","match","replace","RegExp"],"sources":["../../../src/-private/string/transform.ts","../../../src/-private/string/inflect.ts"],"sourcesContent":["import { dasherize as internalDasherize, LRUCache, STRING_DASHERIZE_CACHE } from '@warp-drive/core/utils/string';\n\n// oxlint-disable-next-line no-useless-escape\nconst STRING_CAMELIZE_REGEXP_1 = /(\\-|\\_|\\.|\\s)+(.)?/g;\nconst STRING_CAMELIZE_REGEXP_2 = /(^|\\/)([A-Z])/g;\nconst CAMELIZE_CACHE = new LRUCache<string, string>((key: string) =>\n  key\n    .replace(STRING_CAMELIZE_REGEXP_1, (_match, _separator, chr: string | null) => (chr ? chr.toUpperCase() : ''))\n    .replace(STRING_CAMELIZE_REGEXP_2, (match /*, separator, chr */) => match.toLowerCase())\n);\n\nconst STRING_UNDERSCORE_REGEXP_1 = /([a-z\\d])([A-Z]+)/g;\n// oxlint-disable-next-line no-useless-escape\nconst STRING_UNDERSCORE_REGEXP_2 = /\\-|\\s+/g;\nconst UNDERSCORE_CACHE = new LRUCache<string, string>((str: string) =>\n  str.replace(STRING_UNDERSCORE_REGEXP_1, '$1_$2').replace(STRING_UNDERSCORE_REGEXP_2, '_').toLowerCase()\n);\n\nconst STRING_CAPITALIZE_REGEXP = /(^|\\/)([a-z\\u00C0-\\u024F])/g;\nconst CAPITALIZE_CACHE = new LRUCache<string, string>((str: string) =>\n  str.replace(STRING_CAPITALIZE_REGEXP, (match /*, separator, chr */) => match.toUpperCase())\n);\n\n/**\n * Replaces underscores, spaces, or camelCase with dashes.\n *\n * ```js\n * import { dasherize } from '@warp-drive/utilities/string';\n *\n * dasherize('innerHTML');                // 'inner-html'\n * dasherize('action_name');              // 'action-name'\n * dasherize('css-class-name');           // 'css-class-name'\n * dasherize('my favorite items');        // 'my-favorite-items'\n * dasherize('privateDocs/ownerInvoice';  // 'private-docs/owner-invoice'\n * ```\n *\n * @summary Converts camelCase, underscored, or spaced strings to dasherized form, such as `innerHTML` to `inner-html`.\n * @public\n * @since 4.13.0\n */\nexport const dasherize: (str: string) => string = internalDasherize;\n\n/**\n * Returns the lowerCamelCase form of a string.\n *\n * ```js\n * import { camelize } from '@warp-drive/utilities/string';\n *\n * camelize('innerHTML');                   // 'innerHTML'\n * camelize('action_name');                 // 'actionName'\n * camelize('css-class-name');              // 'cssClassName'\n * camelize('my favorite items');           // 'myFavoriteItems'\n * camelize('My Favorite Items');           // 'myFavoriteItems'\n * camelize('private-docs/owner-invoice');  // 'privateDocs/ownerInvoice'\n * ```\n *\n * @summary Converts dashed, underscored, dotted, or spaced strings to lowerCamelCase, such as `action_name` to\n * `actionName`.\n * @public\n * @since 4.13.0\n */\nexport function camelize(str: string): string {\n  return CAMELIZE_CACHE.get(str);\n}\n\n/**\n * Returns the lower\\_case\\_and\\_underscored form of a string.\n *\n * ```js\n * import { underscore } from '@warp-drive/utilities/string';\n *\n * underscore('innerHTML');                 // 'inner_html'\n * underscore('action_name');               // 'action_name'\n * underscore('css-class-name');            // 'css_class_name'\n * underscore('my favorite items');         // 'my_favorite_items'\n * underscore('privateDocs/ownerInvoice');  // 'private_docs/owner_invoice'\n * ```\n *\n * @summary Converts camelCase, dashed, or spaced strings to lowercase snake_case, such as `innerHTML` to `inner_html`.\n * @public\n * @since 4.13.0\n */\nexport function underscore(str: string): string {\n  return UNDERSCORE_CACHE.get(str);\n}\n\n/**\n * Returns the Capitalized form of a string\n *\n * ```js\n * import { capitalize } from '@warp-drive/utilities/string';\n *\n * capitalize('innerHTML')                 // 'InnerHTML'\n * capitalize('action_name')               // 'Action_name'\n * capitalize('css-class-name')            // 'Css-class-name'\n * capitalize('my favorite items')         // 'My favorite items'\n * capitalize('privateDocs/ownerInvoice'); // 'PrivateDocs/ownerInvoice'\n * ```\n *\n * @summary Uppercases the first letter of a string, and of each `/`-separated path segment, leaving the rest unchanged.\n * @public\n * @since 4.13.0\n */\nexport function capitalize(str: string): string {\n  return CAPITALIZE_CACHE.get(str);\n}\n\n/**\n * Sets the maximum size of the LRUCache for all string transformation functions.\n * The default size is 10,000.\n *\n * @summary Sets how many results the `camelize`, `underscore`, `capitalize`, and `dasherize` caches each keep (default\n * 10,000).\n * @public\n * @since 4.13.0\n */\nexport function setMaxLRUCacheSize(size: number): void {\n  CAMELIZE_CACHE.size = size;\n  UNDERSCORE_CACHE.size = size;\n  CAPITALIZE_CACHE.size = size;\n  STRING_DASHERIZE_CACHE.size = size;\n}\n","import { assert } from '@warp-drive/core/build-config/macros';\nimport { LRUCache } from '@warp-drive/core/utils/string';\n\nimport { defaultRules } from './inflections.ts';\nimport { capitalize } from './transform.ts';\n\nconst BLANK_REGEX = /^\\s*$/;\nconst LAST_WORD_DASHED_REGEX = /([\\w/-]+[_/\\s-])([a-z\\d]+$)/;\nconst LAST_WORD_CAMELIZED_REGEX = /([\\w/\\s-]+)([A-Z][a-z\\d]*$)/;\nconst CAMELIZED_REGEX = /[A-Z][a-z\\d]*$/;\n\nconst SINGULARS = new LRUCache<string, string>((word: string) => {\n  return _singularize(word);\n});\nconst PLURALS = new LRUCache<string, string>((word: string) => {\n  return _pluralize(word);\n});\nconst UNCOUNTABLE = new Set(defaultRules.uncountable);\nconst IRREGULAR: Map<string, string> = new Map();\nconst INVERSE_IRREGULAR: Map<string, string> = new Map();\nconst SINGULAR_RULES = new Map(defaultRules.singular.reverse());\nconst PLURAL_RULES = new Map(defaultRules.plurals.reverse());\n\n/**\n * Marks a word as uncountable. Uncountable words are not pluralized\n * or singularized.\n *\n * @summary Registers a word that `pluralize` and `singularize` should always return unchanged.\n * @public\n * @since 4.13.0\n */\nexport function uncountable(word: string): void {\n  UNCOUNTABLE.add(word.toLowerCase());\n}\n\n/**\n * Marks a list of words as uncountable. Uncountable words are not pluralized\n * or singularized.\n *\n * @summary Registers a list of words that `pluralize` and `singularize` should always return unchanged.\n * @public\n * @since 4.13.0\n */\nexport function loadUncountable(uncountables: string[]): void {\n  uncountables.forEach((word) => {\n    uncountable(word);\n  });\n}\n\n/**\n * Marks a word as irregular. Irregular words have unique\n * pluralization and singularization rules.\n *\n * @summary Registers a singular and plural word pair that `pluralize` and `singularize` map directly instead of\n * applying rules.\n * @public\n * @since 4.13.0\n */\nexport function irregular(single: string, plur: string): void {\n  //pluralizing\n  IRREGULAR.set(single.toLowerCase(), plur);\n  IRREGULAR.set(plur.toLowerCase(), plur);\n\n  //singularizing\n  INVERSE_IRREGULAR.set(plur.toLowerCase(), single);\n  INVERSE_IRREGULAR.set(single.toLowerCase(), single);\n}\n\n/**\n * Marks a list of word pairs as irregular. Irregular words have unique\n * pluralization and singularization rules.\n *\n * @summary Registers a list of singular and plural word pairs that `pluralize` and `singularize` map directly.\n * @public\n * @since 4.13.0\n */\nexport function loadIrregular(irregularPairs: Array<[string, string]>): void {\n  irregularPairs.forEach((pair) => {\n    //pluralizing\n    IRREGULAR.set(pair[0].toLowerCase(), pair[1]);\n    IRREGULAR.set(pair[1].toLowerCase(), pair[1]);\n\n    //singularizing\n    INVERSE_IRREGULAR.set(pair[1].toLowerCase(), pair[0]);\n    INVERSE_IRREGULAR.set(pair[0].toLowerCase(), pair[0]);\n  });\n}\nloadIrregular(defaultRules.irregularPairs);\n\n/**\n * Clears the caches for singularize and pluralize.\n *\n * @summary Empties the cached results of `singularize` and `pluralize` while keeping all inflection rules.\n * @public\n * @since 4.13.0\n */\nexport function clear(): void {\n  SINGULARS.clear();\n  PLURALS.clear();\n}\n\n/**\n * Resets the inflection rules to the defaults.\n *\n * @summary Discards all custom inflection rules and caches, then restores the built-in default rules.\n * @public\n * @since 4.13.0\n */\nexport function resetToDefaults(): void {\n  clearRules();\n  defaultRules.uncountable.forEach((v) => UNCOUNTABLE.add(v));\n  defaultRules.singular.forEach((v) => SINGULAR_RULES.set(v[0], v[1]));\n  defaultRules.plurals.forEach((v) => PLURAL_RULES.set(v[0], v[1]));\n  loadIrregular(defaultRules.irregularPairs);\n}\n\n/**\n * Clears all inflection rules\n * and resets the caches for singularize and pluralize.\n *\n * @summary Removes every inflection rule, including the defaults, and empties the `singularize` and `pluralize` caches.\n * @public\n * @since 4.13.0\n */\nexport function clearRules(): void {\n  SINGULARS.clear();\n  PLURALS.clear();\n  UNCOUNTABLE.clear();\n  IRREGULAR.clear();\n  INVERSE_IRREGULAR.clear();\n  SINGULAR_RULES.clear();\n  PLURAL_RULES.clear();\n}\n\n/**\n * Singularizes a word.\n *\n * @summary Returns the singular form of an English word using the registered inflection rules, with cached results.\n * @public\n * @since 4.13.0\n */\nexport function singularize(word: string): string {\n  assert(`singularize expects to receive a non-empty string`, typeof word === 'string' && word.length > 0);\n  if (!word) return '';\n  return SINGULARS.get(word);\n}\n\n/**\n * Pluralizes a word.\n *\n * @summary Returns the plural form of an English word using the registered inflection rules, with cached results.\n * @public\n * @since 4.13.0\n */\nexport function pluralize(word: string): string {\n  assert(`pluralize expects to receive a non-empty string`, typeof word === 'string' && word.length > 0);\n  if (!word) return '';\n  return PLURALS.get(word);\n}\n\nfunction unshiftMap<K, V>(v: [K, V], map: Map<K, V>) {\n  // reorder\n  const rules = [v, ...map.entries()];\n  map.clear();\n  rules.forEach((rule) => {\n    map.set(rule[0], rule[1]);\n  });\n}\n\n/**\n * Adds a pluralization rule.\n *\n * @summary Adds a regex and replacement rule that `pluralize` checks before all existing plural rules.\n * @public\n * @since 4.13.0\n */\nexport function plural(regex: RegExp, string: string): void {\n  // rule requires reordering if exists, so remove it first\n  if (PLURAL_RULES.has(regex)) {\n    PLURAL_RULES.delete(regex);\n  }\n\n  // reorder\n  unshiftMap([regex, string], PLURAL_RULES);\n}\n\n/**\n * Adds a singularization rule.\n *\n * @summary Adds a regex and replacement rule that `singularize` checks before all existing singular rules.\n * @public\n * @since 4.13.0\n */\nexport function singular(regex: RegExp, string: string): void {\n  // rule requires reordering if exists, so remove it first\n  if (SINGULAR_RULES.has(regex)) {\n    SINGULAR_RULES.delete(regex);\n  }\n\n  // reorder\n  unshiftMap([regex, string], SINGULAR_RULES);\n}\n\nfunction _pluralize(word: string) {\n  return inflect(word, PLURAL_RULES, IRREGULAR);\n}\n\nfunction _singularize(word: string) {\n  return inflect(word, SINGULAR_RULES, INVERSE_IRREGULAR);\n}\n\nfunction inflect(word: string, typeRules: Map<RegExp, string>, irregulars: Map<string, string>) {\n  // empty strings\n  const isBlank = !word || BLANK_REGEX.test(word);\n  if (isBlank) {\n    return word;\n  }\n\n  // basic uncountables\n  const lowercase = word.toLowerCase();\n  if (UNCOUNTABLE.has(lowercase)) {\n    return word;\n  }\n\n  // adv uncountables\n  const wordSplit = LAST_WORD_DASHED_REGEX.exec(word) || LAST_WORD_CAMELIZED_REGEX.exec(word);\n  const lastWord = wordSplit ? wordSplit[2].toLowerCase() : null;\n  if (lastWord && UNCOUNTABLE.has(lastWord)) {\n    return word;\n  }\n\n  // handle irregulars\n  const isCamelized = CAMELIZED_REGEX.test(word);\n  for (let [rule, substitution] of irregulars) {\n    if (lowercase.match(rule + '$')) {\n      if (isCamelized && lastWord && irregulars.has(lastWord)) {\n        substitution = capitalize(substitution);\n        rule = capitalize(rule);\n      }\n\n      return word.replace(new RegExp(rule, 'i'), substitution);\n    }\n  }\n\n  // do the actual inflection\n  for (const [rule, substitution] of typeRules) {\n    if (rule.test(word)) {\n      return word.replace(rule, substitution);\n    }\n  }\n\n  return word;\n}\n"],"mappings":"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"}
+{"version":3,"file":"string-Du9nRZEd.js","names":["dasherize","internalDasherize","LRUCache","defaultRules","capitalize","BLANK_REGEX","LAST_WORD_DASHED_REGEX","LAST_WORD_CAMELIZED_REGEX","CAMELIZED_REGEX","SINGULARS","word","_singularize","PLURALS","_pluralize","UNCOUNTABLE","Set","uncountable","IRREGULAR","Map","INVERSE_IRREGULAR","SINGULAR_RULES","singular","reverse","PLURAL_RULES","plurals","add","toLowerCase","loadUncountable","uncountables","forEach","irregular","single","plur","set","loadIrregular","irregularPairs","pair","clear","resetToDefaults","clearRules","v","singularize","get","pluralize","unshiftMap","map","rules","entries","rule","plural","regex","string","has","delete","inflect","typeRules","irregulars","isBlank","test","lowercase","wordSplit","exec","lastWord","isCamelized","substitution","match","replace","RegExp"],"sources":["../../../src/-private/string/transform.ts","../../../src/-private/string/inflect.ts"],"sourcesContent":["import { dasherize as internalDasherize, LRUCache, STRING_DASHERIZE_CACHE } from '@warp-drive/core/utils/string';\n\n// oxlint-disable-next-line no-useless-escape\nconst STRING_CAMELIZE_REGEXP_1 = /(\\-|\\_|\\.|\\s)+(.)?/g;\nconst STRING_CAMELIZE_REGEXP_2 = /(^|\\/)([A-Z])/g;\nconst CAMELIZE_CACHE = new LRUCache<string, string>((key: string) =>\n  key\n    .replace(STRING_CAMELIZE_REGEXP_1, (_match, _separator, chr: string | null) => (chr ? chr.toUpperCase() : ''))\n    .replace(STRING_CAMELIZE_REGEXP_2, (match /*, separator, chr */) => match.toLowerCase())\n);\n\nconst STRING_UNDERSCORE_REGEXP_1 = /([a-z\\d])([A-Z]+)/g;\n// oxlint-disable-next-line no-useless-escape\nconst STRING_UNDERSCORE_REGEXP_2 = /\\-|\\s+/g;\nconst UNDERSCORE_CACHE = new LRUCache<string, string>((str: string) =>\n  str.replace(STRING_UNDERSCORE_REGEXP_1, '$1_$2').replace(STRING_UNDERSCORE_REGEXP_2, '_').toLowerCase()\n);\n\nconst STRING_CAPITALIZE_REGEXP = /(^|\\/)([a-z\\u00C0-\\u024F])/g;\nconst CAPITALIZE_CACHE = new LRUCache<string, string>((str: string) =>\n  str.replace(STRING_CAPITALIZE_REGEXP, (match /*, separator, chr */) => match.toUpperCase())\n);\n\n/**\n * Replaces underscores, spaces, or camelCase with dashes.\n *\n * ```js\n * import { dasherize } from '@warp-drive/utilities/string';\n *\n * dasherize('innerHTML');                // 'inner-html'\n * dasherize('action_name');              // 'action-name'\n * dasherize('css-class-name');           // 'css-class-name'\n * dasherize('my favorite items');        // 'my-favorite-items'\n * dasherize('privateDocs/ownerInvoice';  // 'private-docs/owner-invoice'\n * ```\n *\n * @summary Converts camelCase, underscored, or spaced strings to dasherized form, such as `innerHTML` to `inner-html`.\n * @public\n * @since 4.13.0\n */\nexport const dasherize: (str: string) => string = internalDasherize;\n\n/**\n * Returns the lowerCamelCase form of a string.\n *\n * ```js\n * import { camelize } from '@warp-drive/utilities/string';\n *\n * camelize('innerHTML');                   // 'innerHTML'\n * camelize('action_name');                 // 'actionName'\n * camelize('css-class-name');              // 'cssClassName'\n * camelize('my favorite items');           // 'myFavoriteItems'\n * camelize('My Favorite Items');           // 'myFavoriteItems'\n * camelize('private-docs/owner-invoice');  // 'privateDocs/ownerInvoice'\n * ```\n *\n * @summary Converts dashed, underscored, dotted, or spaced strings to lowerCamelCase, such as `action_name` to\n * `actionName`.\n * @public\n * @since 4.13.0\n */\nexport function camelize(str: string): string {\n  return CAMELIZE_CACHE.get(str);\n}\n\n/**\n * Returns the lower\\_case\\_and\\_underscored form of a string.\n *\n * ```js\n * import { underscore } from '@warp-drive/utilities/string';\n *\n * underscore('innerHTML');                 // 'inner_html'\n * underscore('action_name');               // 'action_name'\n * underscore('css-class-name');            // 'css_class_name'\n * underscore('my favorite items');         // 'my_favorite_items'\n * underscore('privateDocs/ownerInvoice');  // 'private_docs/owner_invoice'\n * ```\n *\n * @summary Converts camelCase, dashed, or spaced strings to lowercase snake_case, such as `innerHTML` to `inner_html`.\n * @public\n * @since 4.13.0\n */\nexport function underscore(str: string): string {\n  return UNDERSCORE_CACHE.get(str);\n}\n\n/**\n * Returns the Capitalized form of a string\n *\n * ```js\n * import { capitalize } from '@warp-drive/utilities/string';\n *\n * capitalize('innerHTML')                 // 'InnerHTML'\n * capitalize('action_name')               // 'Action_name'\n * capitalize('css-class-name')            // 'Css-class-name'\n * capitalize('my favorite items')         // 'My favorite items'\n * capitalize('privateDocs/ownerInvoice'); // 'PrivateDocs/ownerInvoice'\n * ```\n *\n * @summary Uppercases the first letter of a string, and of each `/`-separated path segment, leaving the rest unchanged.\n * @public\n * @since 4.13.0\n */\nexport function capitalize(str: string): string {\n  return CAPITALIZE_CACHE.get(str);\n}\n\n/**\n * Sets the maximum size of the LRUCache for all string transformation functions.\n * The default size is 10,000.\n *\n * @summary Sets how many results the `camelize`, `underscore`, `capitalize`, and `dasherize` caches each keep (default\n * 10,000).\n * @public\n * @since 4.13.0\n */\nexport function setMaxLRUCacheSize(size: number): void {\n  CAMELIZE_CACHE.size = size;\n  UNDERSCORE_CACHE.size = size;\n  CAPITALIZE_CACHE.size = size;\n  STRING_DASHERIZE_CACHE.size = size;\n}\n","import { assert } from '@warp-drive/core/build-config/macros';\nimport { LRUCache } from '@warp-drive/core/utils/string';\n\nimport { defaultRules } from './inflections.ts';\nimport { capitalize } from './transform.ts';\n\nconst BLANK_REGEX = /^\\s*$/;\nconst LAST_WORD_DASHED_REGEX = /([\\w/-]+[_/\\s-])([a-z\\d]+$)/;\nconst LAST_WORD_CAMELIZED_REGEX = /([\\w/\\s-]+)([A-Z][a-z\\d]*$)/;\nconst CAMELIZED_REGEX = /[A-Z][a-z\\d]*$/;\n\nconst SINGULARS = new LRUCache<string, string>((word: string) => {\n  return _singularize(word);\n});\nconst PLURALS = new LRUCache<string, string>((word: string) => {\n  return _pluralize(word);\n});\nconst UNCOUNTABLE = new Set(defaultRules.uncountable);\nconst IRREGULAR: Map<string, string> = new Map();\nconst INVERSE_IRREGULAR: Map<string, string> = new Map();\nconst SINGULAR_RULES = new Map(defaultRules.singular.reverse());\nconst PLURAL_RULES = new Map(defaultRules.plurals.reverse());\n\n/**\n * Marks a word as uncountable. Uncountable words are not pluralized\n * or singularized.\n *\n * @summary Registers a word that `pluralize` and `singularize` should always return unchanged.\n * @public\n * @since 4.13.0\n */\nexport function uncountable(word: string): void {\n  UNCOUNTABLE.add(word.toLowerCase());\n}\n\n/**\n * Marks a list of words as uncountable. Uncountable words are not pluralized\n * or singularized.\n *\n * @summary Registers a list of words that `pluralize` and `singularize` should always return unchanged.\n * @public\n * @since 4.13.0\n */\nexport function loadUncountable(uncountables: string[]): void {\n  uncountables.forEach((word) => {\n    uncountable(word);\n  });\n}\n\n/**\n * Marks a word as irregular. Irregular words have unique\n * pluralization and singularization rules.\n *\n * @summary Registers a singular and plural word pair that `pluralize` and `singularize` map directly instead of\n * applying rules.\n * @public\n * @since 4.13.0\n */\nexport function irregular(single: string, plur: string): void {\n  //pluralizing\n  IRREGULAR.set(single.toLowerCase(), plur);\n  IRREGULAR.set(plur.toLowerCase(), plur);\n\n  //singularizing\n  INVERSE_IRREGULAR.set(plur.toLowerCase(), single);\n  INVERSE_IRREGULAR.set(single.toLowerCase(), single);\n}\n\n/**\n * Marks a list of word pairs as irregular. Irregular words have unique\n * pluralization and singularization rules.\n *\n * @summary Registers a list of singular and plural word pairs that `pluralize` and `singularize` map directly.\n * @public\n * @since 4.13.0\n */\nexport function loadIrregular(irregularPairs: Array<[string, string]>): void {\n  irregularPairs.forEach((pair) => {\n    //pluralizing\n    IRREGULAR.set(pair[0].toLowerCase(), pair[1]);\n    IRREGULAR.set(pair[1].toLowerCase(), pair[1]);\n\n    //singularizing\n    INVERSE_IRREGULAR.set(pair[1].toLowerCase(), pair[0]);\n    INVERSE_IRREGULAR.set(pair[0].toLowerCase(), pair[0]);\n  });\n}\nloadIrregular(defaultRules.irregularPairs);\n\n/**\n * Clears the caches for singularize and pluralize.\n *\n * @summary Empties the cached results of `singularize` and `pluralize` while keeping all inflection rules.\n * @public\n * @since 4.13.0\n */\nexport function clear(): void {\n  SINGULARS.clear();\n  PLURALS.clear();\n}\n\n/**\n * Resets the inflection rules to the defaults.\n *\n * @summary Discards all custom inflection rules and caches, then restores the built-in default rules.\n * @public\n * @since 4.13.0\n */\nexport function resetToDefaults(): void {\n  clearRules();\n  defaultRules.uncountable.forEach((v) => UNCOUNTABLE.add(v));\n  defaultRules.singular.forEach((v) => SINGULAR_RULES.set(v[0], v[1]));\n  defaultRules.plurals.forEach((v) => PLURAL_RULES.set(v[0], v[1]));\n  loadIrregular(defaultRules.irregularPairs);\n}\n\n/**\n * Clears all inflection rules\n * and resets the caches for singularize and pluralize.\n *\n * @summary Removes every inflection rule, including the defaults, and empties the `singularize` and `pluralize` caches.\n * @public\n * @since 4.13.0\n */\nexport function clearRules(): void {\n  SINGULARS.clear();\n  PLURALS.clear();\n  UNCOUNTABLE.clear();\n  IRREGULAR.clear();\n  INVERSE_IRREGULAR.clear();\n  SINGULAR_RULES.clear();\n  PLURAL_RULES.clear();\n}\n\n/**\n * Singularizes a word.\n *\n * @summary Returns the singular form of an English word using the registered inflection rules, with cached results.\n * @public\n * @since 4.13.0\n */\nexport function singularize(word: string): string {\n  assert(`singularize expects to receive a non-empty string`, typeof word === 'string' && word.length > 0);\n  if (!word) return '';\n  return SINGULARS.get(word);\n}\n\n/**\n * Pluralizes a word.\n *\n * @summary Returns the plural form of an English word using the registered inflection rules, with cached results.\n * @public\n * @since 4.13.0\n */\nexport function pluralize(word: string): string {\n  assert(`pluralize expects to receive a non-empty string`, typeof word === 'string' && word.length > 0);\n  if (!word) return '';\n  return PLURALS.get(word);\n}\n\nfunction unshiftMap<K, V>(v: [K, V], map: Map<K, V>) {\n  // reorder\n  const rules = [v, ...map.entries()];\n  map.clear();\n  rules.forEach((rule) => {\n    map.set(rule[0], rule[1]);\n  });\n}\n\n/**\n * Adds a pluralization rule.\n *\n * @summary Adds a regex and replacement rule that `pluralize` checks before all existing plural rules.\n * @public\n * @since 4.13.0\n */\nexport function plural(regex: RegExp, string: string): void {\n  // rule requires reordering if exists, so remove it first\n  if (PLURAL_RULES.has(regex)) {\n    PLURAL_RULES.delete(regex);\n  }\n\n  // reorder\n  unshiftMap([regex, string], PLURAL_RULES);\n}\n\n/**\n * Adds a singularization rule.\n *\n * @summary Adds a regex and replacement rule that `singularize` checks before all existing singular rules.\n * @public\n * @since 4.13.0\n */\nexport function singular(regex: RegExp, string: string): void {\n  // rule requires reordering if exists, so remove it first\n  if (SINGULAR_RULES.has(regex)) {\n    SINGULAR_RULES.delete(regex);\n  }\n\n  // reorder\n  unshiftMap([regex, string], SINGULAR_RULES);\n}\n\nfunction _pluralize(word: string) {\n  return inflect(word, PLURAL_RULES, IRREGULAR);\n}\n\nfunction _singularize(word: string) {\n  return inflect(word, SINGULAR_RULES, INVERSE_IRREGULAR);\n}\n\nfunction inflect(word: string, typeRules: Map<RegExp, string>, irregulars: Map<string, string>) {\n  // empty strings\n  const isBlank = !word || BLANK_REGEX.test(word);\n  if (isBlank) {\n    return word;\n  }\n\n  // basic uncountables\n  const lowercase = word.toLowerCase();\n  if (UNCOUNTABLE.has(lowercase)) {\n    return word;\n  }\n\n  // adv uncountables\n  const wordSplit = LAST_WORD_DASHED_REGEX.exec(word) || LAST_WORD_CAMELIZED_REGEX.exec(word);\n  const lastWord = wordSplit ? wordSplit[2].toLowerCase() : null;\n  if (lastWord && UNCOUNTABLE.has(lastWord)) {\n    return word;\n  }\n\n  // handle irregulars\n  const isCamelized = CAMELIZED_REGEX.test(word);\n  for (let [rule, substitution] of irregulars) {\n    if (lowercase.match(rule + '$')) {\n      if (isCamelized && lastWord && irregulars.has(lastWord)) {\n        substitution = capitalize(substitution);\n        rule = capitalize(rule);\n      }\n\n      return word.replace(new RegExp(rule, 'i'), substitution);\n    }\n  }\n\n  // do the actual inflection\n  for (const [rule, substitution] of typeRules) {\n    if (rule.test(word)) {\n      return word.replace(rule, substitution);\n    }\n  }\n\n  return word;\n}\n"],"mappings":"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"}

package/dist/unpkg/prod/string.js

@@ -1,3 +1,3 @@
-import { a as loadUncountable, c as resetToDefaults, d as uncountable, f as camelize, g as underscore, h as setMaxLRUCacheSize, i as loadIrregular, l as singular, m as dasherize, n as clearRules, o as plural, p as capitalize, r as irregular, s as pluralize, t as clear, u as singularize } from "./string-D8BEYx2W.js";
+import { a as loadUncountable, c as resetToDefaults, d as uncountable, f as camelize, g as underscore, h as setMaxLRUCacheSize, i as loadIrregular, l as singular, m as dasherize, n as clearRules, o as plural, p as capitalize, r as irregular, s as pluralize, t as clear, u as singularize } from "./string-Du9nRZEd.js";
 
 export { camelize, capitalize, clear, clearRules, dasherize, irregular, loadIrregular, loadUncountable, plural, pluralize, resetToDefaults, setMaxLRUCacheSize, singular, singularize, uncountable, underscore };

package/dist/unpkg/prod-deprecated/-private.js

@@ -1,3 +1,3 @@
-import { t as defaultRules } from "./inflections-DzBsjJqj.js";
+import { t as defaultRules } from "./inflections-CWdUh2K_.js";
 
 export { defaultRules as InflectionRuleDefaults };

package/dist/unpkg/prod-deprecated/active-record.js

@@ -1,9 +1,9 @@
 import { buildBaseURL, buildQueryParams } from "./index.js";
-import { g as underscore, s as pluralize } from "./string-D8BEYx2W.js";
-import { n as extractCacheOptions, t as copyForwardUrlOptions } from "./builder-utils-BkXwUT0x.js";
+import { g as underscore, s as pluralize } from "./string-Du9nRZEd.js";
+import { n as extractCacheOptions, t as copyForwardUrlOptions } from "./builder-utils-bjXbHa-m.js";
 import { recordIdentifierFor } from "@warp-drive/core";
 
-//#region src/-private/active-record/find-record.ts
+// src/-private/active-record/find-record.ts
 function findRecord(arg1, arg2, arg3) {
 	const identifier = typeof arg1 === "string" ? {
 		type: arg1,
@@ -30,8 +30,7 @@ function findRecord(arg1, arg2, arg3) {
 	};
 }
 
-//#endregion
-//#region src/-private/active-record/query.ts
+// src/-private/active-record/query.ts
 function query(type, query = {}, options = {}) {
 	const cacheOptions = extractCacheOptions(options);
 	const urlOptions = {
@@ -53,8 +52,7 @@ function query(type, query = {}, options = {}) {
 	};
 }
 
-//#endregion
-//#region src/-private/active-record/save-record.ts
+// src/-private/active-record/save-record.ts
 /**
 * Builds request options to delete record for resources,
 * configured for the url, method and header expectations of ActiveRecord APIs.
@@ -258,6 +256,5 @@ function updateRecord(record, options = {}) {
 	};
 }
 
-//#endregion
 export { createRecord, deleteRecord, findRecord, query, updateRecord };
 //# sourceMappingURL=active-record.js.map

package/dist/unpkg/prod-deprecated/active-record.js.map

@@ -1 +1 @@
-{"version":3,"file":"active-record.js","names":["recordIdentifierFor","buildBaseURL","pluralize","underscore","copyForwardUrlOptions","isExisting","identifier","id","type","deleteRecord","record","options","urlOptions","op","resourcePath","url","headers","Headers","append","method","data","records","createRecord","updateRecord","patch"],"sources":["../../../src/-private/active-record/find-record.ts","../../../src/-private/active-record/query.ts","../../../src/-private/active-record/save-record.ts"],"sourcesContent":["import type { ReactiveDataDocument } from '@warp-drive/core/reactive';\nimport type { TypeFromInstance } from '@warp-drive/core/types/record';\nimport type {\n  FindRecordOptions,\n  FindRecordRequestOptions,\n  RemotelyAccessibleIdentifier,\n} from '@warp-drive/core/types/request';\nimport type { Meta } from '@warp-drive/core/types/spec/json-api-raw';\n\nimport { buildBaseURL, buildQueryParams, type FindRecordUrlOptions } from '../../index.ts';\nimport { pluralize, underscore } from '../../string.ts';\nimport { copyForwardUrlOptions, extractCacheOptions } from '../builder-utils.ts';\n\n/**\n * Builds request options to fetch a single resource by a known id or identifier\n * configured for the url and header expectations of most ActiveRecord APIs.\n *\n * See the [Builders](/guides/the-manual/requests/builders) guide for what request builders do and\n * when to use one.\n *\n * **Basic Usage**\n *\n * ```ts\n * import { findRecord } from '@warp-drive/utilities/active-record';\n *\n * const data = await store.request(findRecord('person', '1'));\n * ```\n *\n * **With Options**\n *\n * ```ts\n * import { findRecord } from '@warp-drive/utilities/active-record';\n *\n * const options = findRecord('person', '1', { include: ['pets', 'friends'] });\n * const data = await store.request(options);\n * ```\n *\n * **With an Identifier**\n *\n * ```ts\n * import { findRecord } from '@warp-drive/utilities/active-record';\n *\n * const options = findRecord({ type: 'person', id: '1' }, { include: ['pets', 'friends'] });\n * const data = await store.request(options);\n * ```\n *\n * **Supplying Options to Modify the Request Behavior**\n *\n * The following options are supported:\n *\n * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.\n * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.\n * - `resourcePath` - The resource path to use for the request, defaults to pluralizing and underscoring the supplied type\n * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this\n *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.\n * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the\n *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,\n *      defaulting to `false` if none is configured.\n * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)\n *\n * ```ts\n * import { findRecord } from '@warp-drive/utilities/active-record';\n *\n * const options = findRecord('person', '1', { include: ['pets', 'friends'] }, { namespace: 'api/v2' });\n * const data = await store.request(options);\n * ```\n *\n * @summary Builds a `GET` request for one resource by type and id, using ActiveRecord-style pluralized, underscored\n * URLs.\n * @public\n * @param identifier\n * @param options\n */\nexport function findRecord<T, M extends Meta | undefined = Meta | undefined, E extends object = object>(\n  identifier: RemotelyAccessibleIdentifier<TypeFromInstance<T>>,\n  options?: FindRecordOptions\n): FindRecordRequestOptions<ReactiveDataDocument<T, M, E>, T>;\nexport function findRecord(\n  identifier: RemotelyAccessibleIdentifier,\n  options?: FindRecordOptions\n): FindRecordRequestOptions;\nexport function findRecord<T, M extends Meta | undefined = Meta | undefined, E extends object = object>(\n  type: TypeFromInstance<T>,\n  id: string,\n  options?: FindRecordOptions\n): FindRecordRequestOptions<ReactiveDataDocument<T, M, E>, T>;\nexport function findRecord(type: string, id: string, options?: FindRecordOptions): FindRecordRequestOptions;\nexport function findRecord(\n  arg1: string | RemotelyAccessibleIdentifier,\n  arg2: string | FindRecordOptions | undefined,\n  arg3?: FindRecordOptions\n): FindRecordRequestOptions {\n  const identifier: RemotelyAccessibleIdentifier = typeof arg1 === 'string' ? { type: arg1, id: arg2 as string } : arg1;\n  const options = ((typeof arg1 === 'string' ? arg3 : arg2) || {}) as FindRecordOptions;\n  const cacheOptions = extractCacheOptions(options);\n  const urlOptions: FindRecordUrlOptions = {\n    identifier,\n    op: 'findRecord',\n    resourcePath: pluralize(underscore(identifier.type)),\n  };\n\n  copyForwardUrlOptions(urlOptions, options);\n\n  const url = buildBaseURL(urlOptions);\n  const headers = new Headers();\n  headers.append('Accept', 'application/json;charset=utf-8');\n\n  return {\n    url: options.include?.length\n      ? `${url}?${buildQueryParams({ include: options.include }, options.urlParamsSettings)}`\n      : url,\n    method: 'GET',\n    headers,\n    cacheOptions,\n    op: 'findRecord',\n    records: [identifier],\n  };\n}\n\n/** @deprecated use {@link ReactiveDataDocument} instead */\nexport type FindRecordResultDocument<\n  T,\n  M extends Meta | undefined = Meta | undefined,\n  E extends object = object,\n> = ReactiveDataDocument<T, M, E>;\n","import type { ReactiveDataDocument } from '@warp-drive/core/reactive';\nimport type { QueryParamsSource } from '@warp-drive/core/types/params';\nimport type { TypeFromInstance } from '@warp-drive/core/types/record';\nimport type { ConstrainedRequestOptions, QueryRequestOptions } from '@warp-drive/core/types/request';\nimport type { Meta } from '@warp-drive/core/types/spec/json-api-raw';\n\nimport { buildBaseURL, buildQueryParams, type QueryUrlOptions } from '../../index.ts';\nimport { pluralize, underscore } from '../../string';\nimport { copyForwardUrlOptions, extractCacheOptions } from '../builder-utils.ts';\n\n/**\n * Builds request options to query for resources, usually by a primary\n * type, configured for the url and header expectations of most ActiveRecord APIs.\n *\n * See the [Builders](/guides/the-manual/requests/builders) guide for what request builders do and\n * when to use one.\n *\n * **Basic Usage**\n *\n * ```ts\n * import { query } from '@warp-drive/utilities/active-record';\n *\n * const data = await store.request(query('person'));\n * ```\n *\n * **With Query Params**\n *\n * ```ts\n * import { query } from '@warp-drive/utilities/active-record';\n *\n * const options = query('person', { include: ['pets', 'friends'] });\n * const data = await store.request(options);\n * ```\n *\n * **Supplying Options to Modify the Request Behavior**\n *\n * The following options are supported:\n *\n * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.\n * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.\n * - `resourcePath` - The resource path to use for the request, defaults to pluralizing and underscoring the supplied type\n * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this\n *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.\n * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the\n *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,\n *      defaulting to `false` if none is configured.\n * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)\n *\n * ```ts\n * import { query } from '@warp-drive/utilities/active-record';\n *\n * const options = query('person', { include: ['pets', 'friends'] }, { reload: true });\n * const data = await store.request(options);\n * ```\n *\n * @summary Builds a `GET` request that queries a resource type with query params, using ActiveRecord-style URLs.\n * @public\n * @param identifier\n * @param query\n * @param options\n */\nexport function query<T, M extends Meta | undefined = Meta | undefined, E extends object = object>(\n  type: TypeFromInstance<T>,\n  query?: QueryParamsSource,\n  options?: ConstrainedRequestOptions\n): QueryRequestOptions<ReactiveDataDocument<T[], M, E>>;\nexport function query(\n  type: string,\n  query?: QueryParamsSource,\n  options?: ConstrainedRequestOptions\n): QueryRequestOptions;\nexport function query(\n  type: string,\n  // oxlint-disable-next-line no-shadow\n  query: QueryParamsSource = {},\n  options: ConstrainedRequestOptions = {}\n): QueryRequestOptions {\n  const cacheOptions = extractCacheOptions(options);\n  const urlOptions: QueryUrlOptions = {\n    identifier: { type },\n    op: 'query',\n    resourcePath: pluralize(underscore(type)),\n  };\n\n  copyForwardUrlOptions(urlOptions, options);\n\n  const url = buildBaseURL(urlOptions);\n  const headers = new Headers();\n  headers.append('Accept', 'application/json;charset=utf-8');\n  const queryString = buildQueryParams(query, options.urlParamsSettings);\n\n  return {\n    url: queryString ? `${url}?${queryString}` : url,\n    method: 'GET',\n    headers,\n    cacheOptions,\n    op: 'query',\n  };\n}\n","import { recordIdentifierFor } from '@warp-drive/core';\nimport { assert } from '@warp-drive/core/build-config/macros';\nimport type { ReactiveDataDocument } from '@warp-drive/core/reactive';\nimport type { PersistedResourceKey, ResourceKey } from '@warp-drive/core/types/identifier';\nimport type { TypedRecordInstance } from '@warp-drive/core/types/record';\nimport type {\n  ConstrainedRequestOptions,\n  CreateRequestOptions,\n  DeleteRequestOptions,\n  UpdateRequestOptions,\n} from '@warp-drive/core/types/request';\nimport type { Meta } from '@warp-drive/core/types/spec/json-api-raw';\n\nimport {\n  buildBaseURL,\n  type CreateRecordUrlOptions,\n  type DeleteRecordUrlOptions,\n  type UpdateRecordUrlOptions,\n} from '../../index.ts';\nimport { pluralize, underscore } from '../../string';\nimport { copyForwardUrlOptions } from '../builder-utils.ts';\n\nfunction isExisting(identifier: ResourceKey): identifier is PersistedResourceKey {\n  return 'id' in identifier && identifier.id !== null && 'type' in identifier && identifier.type !== null;\n}\n\n/**\n * Builds request options to delete record for resources,\n * configured for the url, method and header expectations of ActiveRecord APIs.\n *\n * See the [Builders](/guides/the-manual/requests/builders) guide for what request builders do and\n * when to use one.\n *\n * **Basic Usage**\n *\n * ```ts\n * import { deleteRecord } from '@warp-drive/utilities/active-record';\n *\n * const person = store.peekRecord('person', '1');\n *\n * // mark record as deleted\n * store.deleteRecord(person);\n *\n * // persist deletion\n * const data = await store.request(deleteRecord(person));\n * ```\n *\n * **Supplying Options to Modify the Request Behavior**\n *\n * The following options are supported:\n *\n * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.\n * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.\n * - `resourcePath` - The resource path to use for the request, defaults to pluralizing the supplied type\n * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this\n *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.\n * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the\n *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,\n *      defaulting to `false` if none is configured.\n * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)\n *\n * ```ts\n * import { deleteRecord } from '@warp-drive/utilities/active-record';\n *\n * const person = store.peekRecord('person', '1');\n *\n * // mark record as deleted\n * store.deleteRecord(person);\n *\n * // persist deletion\n * const options = deleteRecord(person, { namespace: 'api/v1' });\n * const data = await store.request(options);\n * ```\n *\n * @summary Builds a `DELETE` request that persists deletion of an existing record, using ActiveRecord-style URLs.\n * @public\n * @param record\n * @param options\n */\nexport function deleteRecord<T>(record: T, options?: ConstrainedRequestOptions): DeleteRequestOptions<T>;\nexport function deleteRecord(record: unknown, options?: ConstrainedRequestOptions): DeleteRequestOptions;\nexport function deleteRecord(record: unknown, options: ConstrainedRequestOptions = {}): DeleteRequestOptions {\n  const identifier = recordIdentifierFor(record);\n  assert(`Expected to be given a record instance`, identifier);\n  assert(`Cannot delete a record that does not have an associated type and id.`, isExisting(identifier));\n\n  const urlOptions: DeleteRecordUrlOptions = {\n    identifier: identifier,\n    op: 'deleteRecord',\n    resourcePath: pluralize(underscore(identifier.type)),\n  };\n\n  copyForwardUrlOptions(urlOptions, options);\n\n  const url = buildBaseURL(urlOptions);\n  const headers = new Headers();\n  headers.append('Accept', 'application/json;charset=utf-8');\n\n  return {\n    url,\n    method: 'DELETE',\n    headers,\n    op: 'deleteRecord',\n    data: {\n      record: identifier,\n    },\n    records: [identifier],\n  };\n}\n\n/**\n * Builds request options to create new record for resources,\n * configured for the url, method and header expectations of most ActiveRecord APIs.\n *\n * See the [Builders](/guides/the-manual/requests/builders) guide for what request builders do and\n * when to use one.\n *\n * **Basic Usage**\n *\n * ```ts\n * import { createRecord } from '@warp-drive/utilities/active-record';\n *\n * const person = store.createRecord('person', { name: 'Ted' });\n * const data = await store.request(createRecord(person));\n * ```\n *\n * **Supplying Options to Modify the Request Behavior**\n *\n * The following options are supported:\n *\n * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.\n * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.\n * - `resourcePath` - The resource path to use for the request, defaults to pluralizing the supplied type\n * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this\n *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.\n * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the\n *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,\n *      defaulting to `false` if none is configured.\n * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)\n *\n * ```ts\n * import { createRecord } from '@warp-drive/utilities/active-record';\n *\n * const person = store.createRecord('person', { name: 'Ted' });\n * const options = createRecord(person, { namespace: 'api/v1' });\n * const data = await store.request(options);\n * ```\n *\n * @summary Builds a `POST` request that saves a newly created record, using ActiveRecord-style URLs.\n * @public\n * @param record\n * @param options\n */\nexport function createRecord<T>(record: T, options?: ConstrainedRequestOptions): CreateRequestOptions<T>;\nexport function createRecord(record: unknown, options?: ConstrainedRequestOptions): CreateRequestOptions;\nexport function createRecord(record: unknown, options: ConstrainedRequestOptions = {}): CreateRequestOptions {\n  const identifier = recordIdentifierFor(record);\n  assert(`Expected to be given a record instance`, identifier);\n\n  const urlOptions: CreateRecordUrlOptions = {\n    identifier: identifier,\n    op: 'createRecord',\n    resourcePath: pluralize(underscore(identifier.type)),\n  };\n\n  copyForwardUrlOptions(urlOptions, options);\n\n  const url = buildBaseURL(urlOptions);\n  const headers = new Headers();\n  headers.append('Accept', 'application/json;charset=utf-8');\n\n  return {\n    url,\n    method: 'POST',\n    headers,\n    op: 'createRecord',\n    data: {\n      record: identifier,\n    },\n    records: [identifier],\n  };\n}\n\n/**\n * Builds request options to update existing record for resources,\n * configured for the url, method and header expectations of most ActiveRecord APIs.\n *\n * See the [Builders](/guides/the-manual/requests/builders) guide for what request builders do and\n * when to use one.\n *\n * **Basic Usage**\n *\n * ```ts\n * import { updateRecord } from '@warp-drive/utilities/active-record';\n *\n * const person = store.peekRecord('person', '1');\n * person.name = 'Chris';\n * const data = await store.request(updateRecord(person));\n * ```\n *\n * **Supplying Options to Modify the Request Behavior**\n *\n * The following options are supported:\n *\n * - `patch` - Allows caller to specify whether to use a PATCH request instead of a PUT request, defaults to `false`.\n * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.\n * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.\n * - `resourcePath` - The resource path to use for the request, defaults to pluralizing the supplied type\n * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this\n *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.\n * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the\n *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,\n *      defaulting to `false` if none is configured.\n * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)\n *\n * ```ts\n * import { updateRecord } from '@warp-drive/utilities/active-record';\n *\n * const person = store.peekRecord('person', '1');\n * person.name = 'Chris';\n * const options = updateRecord(person, { patch: true });\n * const data = await store.request(options);\n * ```\n *\n * @summary Builds a `PUT` (or `PATCH`) request that saves changes to an existing record, using ActiveRecord-style URLs.\n * @public\n * @param record\n * @param options\n */\nexport function updateRecord<\n  T extends TypedRecordInstance,\n  RT extends TypedRecordInstance = T,\n  M extends Meta | undefined = Meta | undefined,\n  E extends object = object,\n>(\n  record: T,\n  options?: ConstrainedRequestOptions & { patch?: boolean }\n): UpdateRequestOptions<ReactiveDataDocument<RT, M, E>, T>;\nexport function updateRecord(\n  record: unknown,\n  options?: ConstrainedRequestOptions & { patch?: boolean }\n): UpdateRequestOptions;\nexport function updateRecord(\n  record: unknown,\n  options: ConstrainedRequestOptions & { patch?: boolean } = {}\n): UpdateRequestOptions {\n  const identifier = recordIdentifierFor(record);\n  assert(`Expected to be given a record instance`, identifier);\n  assert(`Cannot update a record that does not have an associated type and id.`, isExisting(identifier));\n\n  const urlOptions: UpdateRecordUrlOptions = {\n    identifier: identifier,\n    op: 'updateRecord',\n    resourcePath: pluralize(underscore(identifier.type)),\n  };\n\n  copyForwardUrlOptions(urlOptions, options);\n\n  const url = buildBaseURL(urlOptions);\n  const headers = new Headers();\n  headers.append('Accept', 'application/json;charset=utf-8');\n\n  return {\n    url,\n    method: options.patch ? 'PATCH' : 'PUT',\n    headers,\n    op: 'updateRecord',\n    data: {\n      record: identifier,\n    },\n    records: [identifier],\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"active-record.js","names":["recordIdentifierFor","buildBaseURL","pluralize","underscore","copyForwardUrlOptions","isExisting","identifier","id","type","deleteRecord","record","options","urlOptions","op","resourcePath","url","headers","Headers","append","method","data","records","createRecord","updateRecord","patch"],"sources":["../../../src/-private/active-record/find-record.ts","../../../src/-private/active-record/query.ts","../../../src/-private/active-record/save-record.ts"],"sourcesContent":["import type { ReactiveDataDocument } from '@warp-drive/core/reactive';\nimport type { TypeFromInstance } from '@warp-drive/core/types/record';\nimport type {\n  FindRecordOptions,\n  FindRecordRequestOptions,\n  RemotelyAccessibleIdentifier,\n} from '@warp-drive/core/types/request';\nimport type { Meta } from '@warp-drive/core/types/spec/json-api-raw';\n\nimport { buildBaseURL, buildQueryParams, type FindRecordUrlOptions } from '../../index.ts';\nimport { pluralize, underscore } from '../../string.ts';\nimport { copyForwardUrlOptions, extractCacheOptions } from '../builder-utils.ts';\n\n/**\n * Builds request options to fetch a single resource by a known id or identifier\n * configured for the url and header expectations of most ActiveRecord APIs.\n *\n * See the [Builders](/guides/the-manual/requests/builders) guide for what request builders do and\n * when to use one.\n *\n * **Basic Usage**\n *\n * ```ts\n * import { findRecord } from '@warp-drive/utilities/active-record';\n *\n * const data = await store.request(findRecord('person', '1'));\n * ```\n *\n * **With Options**\n *\n * ```ts\n * import { findRecord } from '@warp-drive/utilities/active-record';\n *\n * const options = findRecord('person', '1', { include: ['pets', 'friends'] });\n * const data = await store.request(options);\n * ```\n *\n * **With an Identifier**\n *\n * ```ts\n * import { findRecord } from '@warp-drive/utilities/active-record';\n *\n * const options = findRecord({ type: 'person', id: '1' }, { include: ['pets', 'friends'] });\n * const data = await store.request(options);\n * ```\n *\n * **Supplying Options to Modify the Request Behavior**\n *\n * The following options are supported:\n *\n * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.\n * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.\n * - `resourcePath` - The resource path to use for the request, defaults to pluralizing and underscoring the supplied type\n * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this\n *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.\n * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the\n *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,\n *      defaulting to `false` if none is configured.\n * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)\n *\n * ```ts\n * import { findRecord } from '@warp-drive/utilities/active-record';\n *\n * const options = findRecord('person', '1', { include: ['pets', 'friends'] }, { namespace: 'api/v2' });\n * const data = await store.request(options);\n * ```\n *\n * @summary Builds a `GET` request for one resource by type and id, using ActiveRecord-style pluralized, underscored\n * URLs.\n * @public\n * @param identifier\n * @param options\n */\nexport function findRecord<T, M extends Meta | undefined = Meta | undefined, E extends object = object>(\n  identifier: RemotelyAccessibleIdentifier<TypeFromInstance<T>>,\n  options?: FindRecordOptions\n): FindRecordRequestOptions<ReactiveDataDocument<T, M, E>, T>;\nexport function findRecord(\n  identifier: RemotelyAccessibleIdentifier,\n  options?: FindRecordOptions\n): FindRecordRequestOptions;\nexport function findRecord<T, M extends Meta | undefined = Meta | undefined, E extends object = object>(\n  type: TypeFromInstance<T>,\n  id: string,\n  options?: FindRecordOptions\n): FindRecordRequestOptions<ReactiveDataDocument<T, M, E>, T>;\nexport function findRecord(type: string, id: string, options?: FindRecordOptions): FindRecordRequestOptions;\nexport function findRecord(\n  arg1: string | RemotelyAccessibleIdentifier,\n  arg2: string | FindRecordOptions | undefined,\n  arg3?: FindRecordOptions\n): FindRecordRequestOptions {\n  const identifier: RemotelyAccessibleIdentifier = typeof arg1 === 'string' ? { type: arg1, id: arg2 as string } : arg1;\n  const options = ((typeof arg1 === 'string' ? arg3 : arg2) || {}) as FindRecordOptions;\n  const cacheOptions = extractCacheOptions(options);\n  const urlOptions: FindRecordUrlOptions = {\n    identifier,\n    op: 'findRecord',\n    resourcePath: pluralize(underscore(identifier.type)),\n  };\n\n  copyForwardUrlOptions(urlOptions, options);\n\n  const url = buildBaseURL(urlOptions);\n  const headers = new Headers();\n  headers.append('Accept', 'application/json;charset=utf-8');\n\n  return {\n    url: options.include?.length\n      ? `${url}?${buildQueryParams({ include: options.include }, options.urlParamsSettings)}`\n      : url,\n    method: 'GET',\n    headers,\n    cacheOptions,\n    op: 'findRecord',\n    records: [identifier],\n  };\n}\n\n/** @deprecated use {@link ReactiveDataDocument} instead */\nexport type FindRecordResultDocument<\n  T,\n  M extends Meta | undefined = Meta | undefined,\n  E extends object = object,\n> = ReactiveDataDocument<T, M, E>;\n","import type { ReactiveDataDocument } from '@warp-drive/core/reactive';\nimport type { QueryParamsSource } from '@warp-drive/core/types/params';\nimport type { TypeFromInstance } from '@warp-drive/core/types/record';\nimport type { ConstrainedRequestOptions, QueryRequestOptions } from '@warp-drive/core/types/request';\nimport type { Meta } from '@warp-drive/core/types/spec/json-api-raw';\n\nimport { buildBaseURL, buildQueryParams, type QueryUrlOptions } from '../../index.ts';\nimport { pluralize, underscore } from '../../string';\nimport { copyForwardUrlOptions, extractCacheOptions } from '../builder-utils.ts';\n\n/**\n * Builds request options to query for resources, usually by a primary\n * type, configured for the url and header expectations of most ActiveRecord APIs.\n *\n * See the [Builders](/guides/the-manual/requests/builders) guide for what request builders do and\n * when to use one.\n *\n * **Basic Usage**\n *\n * ```ts\n * import { query } from '@warp-drive/utilities/active-record';\n *\n * const data = await store.request(query('person'));\n * ```\n *\n * **With Query Params**\n *\n * ```ts\n * import { query } from '@warp-drive/utilities/active-record';\n *\n * const options = query('person', { include: ['pets', 'friends'] });\n * const data = await store.request(options);\n * ```\n *\n * **Supplying Options to Modify the Request Behavior**\n *\n * The following options are supported:\n *\n * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.\n * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.\n * - `resourcePath` - The resource path to use for the request, defaults to pluralizing and underscoring the supplied type\n * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this\n *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.\n * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the\n *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,\n *      defaulting to `false` if none is configured.\n * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)\n *\n * ```ts\n * import { query } from '@warp-drive/utilities/active-record';\n *\n * const options = query('person', { include: ['pets', 'friends'] }, { reload: true });\n * const data = await store.request(options);\n * ```\n *\n * @summary Builds a `GET` request that queries a resource type with query params, using ActiveRecord-style URLs.\n * @public\n * @param identifier\n * @param query\n * @param options\n */\nexport function query<T, M extends Meta | undefined = Meta | undefined, E extends object = object>(\n  type: TypeFromInstance<T>,\n  query?: QueryParamsSource,\n  options?: ConstrainedRequestOptions\n): QueryRequestOptions<ReactiveDataDocument<T[], M, E>>;\nexport function query(\n  type: string,\n  query?: QueryParamsSource,\n  options?: ConstrainedRequestOptions\n): QueryRequestOptions;\nexport function query(\n  type: string,\n  // oxlint-disable-next-line no-shadow\n  query: QueryParamsSource = {},\n  options: ConstrainedRequestOptions = {}\n): QueryRequestOptions {\n  const cacheOptions = extractCacheOptions(options);\n  const urlOptions: QueryUrlOptions = {\n    identifier: { type },\n    op: 'query',\n    resourcePath: pluralize(underscore(type)),\n  };\n\n  copyForwardUrlOptions(urlOptions, options);\n\n  const url = buildBaseURL(urlOptions);\n  const headers = new Headers();\n  headers.append('Accept', 'application/json;charset=utf-8');\n  const queryString = buildQueryParams(query, options.urlParamsSettings);\n\n  return {\n    url: queryString ? `${url}?${queryString}` : url,\n    method: 'GET',\n    headers,\n    cacheOptions,\n    op: 'query',\n  };\n}\n","import { recordIdentifierFor } from '@warp-drive/core';\nimport { assert } from '@warp-drive/core/build-config/macros';\nimport type { ReactiveDataDocument } from '@warp-drive/core/reactive';\nimport type { PersistedResourceKey, ResourceKey } from '@warp-drive/core/types/identifier';\nimport type { TypedRecordInstance } from '@warp-drive/core/types/record';\nimport type {\n  ConstrainedRequestOptions,\n  CreateRequestOptions,\n  DeleteRequestOptions,\n  UpdateRequestOptions,\n} from '@warp-drive/core/types/request';\nimport type { Meta } from '@warp-drive/core/types/spec/json-api-raw';\n\nimport {\n  buildBaseURL,\n  type CreateRecordUrlOptions,\n  type DeleteRecordUrlOptions,\n  type UpdateRecordUrlOptions,\n} from '../../index.ts';\nimport { pluralize, underscore } from '../../string';\nimport { copyForwardUrlOptions } from '../builder-utils.ts';\n\nfunction isExisting(identifier: ResourceKey): identifier is PersistedResourceKey {\n  return 'id' in identifier && identifier.id !== null && 'type' in identifier && identifier.type !== null;\n}\n\n/**\n * Builds request options to delete record for resources,\n * configured for the url, method and header expectations of ActiveRecord APIs.\n *\n * See the [Builders](/guides/the-manual/requests/builders) guide for what request builders do and\n * when to use one.\n *\n * **Basic Usage**\n *\n * ```ts\n * import { deleteRecord } from '@warp-drive/utilities/active-record';\n *\n * const person = store.peekRecord('person', '1');\n *\n * // mark record as deleted\n * store.deleteRecord(person);\n *\n * // persist deletion\n * const data = await store.request(deleteRecord(person));\n * ```\n *\n * **Supplying Options to Modify the Request Behavior**\n *\n * The following options are supported:\n *\n * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.\n * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.\n * - `resourcePath` - The resource path to use for the request, defaults to pluralizing the supplied type\n * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this\n *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.\n * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the\n *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,\n *      defaulting to `false` if none is configured.\n * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)\n *\n * ```ts\n * import { deleteRecord } from '@warp-drive/utilities/active-record';\n *\n * const person = store.peekRecord('person', '1');\n *\n * // mark record as deleted\n * store.deleteRecord(person);\n *\n * // persist deletion\n * const options = deleteRecord(person, { namespace: 'api/v1' });\n * const data = await store.request(options);\n * ```\n *\n * @summary Builds a `DELETE` request that persists deletion of an existing record, using ActiveRecord-style URLs.\n * @public\n * @param record\n * @param options\n */\nexport function deleteRecord<T>(record: T, options?: ConstrainedRequestOptions): DeleteRequestOptions<T>;\nexport function deleteRecord(record: unknown, options?: ConstrainedRequestOptions): DeleteRequestOptions;\nexport function deleteRecord(record: unknown, options: ConstrainedRequestOptions = {}): DeleteRequestOptions {\n  const identifier = recordIdentifierFor(record);\n  assert(`Expected to be given a record instance`, identifier);\n  assert(`Cannot delete a record that does not have an associated type and id.`, isExisting(identifier));\n\n  const urlOptions: DeleteRecordUrlOptions = {\n    identifier: identifier,\n    op: 'deleteRecord',\n    resourcePath: pluralize(underscore(identifier.type)),\n  };\n\n  copyForwardUrlOptions(urlOptions, options);\n\n  const url = buildBaseURL(urlOptions);\n  const headers = new Headers();\n  headers.append('Accept', 'application/json;charset=utf-8');\n\n  return {\n    url,\n    method: 'DELETE',\n    headers,\n    op: 'deleteRecord',\n    data: {\n      record: identifier,\n    },\n    records: [identifier],\n  };\n}\n\n/**\n * Builds request options to create new record for resources,\n * configured for the url, method and header expectations of most ActiveRecord APIs.\n *\n * See the [Builders](/guides/the-manual/requests/builders) guide for what request builders do and\n * when to use one.\n *\n * **Basic Usage**\n *\n * ```ts\n * import { createRecord } from '@warp-drive/utilities/active-record';\n *\n * const person = store.createRecord('person', { name: 'Ted' });\n * const data = await store.request(createRecord(person));\n * ```\n *\n * **Supplying Options to Modify the Request Behavior**\n *\n * The following options are supported:\n *\n * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.\n * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.\n * - `resourcePath` - The resource path to use for the request, defaults to pluralizing the supplied type\n * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this\n *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.\n * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the\n *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,\n *      defaulting to `false` if none is configured.\n * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)\n *\n * ```ts\n * import { createRecord } from '@warp-drive/utilities/active-record';\n *\n * const person = store.createRecord('person', { name: 'Ted' });\n * const options = createRecord(person, { namespace: 'api/v1' });\n * const data = await store.request(options);\n * ```\n *\n * @summary Builds a `POST` request that saves a newly created record, using ActiveRecord-style URLs.\n * @public\n * @param record\n * @param options\n */\nexport function createRecord<T>(record: T, options?: ConstrainedRequestOptions): CreateRequestOptions<T>;\nexport function createRecord(record: unknown, options?: ConstrainedRequestOptions): CreateRequestOptions;\nexport function createRecord(record: unknown, options: ConstrainedRequestOptions = {}): CreateRequestOptions {\n  const identifier = recordIdentifierFor(record);\n  assert(`Expected to be given a record instance`, identifier);\n\n  const urlOptions: CreateRecordUrlOptions = {\n    identifier: identifier,\n    op: 'createRecord',\n    resourcePath: pluralize(underscore(identifier.type)),\n  };\n\n  copyForwardUrlOptions(urlOptions, options);\n\n  const url = buildBaseURL(urlOptions);\n  const headers = new Headers();\n  headers.append('Accept', 'application/json;charset=utf-8');\n\n  return {\n    url,\n    method: 'POST',\n    headers,\n    op: 'createRecord',\n    data: {\n      record: identifier,\n    },\n    records: [identifier],\n  };\n}\n\n/**\n * Builds request options to update existing record for resources,\n * configured for the url, method and header expectations of most ActiveRecord APIs.\n *\n * See the [Builders](/guides/the-manual/requests/builders) guide for what request builders do and\n * when to use one.\n *\n * **Basic Usage**\n *\n * ```ts\n * import { updateRecord } from '@warp-drive/utilities/active-record';\n *\n * const person = store.peekRecord('person', '1');\n * person.name = 'Chris';\n * const data = await store.request(updateRecord(person));\n * ```\n *\n * **Supplying Options to Modify the Request Behavior**\n *\n * The following options are supported:\n *\n * - `patch` - Allows caller to specify whether to use a PATCH request instead of a PUT request, defaults to `false`.\n * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.\n * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.\n * - `resourcePath` - The resource path to use for the request, defaults to pluralizing the supplied type\n * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this\n *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.\n * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the\n *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,\n *      defaulting to `false` if none is configured.\n * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)\n *\n * ```ts\n * import { updateRecord } from '@warp-drive/utilities/active-record';\n *\n * const person = store.peekRecord('person', '1');\n * person.name = 'Chris';\n * const options = updateRecord(person, { patch: true });\n * const data = await store.request(options);\n * ```\n *\n * @summary Builds a `PUT` (or `PATCH`) request that saves changes to an existing record, using ActiveRecord-style URLs.\n * @public\n * @param record\n * @param options\n */\nexport function updateRecord<\n  T extends TypedRecordInstance,\n  RT extends TypedRecordInstance = T,\n  M extends Meta | undefined = Meta | undefined,\n  E extends object = object,\n>(\n  record: T,\n  options?: ConstrainedRequestOptions & { patch?: boolean }\n): UpdateRequestOptions<ReactiveDataDocument<RT, M, E>, T>;\nexport function updateRecord(\n  record: unknown,\n  options?: ConstrainedRequestOptions & { patch?: boolean }\n): UpdateRequestOptions;\nexport function updateRecord(\n  record: unknown,\n  options: ConstrainedRequestOptions & { patch?: boolean } = {}\n): UpdateRequestOptions {\n  const identifier = recordIdentifierFor(record);\n  assert(`Expected to be given a record instance`, identifier);\n  assert(`Cannot update a record that does not have an associated type and id.`, isExisting(identifier));\n\n  const urlOptions: UpdateRecordUrlOptions = {\n    identifier: identifier,\n    op: 'updateRecord',\n    resourcePath: pluralize(underscore(identifier.type)),\n  };\n\n  copyForwardUrlOptions(urlOptions, options);\n\n  const url = buildBaseURL(urlOptions);\n  const headers = new Headers();\n  headers.append('Accept', 'application/json;charset=utf-8');\n\n  return {\n    url,\n    method: options.patch ? 'PATCH' : 'PUT',\n    headers,\n    op: 'updateRecord',\n    data: {\n      record: identifier,\n    },\n    records: [identifier],\n  };\n}\n"],"mappings":"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"}

package/dist/unpkg/prod-deprecated/{builder-utils-BkXwUT0x.js → builder-utils-bjXbHa-m.js}

@@ -1,4 +1,4 @@
-//#region src/-private/builder-utils.ts
+// src/-private/builder-utils.ts
 function copyForwardUrlOptions(urlOptions, options) {
 	if ("host" in options) urlOptions.host = options.host;
 	if ("namespace" in options) urlOptions.namespace = options.namespace;
@@ -11,6 +11,5 @@ function extractCacheOptions(options) {
 	return cacheOptions;
 }
 
-//#endregion
 export { extractCacheOptions as n, copyForwardUrlOptions as t };
-//# sourceMappingURL=builder-utils-BkXwUT0x.js.map
+//# sourceMappingURL=builder-utils-bjXbHa-m.js.map

package/dist/unpkg/prod-deprecated/{builder-utils-BkXwUT0x.js.map → builder-utils-bjXbHa-m.js.map}

@@ -1 +1 @@
-{"version":3,"file":"builder-utils-BkXwUT0x.js","names":[],"sources":["../../../src/-private/builder-utils.ts"],"sourcesContent":["import type { CacheOptions, ConstrainedRequestOptions } from '@warp-drive/core/types/request';\n\nimport type { UrlOptions } from '../index.ts';\n\nexport function copyForwardUrlOptions(urlOptions: UrlOptions, options: ConstrainedRequestOptions): void {\n  if ('host' in options) {\n    urlOptions.host = options.host;\n  }\n  if ('namespace' in options) {\n    urlOptions.namespace = options.namespace;\n  }\n  if ('resourcePath' in options) {\n    urlOptions.resourcePath = options.resourcePath;\n  }\n}\n\nexport function extractCacheOptions(options: ConstrainedRequestOptions): CacheOptions {\n  const cacheOptions: CacheOptions = {};\n  if ('reload' in options) {\n    cacheOptions.reload = options.reload;\n  }\n  if ('backgroundReload' in options) {\n    cacheOptions.backgroundReload = options.backgroundReload;\n  }\n  return cacheOptions;\n}\n"],"mappings":";AAIA,SAAgB,sBAAsB,YAAwB,SAA0C;CACtG,IAAI,UAAU,SACZ,WAAW,OAAO,QAAQ;CAE5B,IAAI,eAAe,SACjB,WAAW,YAAY,QAAQ;CAEjC,IAAI,kBAAkB,SACpB,WAAW,eAAe,QAAQ;AAEtC;AAEA,SAAgB,oBAAoB,SAAkD;CACpF,MAAM,eAA6B,CAAC;CACpC,IAAI,YAAY,SACd,aAAa,SAAS,QAAQ;CAEhC,IAAI,sBAAsB,SACxB,aAAa,mBAAmB,QAAQ;CAE1C,OAAO;AACT"}
+{"version":3,"file":"builder-utils-bjXbHa-m.js","names":[],"sources":["../../../src/-private/builder-utils.ts"],"sourcesContent":["import type { CacheOptions, ConstrainedRequestOptions } from '@warp-drive/core/types/request';\n\nimport type { UrlOptions } from '../index.ts';\n\nexport function copyForwardUrlOptions(urlOptions: UrlOptions, options: ConstrainedRequestOptions): void {\n  if ('host' in options) {\n    urlOptions.host = options.host;\n  }\n  if ('namespace' in options) {\n    urlOptions.namespace = options.namespace;\n  }\n  if ('resourcePath' in options) {\n    urlOptions.resourcePath = options.resourcePath;\n  }\n}\n\nexport function extractCacheOptions(options: ConstrainedRequestOptions): CacheOptions {\n  const cacheOptions: CacheOptions = {};\n  if ('reload' in options) {\n    cacheOptions.reload = options.reload;\n  }\n  if ('backgroundReload' in options) {\n    cacheOptions.backgroundReload = options.backgroundReload;\n  }\n  return cacheOptions;\n}\n"],"mappings":";AAIA,SAAgB,sBAAsB,YAAwB,SAA0C;CACtG,IAAI,UAAU,SACZ,WAAW,OAAO,QAAQ;CAE5B,IAAI,eAAe,SACjB,WAAW,YAAY,QAAQ;CAEjC,IAAI,kBAAkB,SACpB,WAAW,eAAe,QAAQ;AAEtC;AAEA,SAAgB,oBAAoB,SAAkD;CACpF,MAAM,eAA6B,CAAC;CACpC,IAAI,YAAY,SACd,aAAa,SAAS,QAAQ;CAEhC,IAAI,sBAAsB,SACxB,aAAa,mBAAmB,QAAQ;CAE1C,OAAO;AACT"}

package/dist/unpkg/prod-deprecated/derivations.js

@@ -1,6 +1,6 @@
 import { Type } from "@warp-drive/core/types/symbols";
 
-//#region src/derivations.ts
+// src/derivations.ts
 /**
 * @module
 * @summary The `concat` derivation, which joins a record's listed fields into one string with an optional separator.
@@ -31,6 +31,5 @@ const concat = (record, options, _prop) => {
 };
 concat[Type] = "concat";
 
-//#endregion
 export { concat };
 //# sourceMappingURL=derivations.js.map

package/dist/unpkg/prod-deprecated/handlers.js

@@ -1,4 +1,4 @@
-//#region src/-private/handlers/auto-compress.ts
+// src/-private/handlers/auto-compress.ts
 function isCompressibleMethod(method) {
 	return method === "POST" || method === "PUT" || method === "PATCH" || method === "DELETE";
 }
@@ -126,8 +126,7 @@ function encodingForFormat(format) {
 	}
 }
 
-//#endregion
-//#region src/-private/handlers/gated.ts
+// src/-private/handlers/gated.ts
 /**
 * If CheckFn returns true, the wrapped handler will be used.
 * If CheckFn returns false, the wrapped handler will be skipped.
@@ -156,8 +155,7 @@ var Gate = class {
 	}
 };
 
-//#endregion
-//#region src/-private/handlers/meta-doc.ts
+// src/-private/handlers/meta-doc.ts
 /**
 * MetaDocHandler processes requests that are marked as meta requests.
 *
@@ -214,8 +212,7 @@ function processResponse(response) {
 	return { meta: response.content };
 }
 
-//#endregion
-//#region src/-private/handlers/utils.ts
+// src/-private/handlers/utils.ts
 if (typeof FastBoot === "undefined") globalThis.addEventListener("beforeunload", function() {
 	sessionStorage.setItem("tab-closed", "true");
 });
@@ -283,6 +280,5 @@ const MAX_URL_LENGTH = 8192;
 */
 function assertInvalidUrlLength(url) {}
 
-//#endregion
 export { AutoCompress, Gate, MAX_URL_LENGTH, MetaDocHandler, SupportsRequestStreams, TAB_ASSIGNED, TAB_ID, addTraceHeader, assertInvalidUrlLength };
 //# sourceMappingURL=handlers.js.map

package/dist/unpkg/prod-deprecated/handlers.js.map

@@ -1 +1 @@
-{"version":3,"file":"handlers.js","names":["isCompressibleMethod","method","SupportsRequestStreams","duplexAccessed","hasContentType","Request","body","ReadableStream","duplex","headers","has","DEFAULT_CONSTRAINTS","Blob","ArrayBuffer","TypedArray","DataView","String","Object","getPrototypeOf","Uint8Array","AutoCompress","constructor","options","opts","format","constraints","assign","allowStreaming","forceStreaming","request","next","shouldCompress","compress","canCompress","length","size","byteLength","response","Response","stream","pipeThrough","CompressionStream","Headers","set","encodingForFormat","req","resp","blob","then","type","Gate","constructor","handler","checkFn","request","context","next","FastBoot","globalThis","addEventListener","sessionStorage","setItem","getTabId","crypto","randomUUID","tabId","getItem","tabClosed","newTabId","TAB_ID","TAB_ASSIGNED","Math","floor","Date","now","addTraceHeader","headers","set","MAX_URL_LENGTH","assertInvalidUrlLength","url"],"sources":["../../../src/-private/handlers/auto-compress.ts","../../../src/-private/handlers/gated.ts","../../../src/-private/handlers/meta-doc.ts","../../../src/-private/handlers/utils.ts"],"sourcesContent":["import { assert } from '@warp-drive/core/build-config/macros';\nimport type { Future, Handler, NextFn } from '@warp-drive/core/request';\nimport type { HTTPMethod, RequestContext } from '@warp-drive/core/types/request';\n\nfunction isCompressibleMethod(method?: HTTPMethod): boolean {\n  return method === 'POST' || method === 'PUT' || method === 'PATCH' || method === 'DELETE';\n}\n\n/**\n * Whether the browser supports `ReadableStream` as a request body\n * in a `POST` request.\n *\n * @summary Whether the current browser can send a `ReadableStream` as a `fetch` request body, detected once at\n * module load.\n * @group Constants\n */\nexport const SupportsRequestStreams: boolean = (() => {\n  let duplexAccessed = false;\n\n  const hasContentType = new Request('', {\n    body: new ReadableStream(),\n    method: 'POST',\n    // @ts-expect-error untyped\n    get duplex() {\n      duplexAccessed = true;\n      return 'half';\n    },\n  }).headers.has('Content-Type');\n\n  return duplexAccessed && !hasContentType;\n})();\n\n/**\n * The minimum body size, per body type, at which {@link AutoCompress} compresses a request\n * body. Passed as {@link CompressionOptions.constraints}.\n *\n * @summary Minimum request body sizes, per body type, at which `AutoCompress` compresses a body.\n * @public\n */\nexport interface Constraints {\n  /**\n   * The minimum size at which to compress blobs\n   *\n   * @default 1000\n   */\n  Blob?: number;\n  /**\n   * The minimum size at which to compress array buffers\n   *\n   * @default 1000\n   */\n  ArrayBuffer?: number;\n  /**\n   * The minimum size at which to compress typed arrays\n   *\n   * @default 1000\n   */\n  TypedArray?: number;\n  /**\n   * The minimum size at which to compress data views\n   *\n   * @default 1000\n   */\n  DataView?: number;\n  /**\n   * The minimum size at which to compress strings\n   *\n   * @default 1000\n   */\n  String?: number;\n}\n\n/**\n * Options for configuring the {@link AutoCompress} handler.\n *\n * @summary Options for `new AutoCompress()`: the compression format, size constraints and whether to stream the body.\n * @public\n */\nexport interface CompressionOptions {\n  /**\n   * The compression format to use. Must be a valid\n   * compression format supported by [CompressionStream](https://developer.mozilla.org/en-US/docs/Web/API/CompressionStream)\n   *\n   * The default is `gzip`.\n   *\n   */\n  format?: CompressionFormat;\n\n  /**\n   * Some browsers support `ReadableStream` as a request body. This option\n   * enables passing the compression stream as the request body instead of\n   * the final compressed body when the browser supports doing so.\n   *\n   * This comes with several caveats:\n   *\n   * - the request will be put into `duplex: 'half'` mode. This should be\n   *   transparent to you, but it is worth noting.\n   * - the request mode cannot be `no-cors` as requests with a `ReadableStream`\n   *   have no content length and thus are a new form of request that triggers\n   *   cors requirements and a preflight request.\n   * - http/1.x is not supported.\n   *\n   * For additional reading about the restrictions of using `ReadableStream`\n   * as a request body, see the [Chromium Documentation](https://developer.chrome.com/docs/capabilities/web-apis/fetch-streaming-requests#restrictions)\n   *\n   * Streaming can be enabled per-request in browsers which support it by\n   * setting `request.options.allowStreaming` to `true`.\n   *\n   * Streaming can be forced even when the browser does not support it by setting\n   * `request.options.forceStreaming` to `true`. This is useful if later handlers\n   * in the chain can handle the request body as a stream.\n   *\n   * @default false\n   */\n  allowStreaming?: boolean;\n\n  /**\n   * If `true`, the request will be forced into streaming mode even\n   * if the browser does not support it. This is useful if later handlers\n   * in the chain can handle the request body as a stream.\n   *\n   * @default false\n   */\n  forceStreaming?: boolean;\n\n  /**\n   * The constraints for the request body. This is used to determine\n   * whether to compress the request body or not.\n   *\n   * The defaults are:\n   *\n   * ```ts\n   * {\n   *   Blob: 1000, // blob.size\n   *   ArrayBuffer: 1000, // buffer.byteLength\n   *   TypedArray: 1000, // array.byteLength\n   *   DataView: 1000, // view.byteLength\n   *   String: 1000, // string.length\n   * }\n   * ```\n   *\n   * The following body types are never compressed unless explicitly\n   * configured by the request:\n   * - `FormData`\n   * - `URLSearchParams`\n   * - `ReadableStream`\n   *\n   * A request.options.compress value of `false` will disable\n   * compression for a request body of any type. While a value of\n   * `true` will enable compression for the request.\n   *\n   * An undefined value will use the default, a value of `0` will\n   * enable compression for all values, and a value of `-1` will\n   * disable compression.\n   *\n   */\n  constraints?: Constraints;\n}\n\nconst DEFAULT_CONSTRAINTS = {\n  Blob: 1000,\n  ArrayBuffer: 1000,\n  TypedArray: 1000,\n  DataView: 1000,\n  String: 1000,\n};\nconst TypedArray = Object.getPrototypeOf(Uint8Array) as typeof Uint8Array;\n\n/**\n * A request handler that automatically compresses the request body\n * if the request body is a string, array buffer, blob, or form data.\n *\n * This uses the [CompressionStream API](https://developer.mozilla.org/en-US/docs/Web/API/CompressionStream)\n *\n * The compression format as well as the kinds of data to compress can be\n * configured using the `format` and `constraints` options.\n *\n * ```diff\n * +import { AutoCompress } from '@ember-data/request-utils/handlers';\n * import Fetch from '@ember-data/request/fetch';\n * import RequestManager from '@ember-data/request';\n * import Store from '@ember-data/store';\n *\n * class AppStore extends Store {\n *   requestManager = new RequestManager()\n *     .use([\n * +       new AutoCompress(),\n *        Fetch\n *     ]);\n * }\n * ```\n *\n * @summary Request handler that compresses large `POST`, `PUT`, `PATCH`, and `DELETE` bodies with `CompressionStream`,\n * optionally streaming them.\n * @group Handlers\n * @public\n * @since 5.5.0\n */\nexport class AutoCompress implements Handler {\n  /**\n   * The resolved options this handler was configured with, with all\n   * defaults (including `constraints` defaults) applied.\n   */\n  declare options: Required<CompressionOptions> & {\n    /**\n     * The resolved size constraints used to decide whether to compress a given request body.\n     */\n    constraints: Required<Constraints>;\n  };\n\n  constructor(options: CompressionOptions = {}) {\n    const opts = {\n      format: options.format ?? 'gzip',\n      constraints: Object.assign({}, DEFAULT_CONSTRAINTS, options.constraints),\n      allowStreaming: options.allowStreaming ?? false,\n      forceStreaming: options.forceStreaming ?? false,\n    };\n    this.options = opts;\n  }\n\n  request<T>({ request }: RequestContext, next: NextFn<T>): Promise<T> | Future<T> {\n    const { constraints } = this.options;\n    const { body } = request;\n\n    const shouldCompress =\n      !!body &&\n      isCompressibleMethod(request.method) &&\n      request.options?.compress !== false &&\n      // prettier-ignore\n      (request.options?.compress ? true\n      : typeof body === 'string' || body instanceof String ? canCompress('String', constraints, body.length)\n      : body instanceof Blob ? canCompress('Blob', constraints, body.size)\n      : body instanceof ArrayBuffer ? canCompress('ArrayBuffer', constraints, body.byteLength)\n      : body instanceof DataView ? canCompress('DataView', constraints, body.byteLength)\n      : body instanceof TypedArray ? canCompress('TypedArray', constraints, body.byteLength)\n      : false);\n\n    if (!shouldCompress) return next(request);\n\n    // A convenient way to convert all of the supported body types to a readable\n    // stream is to use a `Response` object body\n    const response = new Response(request.body);\n    const stream = response.body?.pipeThrough(new CompressionStream(this.options.format));\n    const headers = new Headers(request.headers);\n    headers.set('Content-Encoding', encodingForFormat(this.options.format));\n\n    //\n    // For browsers that support it, `fetch` can receive a `ReadableStream` as\n    // the body, so all we need to do is to create a new `ReadableStream` and\n    // compress it on the fly\n    //\n    const forceStreaming = request.options?.forceStreaming ?? this.options.forceStreaming;\n    const allowStreaming = request.options?.allowStreaming ?? this.options.allowStreaming;\n    if (forceStreaming || (SupportsRequestStreams && allowStreaming)) {\n      const req = Object.assign({}, request, {\n        body: stream,\n        headers,\n      });\n      if (SupportsRequestStreams) {\n        // @ts-expect-error untyped\n        req.duplex = 'half';\n      }\n\n      return next(req);\n\n      //\n      // For non-chromium browsers, we have to \"pull\" the stream to get the final\n      // bytes and supply the final byte array as the new request body.\n      //\n    }\n\n    // we need to pull the stream to get the final bytes\n    const resp = new Response(stream);\n    return resp.blob().then((blob) => {\n      const req = Object.assign({}, request, {\n        body: blob,\n        headers,\n      });\n      return next(req);\n    }) as Promise<T>;\n  }\n}\n\nfunction canCompress(type: keyof Constraints, constraints: Required<Constraints>, size: number): boolean {\n  // if we have a value of 0, we can compress anything\n  if (constraints[type] === 0) return true;\n  if (constraints[type] === -1) return false;\n  return size >= constraints[type];\n}\n\nfunction encodingForFormat(format: CompressionFormat): string {\n  switch (format) {\n    case 'gzip':\n    case 'deflate':\n    case 'deflate-raw':\n      return format;\n    default:\n      assert(`Unsupported compression format: ${format as unknown as string}`);\n      // @ts-expect-error - unreachable code is reachable in production\n      return format;\n  }\n}\n","import type { Future, Handler, NextFn } from '@warp-drive/core/request';\nimport type { RequestContext, StructuredDataDocument } from '@warp-drive/core/types/request';\n\n/**\n * If CheckFn returns true, the wrapped handler will be used.\n * If CheckFn returns false, the wrapped handler will be skipped.\n */\ntype CheckFn = (context: RequestContext) => boolean;\n\n/**\n *\n * @summary Request handler that wraps another handler and runs it only when a check function returns true for the\n * request.\n * @group Handlers\n * @public\n */\nexport class Gate implements Handler {\n  /**\n   * The wrapped handler to invoke when {@link Gate.checkFn | checkFn} returns `true`.\n   */\n  declare handler: Handler;\n  /**\n   * The predicate used to decide whether {@link Gate.handler | handler} should run for a given request.\n   */\n  declare checkFn: CheckFn;\n\n  constructor(handler: Handler, checkFn: CheckFn) {\n    this.handler = handler;\n    this.checkFn = checkFn;\n  }\n\n  request<T = unknown>(context: RequestContext, next: NextFn<T>): Promise<T | StructuredDataDocument<T>> | Future<T> {\n    if (this.checkFn(context)) {\n      return this.handler.request(context, next);\n    }\n    return next(context.request);\n  }\n}\n","import type { StoreRequestContext } from '@warp-drive/core';\nimport type { Handler, NextFn } from '@warp-drive/core/request';\nimport type { StructuredDataDocument } from '@warp-drive/core/types/request';\n\n/**\n * MetaDocHandler processes requests that are marked as meta requests.\n *\n * It treats the response body as \"entirely meta\" transforming\n *\n * ```ts\n * {\n *   some: \"key\",\n *   another: \"thing\"\n * }\n * ```\n *\n * into\n *\n * ```ts\n * {\n * \t meta: {\n *     some: \"key\",\n *     another: \"thing\"\n *   }\n * }\n * ```\n *\n * To activate this handler, a request should specify\n *\n * ```ts\n * options.isMetaRequest = true\n * ```\n *\n * For instance\n *\n * ```ts\n * store.request({\n *   url: '/example',\n *   options: {\n *     isMetaRequest: true\n *   }\n * });\n * ```\n *\n * Errors are not processed by this handler, so if the request fails and the error response\n * is not in {json:api} format additional processing may be needed.\n *\n * @summary Request handler that wraps the whole response body in `meta` for requests with `options.isMetaRequest` set.\n * @group Handlers\n */\nexport const MetaDocHandler: Handler = {\n  request<T>(context: StoreRequestContext, next: NextFn<T>): Promise<T | StructuredDataDocument<T> | Awaited<T>> {\n    if (!context.request.options?.isMetaRequest) {\n      return next(context.request);\n    }\n\n    return next(context.request).then((response) => {\n      return processResponse<T>(response);\n    });\n  },\n};\n\nfunction processResponse<T>(response: StructuredDataDocument<T>): T {\n  return {\n    meta: response.content,\n  } as T;\n}\n","import { assert } from '@warp-drive/core/build-config/macros';\n\nif (typeof FastBoot === 'undefined') {\n  globalThis.addEventListener('beforeunload', function () {\n    sessionStorage.setItem('tab-closed', 'true');\n  });\n}\n\nfunction getTabId() {\n  if (typeof sessionStorage === 'undefined') {\n    return crypto.randomUUID();\n  }\n\n  const tabId = sessionStorage.getItem('tab-id');\n  if (tabId) {\n    const tabClosed = sessionStorage.getItem('tab-closed');\n    if (tabClosed === 'true') {\n      return tabId;\n    }\n\n    // fall through to generate a new tab id\n  }\n\n  const newTabId = crypto.randomUUID();\n  sessionStorage.setItem('tab-id', newTabId);\n  return newTabId;\n}\n\n/**\n * A unique identifier for the current browser tab\n * useful for observability/tracing and deduping\n * across multiple tabs.\n *\n * @summary Random UUID identifying the current browser tab, kept in `sessionStorage` across reloads, for request\n * tracing.\n * @group Constants\n */\nexport const TAB_ID: string = getTabId();\n/**\n * The epoch seconds at which the tab id was generated\n *\n * @summary Epoch seconds recorded when this module loaded, paired with `TAB_ID` in trace headers.\n * @group Constants\n */\nexport const TAB_ASSIGNED: number = Math.floor(Date.now() / 1000);\n\n/**\n * Adds the `X-Amzn-Trace-Id` header to support observability\n * tooling around request routing.\n *\n * This makes use of the {@link TAB_ID} and {@link TAB_ASSIGNED}\n * to enable tracking the browser tab of origin across multiple requests.\n *\n * Follows the template: `Root=1-${now}-${uuidv4};TabId=1-${epochSeconds}-${tab-uuid}`\n *\n * @summary Sets an `X-Amzn-Trace-Id` header carrying a per-request id and the tab id, so requests can be traced to\n * their browser tab.\n * @group Utility Functions\n */\nexport function addTraceHeader(headers: Headers): Headers {\n  const now = Math.floor(Date.now() / 1000);\n  headers.set('X-Amzn-Trace-Id', `Root=1-${now}-${crypto.randomUUID()};TabId=1-${TAB_ASSIGNED}-${TAB_ID}`);\n\n  return headers;\n}\n\n/**\n * Source: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html\n * As of 2024-12-05 the maximum URL length is 8192 bytes.\n *\n * @summary The 8192-byte URL length limit, taken from AWS CloudFront, that `assertInvalidUrlLength` checks against.\n * @group Constants\n */\nexport const MAX_URL_LENGTH = 8192;\n\n/**\n * This assertion takes a URL and throws an error if the URL is longer than the maximum URL length.\n *\n * See also {@link MAX_URL_LENGTH}\n *\n * @summary Dev-mode assertion that throws when a URL is longer than `MAX_URL_LENGTH`, suggesting a `POST` or `QUERY`\n * request instead.\n * @group Utility Functions\n */\nexport function assertInvalidUrlLength(url: string | undefined): void {\n  assert(\n    `URL length ${url?.length} exceeds the maximum URL length of ${MAX_URL_LENGTH} bytes.\\n\\nConsider converting this request query a \\`/query\\` endpoint instead of a GET, or upgrade the current endpoint to be able to receive a POST request directly (ideally specifying the header HTTP-Method-Override: QUERY)\\n\\nThe Invalid URL is:\\n\\n${url}`,\n    !url || url.length <= MAX_URL_LENGTH\n  );\n}\n"],"mappings":"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"}
+{"version":3,"file":"handlers.js","names":["isCompressibleMethod","method","SupportsRequestStreams","duplexAccessed","hasContentType","Request","body","ReadableStream","duplex","headers","has","DEFAULT_CONSTRAINTS","Blob","ArrayBuffer","TypedArray","DataView","String","Object","getPrototypeOf","Uint8Array","AutoCompress","constructor","options","opts","format","constraints","assign","allowStreaming","forceStreaming","request","next","shouldCompress","compress","canCompress","length","size","byteLength","response","Response","stream","pipeThrough","CompressionStream","Headers","set","encodingForFormat","req","resp","blob","then","type","Gate","constructor","handler","checkFn","request","context","next","FastBoot","globalThis","addEventListener","sessionStorage","setItem","getTabId","crypto","randomUUID","tabId","getItem","tabClosed","newTabId","TAB_ID","TAB_ASSIGNED","Math","floor","Date","now","addTraceHeader","headers","set","MAX_URL_LENGTH","assertInvalidUrlLength","url"],"sources":["../../../src/-private/handlers/auto-compress.ts","../../../src/-private/handlers/gated.ts","../../../src/-private/handlers/meta-doc.ts","../../../src/-private/handlers/utils.ts"],"sourcesContent":["import { assert } from '@warp-drive/core/build-config/macros';\nimport type { Future, Handler, NextFn } from '@warp-drive/core/request';\nimport type { HTTPMethod, RequestContext } from '@warp-drive/core/types/request';\n\nfunction isCompressibleMethod(method?: HTTPMethod): boolean {\n  return method === 'POST' || method === 'PUT' || method === 'PATCH' || method === 'DELETE';\n}\n\n/**\n * Whether the browser supports `ReadableStream` as a request body\n * in a `POST` request.\n *\n * @summary Whether the current browser can send a `ReadableStream` as a `fetch` request body, detected once at\n * module load.\n * @group Constants\n */\nexport const SupportsRequestStreams: boolean = (() => {\n  let duplexAccessed = false;\n\n  const hasContentType = new Request('', {\n    body: new ReadableStream(),\n    method: 'POST',\n    // @ts-expect-error untyped\n    get duplex() {\n      duplexAccessed = true;\n      return 'half';\n    },\n  }).headers.has('Content-Type');\n\n  return duplexAccessed && !hasContentType;\n})();\n\n/**\n * The minimum body size, per body type, at which {@link AutoCompress} compresses a request\n * body. Passed as {@link CompressionOptions.constraints}.\n *\n * @summary Minimum request body sizes, per body type, at which `AutoCompress` compresses a body.\n * @public\n */\nexport interface Constraints {\n  /**\n   * The minimum size at which to compress blobs\n   *\n   * @default 1000\n   */\n  Blob?: number;\n  /**\n   * The minimum size at which to compress array buffers\n   *\n   * @default 1000\n   */\n  ArrayBuffer?: number;\n  /**\n   * The minimum size at which to compress typed arrays\n   *\n   * @default 1000\n   */\n  TypedArray?: number;\n  /**\n   * The minimum size at which to compress data views\n   *\n   * @default 1000\n   */\n  DataView?: number;\n  /**\n   * The minimum size at which to compress strings\n   *\n   * @default 1000\n   */\n  String?: number;\n}\n\n/**\n * Options for configuring the {@link AutoCompress} handler.\n *\n * @summary Options for `new AutoCompress()`: the compression format, size constraints and whether to stream the body.\n * @public\n */\nexport interface CompressionOptions {\n  /**\n   * The compression format to use. Must be a valid\n   * compression format supported by [CompressionStream](https://developer.mozilla.org/en-US/docs/Web/API/CompressionStream)\n   *\n   * The default is `gzip`.\n   *\n   */\n  format?: CompressionFormat;\n\n  /**\n   * Some browsers support `ReadableStream` as a request body. This option\n   * enables passing the compression stream as the request body instead of\n   * the final compressed body when the browser supports doing so.\n   *\n   * This comes with several caveats:\n   *\n   * - the request will be put into `duplex: 'half'` mode. This should be\n   *   transparent to you, but it is worth noting.\n   * - the request mode cannot be `no-cors` as requests with a `ReadableStream`\n   *   have no content length and thus are a new form of request that triggers\n   *   cors requirements and a preflight request.\n   * - http/1.x is not supported.\n   *\n   * For additional reading about the restrictions of using `ReadableStream`\n   * as a request body, see the [Chromium Documentation](https://developer.chrome.com/docs/capabilities/web-apis/fetch-streaming-requests#restrictions)\n   *\n   * Streaming can be enabled per-request in browsers which support it by\n   * setting `request.options.allowStreaming` to `true`.\n   *\n   * Streaming can be forced even when the browser does not support it by setting\n   * `request.options.forceStreaming` to `true`. This is useful if later handlers\n   * in the chain can handle the request body as a stream.\n   *\n   * @default false\n   */\n  allowStreaming?: boolean;\n\n  /**\n   * If `true`, the request will be forced into streaming mode even\n   * if the browser does not support it. This is useful if later handlers\n   * in the chain can handle the request body as a stream.\n   *\n   * @default false\n   */\n  forceStreaming?: boolean;\n\n  /**\n   * The constraints for the request body. This is used to determine\n   * whether to compress the request body or not.\n   *\n   * The defaults are:\n   *\n   * ```ts\n   * {\n   *   Blob: 1000, // blob.size\n   *   ArrayBuffer: 1000, // buffer.byteLength\n   *   TypedArray: 1000, // array.byteLength\n   *   DataView: 1000, // view.byteLength\n   *   String: 1000, // string.length\n   * }\n   * ```\n   *\n   * The following body types are never compressed unless explicitly\n   * configured by the request:\n   * - `FormData`\n   * - `URLSearchParams`\n   * - `ReadableStream`\n   *\n   * A request.options.compress value of `false` will disable\n   * compression for a request body of any type. While a value of\n   * `true` will enable compression for the request.\n   *\n   * An undefined value will use the default, a value of `0` will\n   * enable compression for all values, and a value of `-1` will\n   * disable compression.\n   *\n   */\n  constraints?: Constraints;\n}\n\nconst DEFAULT_CONSTRAINTS = {\n  Blob: 1000,\n  ArrayBuffer: 1000,\n  TypedArray: 1000,\n  DataView: 1000,\n  String: 1000,\n};\nconst TypedArray = Object.getPrototypeOf(Uint8Array) as typeof Uint8Array;\n\n/**\n * A request handler that automatically compresses the request body\n * if the request body is a string, array buffer, blob, or form data.\n *\n * This uses the [CompressionStream API](https://developer.mozilla.org/en-US/docs/Web/API/CompressionStream)\n *\n * The compression format as well as the kinds of data to compress can be\n * configured using the `format` and `constraints` options.\n *\n * ```diff\n * +import { AutoCompress } from '@ember-data/request-utils/handlers';\n * import Fetch from '@ember-data/request/fetch';\n * import RequestManager from '@ember-data/request';\n * import Store from '@ember-data/store';\n *\n * class AppStore extends Store {\n *   requestManager = new RequestManager()\n *     .use([\n * +       new AutoCompress(),\n *        Fetch\n *     ]);\n * }\n * ```\n *\n * @summary Request handler that compresses large `POST`, `PUT`, `PATCH`, and `DELETE` bodies with `CompressionStream`,\n * optionally streaming them.\n * @group Handlers\n * @public\n * @since 5.5.0\n */\nexport class AutoCompress implements Handler {\n  /**\n   * The resolved options this handler was configured with, with all\n   * defaults (including `constraints` defaults) applied.\n   */\n  declare options: Required<CompressionOptions> & {\n    /**\n     * The resolved size constraints used to decide whether to compress a given request body.\n     */\n    constraints: Required<Constraints>;\n  };\n\n  constructor(options: CompressionOptions = {}) {\n    const opts = {\n      format: options.format ?? 'gzip',\n      constraints: Object.assign({}, DEFAULT_CONSTRAINTS, options.constraints),\n      allowStreaming: options.allowStreaming ?? false,\n      forceStreaming: options.forceStreaming ?? false,\n    };\n    this.options = opts;\n  }\n\n  request<T>({ request }: RequestContext, next: NextFn<T>): Promise<T> | Future<T> {\n    const { constraints } = this.options;\n    const { body } = request;\n\n    const shouldCompress =\n      !!body &&\n      isCompressibleMethod(request.method) &&\n      request.options?.compress !== false &&\n      // prettier-ignore\n      (request.options?.compress ? true\n      : typeof body === 'string' || body instanceof String ? canCompress('String', constraints, body.length)\n      : body instanceof Blob ? canCompress('Blob', constraints, body.size)\n      : body instanceof ArrayBuffer ? canCompress('ArrayBuffer', constraints, body.byteLength)\n      : body instanceof DataView ? canCompress('DataView', constraints, body.byteLength)\n      : body instanceof TypedArray ? canCompress('TypedArray', constraints, body.byteLength)\n      : false);\n\n    if (!shouldCompress) return next(request);\n\n    // A convenient way to convert all of the supported body types to a readable\n    // stream is to use a `Response` object body\n    const response = new Response(request.body);\n    const stream = response.body?.pipeThrough(new CompressionStream(this.options.format));\n    const headers = new Headers(request.headers);\n    headers.set('Content-Encoding', encodingForFormat(this.options.format));\n\n    //\n    // For browsers that support it, `fetch` can receive a `ReadableStream` as\n    // the body, so all we need to do is to create a new `ReadableStream` and\n    // compress it on the fly\n    //\n    const forceStreaming = request.options?.forceStreaming ?? this.options.forceStreaming;\n    const allowStreaming = request.options?.allowStreaming ?? this.options.allowStreaming;\n    if (forceStreaming || (SupportsRequestStreams && allowStreaming)) {\n      const req = Object.assign({}, request, {\n        body: stream,\n        headers,\n      });\n      if (SupportsRequestStreams) {\n        // @ts-expect-error untyped\n        req.duplex = 'half';\n      }\n\n      return next(req);\n\n      //\n      // For non-chromium browsers, we have to \"pull\" the stream to get the final\n      // bytes and supply the final byte array as the new request body.\n      //\n    }\n\n    // we need to pull the stream to get the final bytes\n    const resp = new Response(stream);\n    return resp.blob().then((blob) => {\n      const req = Object.assign({}, request, {\n        body: blob,\n        headers,\n      });\n      return next(req);\n    }) as Promise<T>;\n  }\n}\n\nfunction canCompress(type: keyof Constraints, constraints: Required<Constraints>, size: number): boolean {\n  // if we have a value of 0, we can compress anything\n  if (constraints[type] === 0) return true;\n  if (constraints[type] === -1) return false;\n  return size >= constraints[type];\n}\n\nfunction encodingForFormat(format: CompressionFormat): string {\n  switch (format) {\n    case 'gzip':\n    case 'deflate':\n    case 'deflate-raw':\n      return format;\n    default:\n      assert(`Unsupported compression format: ${format as unknown as string}`);\n      // @ts-expect-error - unreachable code is reachable in production\n      return format;\n  }\n}\n","import type { Future, Handler, NextFn } from '@warp-drive/core/request';\nimport type { RequestContext, StructuredDataDocument } from '@warp-drive/core/types/request';\n\n/**\n * If CheckFn returns true, the wrapped handler will be used.\n * If CheckFn returns false, the wrapped handler will be skipped.\n */\ntype CheckFn = (context: RequestContext) => boolean;\n\n/**\n *\n * @summary Request handler that wraps another handler and runs it only when a check function returns true for the\n * request.\n * @group Handlers\n * @public\n */\nexport class Gate implements Handler {\n  /**\n   * The wrapped handler to invoke when {@link Gate.checkFn | checkFn} returns `true`.\n   */\n  declare handler: Handler;\n  /**\n   * The predicate used to decide whether {@link Gate.handler | handler} should run for a given request.\n   */\n  declare checkFn: CheckFn;\n\n  constructor(handler: Handler, checkFn: CheckFn) {\n    this.handler = handler;\n    this.checkFn = checkFn;\n  }\n\n  request<T = unknown>(context: RequestContext, next: NextFn<T>): Promise<T | StructuredDataDocument<T>> | Future<T> {\n    if (this.checkFn(context)) {\n      return this.handler.request(context, next);\n    }\n    return next(context.request);\n  }\n}\n","import type { StoreRequestContext } from '@warp-drive/core';\nimport type { Handler, NextFn } from '@warp-drive/core/request';\nimport type { StructuredDataDocument } from '@warp-drive/core/types/request';\n\n/**\n * MetaDocHandler processes requests that are marked as meta requests.\n *\n * It treats the response body as \"entirely meta\" transforming\n *\n * ```ts\n * {\n *   some: \"key\",\n *   another: \"thing\"\n * }\n * ```\n *\n * into\n *\n * ```ts\n * {\n * \t meta: {\n *     some: \"key\",\n *     another: \"thing\"\n *   }\n * }\n * ```\n *\n * To activate this handler, a request should specify\n *\n * ```ts\n * options.isMetaRequest = true\n * ```\n *\n * For instance\n *\n * ```ts\n * store.request({\n *   url: '/example',\n *   options: {\n *     isMetaRequest: true\n *   }\n * });\n * ```\n *\n * Errors are not processed by this handler, so if the request fails and the error response\n * is not in {json:api} format additional processing may be needed.\n *\n * @summary Request handler that wraps the whole response body in `meta` for requests with `options.isMetaRequest` set.\n * @group Handlers\n */\nexport const MetaDocHandler: Handler = {\n  request<T>(context: StoreRequestContext, next: NextFn<T>): Promise<T | StructuredDataDocument<T> | Awaited<T>> {\n    if (!context.request.options?.isMetaRequest) {\n      return next(context.request);\n    }\n\n    return next(context.request).then((response) => {\n      return processResponse<T>(response);\n    });\n  },\n};\n\nfunction processResponse<T>(response: StructuredDataDocument<T>): T {\n  return {\n    meta: response.content,\n  } as T;\n}\n","import { assert } from '@warp-drive/core/build-config/macros';\n\nif (typeof FastBoot === 'undefined') {\n  globalThis.addEventListener('beforeunload', function () {\n    sessionStorage.setItem('tab-closed', 'true');\n  });\n}\n\nfunction getTabId() {\n  if (typeof sessionStorage === 'undefined') {\n    return crypto.randomUUID();\n  }\n\n  const tabId = sessionStorage.getItem('tab-id');\n  if (tabId) {\n    const tabClosed = sessionStorage.getItem('tab-closed');\n    if (tabClosed === 'true') {\n      return tabId;\n    }\n\n    // fall through to generate a new tab id\n  }\n\n  const newTabId = crypto.randomUUID();\n  sessionStorage.setItem('tab-id', newTabId);\n  return newTabId;\n}\n\n/**\n * A unique identifier for the current browser tab\n * useful for observability/tracing and deduping\n * across multiple tabs.\n *\n * @summary Random UUID identifying the current browser tab, kept in `sessionStorage` across reloads, for request\n * tracing.\n * @group Constants\n */\nexport const TAB_ID: string = getTabId();\n/**\n * The epoch seconds at which the tab id was generated\n *\n * @summary Epoch seconds recorded when this module loaded, paired with `TAB_ID` in trace headers.\n * @group Constants\n */\nexport const TAB_ASSIGNED: number = Math.floor(Date.now() / 1000);\n\n/**\n * Adds the `X-Amzn-Trace-Id` header to support observability\n * tooling around request routing.\n *\n * This makes use of the {@link TAB_ID} and {@link TAB_ASSIGNED}\n * to enable tracking the browser tab of origin across multiple requests.\n *\n * Follows the template: `Root=1-${now}-${uuidv4};TabId=1-${epochSeconds}-${tab-uuid}`\n *\n * @summary Sets an `X-Amzn-Trace-Id` header carrying a per-request id and the tab id, so requests can be traced to\n * their browser tab.\n * @group Utility Functions\n */\nexport function addTraceHeader(headers: Headers): Headers {\n  const now = Math.floor(Date.now() / 1000);\n  headers.set('X-Amzn-Trace-Id', `Root=1-${now}-${crypto.randomUUID()};TabId=1-${TAB_ASSIGNED}-${TAB_ID}`);\n\n  return headers;\n}\n\n/**\n * Source: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html\n * As of 2024-12-05 the maximum URL length is 8192 bytes.\n *\n * @summary The 8192-byte URL length limit, taken from AWS CloudFront, that `assertInvalidUrlLength` checks against.\n * @group Constants\n */\nexport const MAX_URL_LENGTH = 8192;\n\n/**\n * This assertion takes a URL and throws an error if the URL is longer than the maximum URL length.\n *\n * See also {@link MAX_URL_LENGTH}\n *\n * @summary Dev-mode assertion that throws when a URL is longer than `MAX_URL_LENGTH`, suggesting a `POST` or `QUERY`\n * request instead.\n * @group Utility Functions\n */\nexport function assertInvalidUrlLength(url: string | undefined): void {\n  assert(\n    `URL length ${url?.length} exceeds the maximum URL length of ${MAX_URL_LENGTH} bytes.\\n\\nConsider converting this request query a \\`/query\\` endpoint instead of a GET, or upgrade the current endpoint to be able to receive a POST request directly (ideally specifying the header HTTP-Method-Override: QUERY)\\n\\nThe Invalid URL is:\\n\\n${url}`,\n    !url || url.length <= MAX_URL_LENGTH\n  );\n}\n"],"mappings":"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"}