@warp-drive/utilities 5.9.0-alpha.2 → 5.9.0-alpha.21

package/declarations/rest.d.ts

@@ -1,3 +1,258 @@
-export { findRecord } from "./-private/rest/find-record.js";
-export { query } from "./-private/rest/query.js";
-export { deleteRecord, createRecord, updateRecord } from "./-private/rest/save-record.js";
+import { ReactiveDataDocument } from "@warp-drive/core/reactive";
+import { TypeFromInstance, TypedRecordInstance } from "@warp-drive/core/types/record";
+import { ConstrainedRequestOptions, CreateRequestOptions, DeleteRequestOptions, FindRecordOptions, FindRecordRequestOptions, QueryRequestOptions, RemotelyAccessibleIdentifier, UpdateRequestOptions } from "@warp-drive/core/types/request";
+import { QueryParamsSource } from "@warp-drive/core/types/params";
+//#region src/-private/rest/find-record.d.ts
+/**
+ * Builds request options to fetch a single resource by a known id or identifier
+ * configured for the url and header expectations of most REST APIs.
+ *
+ * **Basic Usage**
+ *
+ * ```ts
+ * import { findRecord } from '@warp-drive/utilities/rest';
+ *
+ * const data = await store.request(findRecord('person', '1'));
+ * ```
+ *
+ * **With Options**
+ *
+ * ```ts
+ * import { findRecord } from '@warp-drive/utilities/rest';
+ *
+ * const options = findRecord('person', '1', { include: ['pets', 'friends'] });
+ * const data = await store.request(options);
+ * ```
+ *
+ * **With an Identifier**
+ *
+ * ```ts
+ * import { findRecord } from '@warp-drive/utilities/rest';
+ *
+ * const options = findRecord({ type: 'person', id: '1' }, { include: ['pets', 'friends'] });
+ * const data = await store.request(options);
+ * ```
+ *
+ * **Supplying Options to Modify the Request Behavior**
+ *
+ * The following options are supported:
+ *
+ * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.
+ * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.
+ * - `resourcePath` - The resource path to use for the request, defaults to pluralizing and camelCasing the supplied type
+ * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this
+ *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.
+ * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the
+ *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,
+ *      defaulting to `false` if none is configured.
+ * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)
+ *
+ * ```ts
+ * import { findRecord } from '@warp-drive/utilities/rest';
+ *
+ * const options = findRecord('person', '1', { include: ['pets', 'friends'] }, { namespace: 'api/v2' });
+ * const data = await store.request(options);
+ * ```
+ *
+ * @public
+ */
+declare function findRecord<T>(identifier: RemotelyAccessibleIdentifier<TypeFromInstance<T>>, options?: FindRecordOptions): FindRecordRequestOptions<ReactiveDataDocument<T>, T>;
+declare function findRecord(identifier: RemotelyAccessibleIdentifier, options?: FindRecordOptions): FindRecordRequestOptions;
+declare function findRecord<T>(type: TypeFromInstance<T>, id: string, options?: FindRecordOptions): FindRecordRequestOptions<ReactiveDataDocument<T>, T>;
+declare function findRecord(type: string, id: string, options?: FindRecordOptions): FindRecordRequestOptions;
+//#endregion
+//#region src/-private/rest/query.d.ts
+/**
+ * Builds request options to query for resources, usually by a primary
+ * type, configured for the url and header expectations of most REST APIs.
+ *
+ * **Basic Usage**
+ *
+ * ```ts
+ * import { query } from '@warp-drive/utilities/rest';
+ *
+ * const data = await store.request(query('person'));
+ * ```
+ *
+ * **With Query Params**
+ *
+ * ```ts
+ * import { query } from '@warp-drive/utilities/rest';
+ *
+ * const options = query('person', { include: ['pets', 'friends'] });
+ * const data = await store.request(options);
+ * ```
+ *
+ * **Supplying Options to Modify the Request Behavior**
+ *
+ * The following options are supported:
+ *
+ * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.
+ * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.
+ * - `resourcePath` - The resource path to use for the request, defaults to pluralizing and camelCasing the supplied type
+ * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this
+ *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.
+ * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the
+ *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,
+ *      defaulting to `false` if none is configured.
+ * - `urlParamsSettings` - an object containing options for how to serialize the query params (see `buildQueryParams`)
+ *
+ * ```ts
+ * import { query } from '@warp-drive/utilities/rest';
+ *
+ * const options = query('person', { include: ['pets', 'friends'] }, { reload: true });
+ * const data = await store.request(options);
+ * ```
+ *
+ * @public
+ * @param identifier
+ * @param query
+ * @param options
+ */
+declare function query<T>(type: TypeFromInstance<T>, query?: QueryParamsSource, options?: ConstrainedRequestOptions): QueryRequestOptions<ReactiveDataDocument<T[]>>;
+declare function query(type: string, query?: QueryParamsSource, options?: ConstrainedRequestOptions): QueryRequestOptions;
+//#endregion
+//#region src/-private/rest/save-record.d.ts
+/**
+ * Builds request options to delete record for resources,
+ * configured for the url, method and header expectations of REST APIs.
+ *
+ * **Basic Usage**
+ *
+ * ```ts
+ * import { deleteRecord } from '@warp-drive/utilities/rest';
+ *
+ * const person = store.peekRecord('person', '1');
+ *
+ * // mark record as deleted
+ * store.deleteRecord(person);
+ *
+ * // persist deletion
+ * const data = await store.request(deleteRecord(person));
+ * ```
+ *
+ * **Supplying Options to Modify the Request Behavior**
+ *
+ * The following options are supported:
+ *
+ * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.
+ * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.
+ * - `resourcePath` - The resource path to use for the request, defaults to pluralizing the supplied type
+ * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this
+ *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.
+ * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the
+ *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,
+ *      defaulting to `false` if none is configured.
+ * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)
+ *
+ * ```ts
+ * import { deleteRecord } from '@warp-drive/utilities/rest';
+ *
+ * const person = store.peekRecord('person', '1');
+ *
+ * // mark record as deleted
+ * store.deleteRecord(person);
+ *
+ * // persist deletion
+ * const options = deleteRecord(person, { namespace: 'api/v1' });
+ * const data = await store.request(options);
+ * ```
+ *
+ * @public
+ * @param record
+ * @param options
+ */
+declare function deleteRecord<T>(record: T, options?: ConstrainedRequestOptions): DeleteRequestOptions<T>;
+declare function deleteRecord(record: unknown, options?: ConstrainedRequestOptions): DeleteRequestOptions;
+/**
+ * Builds request options to create new record for resources,
+ * configured for the url, method and header expectations of most REST APIs.
+ *
+ * **Basic Usage**
+ *
+ * ```ts
+ * import { createRecord } from '@warp-drive/utilities/rest';
+ *
+ * const person = store.createRecord('person', { name: 'Ted' });
+ * const data = await store.request(createRecord(person));
+ * ```
+ *
+ * **Supplying Options to Modify the Request Behavior**
+ *
+ * The following options are supported:
+ *
+ * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.
+ * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.
+ * - `resourcePath` - The resource path to use for the request, defaults to pluralizing the supplied type
+ * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this
+ *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.
+ * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the
+ *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,
+ *      defaulting to `false` if none is configured.
+ * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)
+ *
+ * ```ts
+ * import { createRecord } from '@warp-drive/utilities/rest';
+ *
+ * const person = store.createRecord('person', { name: 'Ted' });
+ * const options = createRecord(person, { namespace: 'api/v1' });
+ * const data = await store.request(options);
+ * ```
+ *
+ * @public
+ * @param record
+ * @param options
+ */
+declare function createRecord<T>(record: T, options?: ConstrainedRequestOptions): CreateRequestOptions<T>;
+declare function createRecord(record: unknown, options?: ConstrainedRequestOptions): CreateRequestOptions;
+/**
+ * Builds request options to update existing record for resources,
+ * configured for the url, method and header expectations of most REST APIs.
+ *
+ * **Basic Usage**
+ *
+ * ```ts
+ * import { updateRecord } from '@warp-drive/utilities/rest';
+ *
+ * const person = store.peekRecord('person', '1');
+ * person.name = 'Chris';
+ * const data = await store.request(updateRecord(person));
+ * ```
+ *
+ * **Supplying Options to Modify the Request Behavior**
+ *
+ * The following options are supported:
+ *
+ * - `patch` - Allows caller to specify whether to use a PATCH request instead of a PUT request, defaults to `false`.
+ * - `host` - The host to use for the request, defaults to the `host` configured with `setBuildURLConfig`.
+ * - `namespace` - The namespace to use for the request, defaults to the `namespace` configured with `setBuildURLConfig`.
+ * - `resourcePath` - The resource path to use for the request, defaults to pluralizing the supplied type
+ * - `reload` - Whether to forcibly reload the request if it is already in the store, not supplying this
+ *      option will delegate to the store's CachePolicy, defaulting to `false` if none is configured.
+ * - `backgroundReload` - Whether to reload the request if it is already in the store, but to also resolve the
+ *      promise with the cached value, not supplying this option will delegate to the store's CachePolicy,
+ *      defaulting to `false` if none is configured.
+ * - `urlParamsSetting` - an object containing options for how to serialize the query params (see `buildQueryParams`)
+ *
+ * ```ts
+ * import { updateRecord } from '@warp-drive/utilities/rest';
+ *
+ * const person = store.peekRecord('person', '1');
+ * person.name = 'Chris';
+ * const options = updateRecord(person, { patch: true });
+ * const data = await store.request(options);
+ * ```
+ *
+ * @public
+ * @param record
+ * @param options
+ */
+declare function updateRecord<T extends TypedRecordInstance, RT extends TypedRecordInstance = T>(record: T, options?: ConstrainedRequestOptions & {
+  patch?: boolean;
+}): UpdateRequestOptions<ReactiveDataDocument<RT>, T>;
+declare function updateRecord(record: unknown, options?: ConstrainedRequestOptions & {
+  patch?: boolean;
+}): UpdateRequestOptions;
+//#endregion
+export { createRecord, deleteRecord, findRecord, query, updateRecord };
+//# sourceMappingURL=rest.d.ts.map

package/declarations/rest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rest.d.ts","names":[],"sources":["../src/-private/rest/find-record.ts","../src/-private/rest/query.ts","../src/-private/rest/save-record.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiEgB,WAAW,GACzB,YAAY,6BAA6B,iBAAiB,KAC1D,UAAU,oBACT,yBAAyB,qBAAqB,IAAI;iBACrC,WACd,YAAY,8BACZ,UAAU,oBACT;iBACa,WAAW,GACzB,MAAM,iBAAiB,IACvB,YACA,UAAU,oBACT,yBAAyB,qBAAqB,IAAI;iBACrC,WAAW,cAAc,YAAY,UAAU,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBCtBnE,MAAM,GACpB,MAAM,iBAAiB,IACvB,QAAQ,mBACR,UAAU,4BACT,oBAAoB,qBAAqB;iBAC5B,MACd,cACA,QAAQ,mBACR,UAAU,4BACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBCSa,aAAa,GAAG,QAAQ,GAAG,UAAU,4BAA4B,qBAAqB;iBACtF,aAAa,iBAAiB,UAAU,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqEpE,aAAa,GAAG,QAAQ,GAAG,UAAU,4BAA4B,qBAAqB;iBACtF,aAAa,iBAAiB,UAAU,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuEpE,aAAa,UAAU,qBAAqB,WAAW,sBAAsB,GAC3F,QAAQ,GACR,UAAU;EAA8B;IACvC,qBAAqB,qBAAqB,KAAK;iBAClC,aACd,iBACA,UAAU;EAA8B;IACvC"}

package/declarations/string.d.ts

@@ -1,14 +1,165 @@
+//#region src/-private/string/inflect.d.ts
 /**
-* String utilities for transforming and inflecting strings useful for
-* when the format provided by the server is not the format you want to use
-* in your application.
-*
-* Each transformation function stores its results in an LRUCache to avoid
-* recomputing the same value multiple times. The cache size can be set
-* using the `setMaxLRUCacheSize` function. The default size is 10,000.
-*
-* @module
-* @public
-*/
-export { pluralize, singularize, singular, plural, loadIrregular, loadUncountable, irregular, uncountable, resetToDefaults, clear, clearRules } from "./-private/string/inflect.js";
-export { dasherize, camelize, capitalize, underscore, setMaxLRUCacheSize } from "./-private/string/transform.js";
+ * Marks a word as uncountable. Uncountable words are not pluralized
+ * or singularized.
+ *
+ * @public
+ * @since 4.13.0
+ */
+declare function uncountable(word: string): void;
+/**
+ * Marks a list of words as uncountable. Uncountable words are not pluralized
+ * or singularized.
+ *
+ * @public
+ * @since 4.13.0
+ */
+declare function loadUncountable(uncountables: string[]): void;
+/**
+ * Marks a word as irregular. Irregular words have unique
+ * pluralization and singularization rules.
+ *
+ * @public
+ * @since 4.13.0
+ */
+declare function irregular(single: string, plur: string): void;
+/**
+ * Marks a list of word pairs as irregular. Irregular words have unique
+ * pluralization and singularization rules.
+ *
+ * @public
+ * @since 4.13.0
+ */
+declare function loadIrregular(irregularPairs: Array<[string, string]>): void;
+/**
+ * Clears the caches for singularize and pluralize.
+ *
+ * @public
+ * @since 4.13.0
+ */
+declare function clear(): void;
+/**
+ * Resets the inflection rules to the defaults.
+ *
+ * @public
+ * @since 4.13.0
+ */
+declare function resetToDefaults(): void;
+/**
+ * Clears all inflection rules
+ * and resets the caches for singularize and pluralize.
+ *
+ * @public
+ * @since 4.13.0
+ */
+declare function clearRules(): void;
+/**
+ * Singularizes a word.
+ *
+ * @public
+ * @since 4.13.0
+ */
+declare function singularize(word: string): string;
+/**
+ * Pluralizes a word.
+ *
+ * @public
+ * @since 4.13.0
+ */
+declare function pluralize(word: string): string;
+/**
+ * Adds a pluralization rule.
+ *
+ * @public
+ * @since 4.13.0
+ */
+declare function plural(regex: RegExp, string: string): void;
+/**
+ * Adds a singularization rule.
+ *
+ * @public
+ * @since 4.13.0
+ */
+declare function singular(regex: RegExp, string: string): void;
+//#endregion
+//#region src/-private/string/transform.d.ts
+/**
+ * Replaces underscores, spaces, or camelCase with dashes.
+ *
+ * ```js
+ * import { dasherize } from '@warp-drive/utilities/string';
+ *
+ * dasherize('innerHTML');                // 'inner-html'
+ * dasherize('action_name');              // 'action-name'
+ * dasherize('css-class-name');           // 'css-class-name'
+ * dasherize('my favorite items');        // 'my-favorite-items'
+ * dasherize('privateDocs/ownerInvoice';  // 'private-docs/owner-invoice'
+ * ```
+ *
+ * @public
+ * @since 4.13.0
+ */
+declare const dasherize: (str: string) => string;
+/**
+ * Returns the lowerCamelCase form of a string.
+ *
+ * ```js
+ * import { camelize } from '@warp-drive/utilities/string';
+ *
+ * camelize('innerHTML');                   // 'innerHTML'
+ * camelize('action_name');                 // 'actionName'
+ * camelize('css-class-name');              // 'cssClassName'
+ * camelize('my favorite items');           // 'myFavoriteItems'
+ * camelize('My Favorite Items');           // 'myFavoriteItems'
+ * camelize('private-docs/owner-invoice');  // 'privateDocs/ownerInvoice'
+ * ```
+ *
+ * @public
+ * @since 4.13.0
+ */
+declare function camelize(str: string): string;
+/**
+ * Returns the lower\_case\_and\_underscored form of a string.
+ *
+ * ```js
+ * import { underscore } from '@warp-drive/utilities/string';
+ *
+ * underscore('innerHTML');                 // 'inner_html'
+ * underscore('action_name');               // 'action_name'
+ * underscore('css-class-name');            // 'css_class_name'
+ * underscore('my favorite items');         // 'my_favorite_items'
+ * underscore('privateDocs/ownerInvoice');  // 'private_docs/owner_invoice'
+ * ```
+ *
+ * @public
+ * @since 4.13.0
+ */
+declare function underscore(str: string): string;
+/**
+ * Returns the Capitalized form of a string
+ *
+ * ```js
+ * import { capitalize } from '@warp-drive/utilities/string';
+ *
+ * capitalize('innerHTML')                 // 'InnerHTML'
+ * capitalize('action_name')               // 'Action_name'
+ * capitalize('css-class-name')            // 'Css-class-name'
+ * capitalize('my favorite items')         // 'My favorite items'
+ * capitalize('privateDocs/ownerInvoice'); // 'PrivateDocs/ownerInvoice'
+ * ```
+ *
+ * @public
+ * @since 4.13.0
+ */
+declare function capitalize(str: string): string;
+/**
+ * Sets the maximum size of the LRUCache for all string transformation functions.
+ * The default size is 10,000.
+ *
+ * @public
+ * @since 4.13.0
+ */
+declare function setMaxLRUCacheSize(size: number): void;
+//#endregion
+export { camelize, capitalize, clear, clearRules, dasherize, irregular, loadIrregular, loadUncountable, plural, pluralize, resetToDefaults, setMaxLRUCacheSize, singular, singularize, uncountable, underscore };
+//# sourceMappingURL=string.d.ts.map

package/declarations/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","names":[],"sources":["../src/-private/string/inflect.ts","../src/-private/string/transform.ts"],"mappings":";;;;;;;;iBA8BgB,YAAY;;;;;;;;iBAWZ,gBAAgB;;;;;;;;iBAahB,UAAU,gBAAgB;;;;;;;;iBAiB1B,cAAc,gBAAgB;;;;;;;iBAmB9B;;;;;;;iBAWA;;;;;;;;iBAeA;;;;;;;iBAgBA,YAAY;;;;;;;iBAYZ,UAAU;;;;;;;iBAqBV,OAAO,OAAO,QAAQ;;;;;;;iBAgBtB,SAAS,OAAO,QAAQ;;;;;;;;;;;;;;;;;;;cC9I3B,YAAY;;;;;;;;;;;;;;;;;;iBAmBT,SAAS;;;;;;;;;;;;;;;;;iBAoBT,WAAW;;;;;;;;;;;;;;;;;iBAoBX,WAAW;;;;;;;;iBAWX,mBAAmB"}

package/dist/-private.js

@@ -1,7 +1,3 @@
-const defaultRules = {
-  plurals: [[/$/, 's'], [/s$/i, 's'], [/^(ax|test)is$/i, '$1es'], [/(octop|vir)us$/i, '$1i'], [/(octop|vir)i$/i, '$1i'], [/(alias|status|bonus)$/i, '$1es'], [/(bu)s$/i, '$1ses'], [/(buffal|tomat)o$/i, '$1oes'], [/([ti])um$/i, '$1a'], [/([ti])a$/i, '$1a'], [/sis$/i, 'ses'], [/(?:([^f])fe|([lr])f)$/i, '$1$2ves'], [/(hive)$/i, '$1s'], [/([^aeiouy]|qu)y$/i, '$1ies'], [/(x|ch|ss|sh)$/i, '$1es'], [/(matr|vert|ind)(?:ix|ex)$/i, '$1ices'], [/^(m|l)ouse$/i, '$1ice'], [/^(m|l)ice$/i, '$1ice'], [/^(ox)$/i, '$1en'], [/^(oxen)$/i, '$1'], [/(quiz)$/i, '$1zes']],
-  singular: [[/s$/i, ''], [/(ss)$/i, '$1'], [/(n)ews$/i, '$1ews'], [/([ti])a$/i, '$1um'], [/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i, '$1sis'], [/(^analy)(sis|ses)$/i, '$1sis'], [/([^f])ves$/i, '$1fe'], [/(hive)s$/i, '$1'], [/(tive)s$/i, '$1'], [/([lr])ves$/i, '$1f'], [/([^aeiouy]|qu)ies$/i, '$1y'], [/(s)eries$/i, '$1eries'], [/(m)ovies$/i, '$1ovie'], [/(x|ch|ss|sh)es$/i, '$1'], [/^(m|l)ice$/i, '$1ouse'], [/(bus)(es)?$/i, '$1'], [/(o)es$/i, '$1'], [/(shoe)s$/i, '$1'], [/(cris|test)(is|es)$/i, '$1is'], [/^(a)x[ie]s$/i, '$1xis'], [/(octop|vir)(us|i)$/i, '$1us'], [/(alias|status|bonus)(es)?$/i, '$1'], [/^(ox)en/i, '$1'], [/(vert|ind)ices$/i, '$1ex'], [/(matr)ices$/i, '$1ix'], [/(quiz)zes$/i, '$1'], [/(database)s$/i, '$1']],
-  irregularPairs: [['person', 'people'], ['man', 'men'], ['child', 'children'], ['sex', 'sexes'], ['move', 'moves'], ['cow', 'kine'], ['zombie', 'zombies']],
-  uncountable: ['equipment', 'information', 'rice', 'money', 'species', 'series', 'fish', 'sheep', 'jeans', 'police']
-};
+import { t as defaultRules } from "./inflections-DzBsjJqj.js";
+
 export { defaultRules as InflectionRuleDefaults };