@ember-data/legacy-compat 5.4.0-alpha.52 → 5.4.0-alpha.54

package/unstable-preview-types/index.d.ts

@@ -1,4 +1,11 @@
+/// <reference path="./builders.d.ts" />
 /// <reference path="./-private.d.ts" />
+/// <reference path="./utils.d.ts" />
+/// <reference path="./builders/find-record.d.ts" />
+/// <reference path="./builders/find-all.d.ts" />
+/// <reference path="./builders/query.d.ts" />
+/// <reference path="./builders/save-record.d.ts" />
+/// <reference path="./builders/utils.d.ts" />
 /// <reference path="./legacy-network-handler/fetch-manager.d.ts" />
 /// <reference path="./legacy-network-handler/identifier-has-id.d.ts" />
 /// <reference path="./legacy-network-handler/minimum-adapter-interface.d.ts" />

package/unstable-preview-types/utils.d.ts

@@ -0,0 +1,159 @@
+declare module '@ember-data/legacy-compat/utils' {
+  type Reporter = (type: 'formatted-id' | 'formatted-type', actual: unknown, expected: unknown) => void;
+  /**
+   * Configure a function to be called when an id or type
+   * changes during normalization. This is useful for instrumenting
+   * to discover places where usage in the app is not consistent.
+   *
+   * @method configureMismatchReporter
+   * @for @ember-data/legacy-compat/utils
+   * @param method a function which takes a mismatch-type ('formatted-id' | 'formatted-type'), actual, and expected value
+   * @public
+   * @static
+   */
+  export function configureMismatchReporter(fn: Reporter): void;
+  /**
+   * Configure a function to be called when an id or type
+   * fails validation. This is useful for instrumenting
+   * to discover places where usage in the app is not consistent.
+   *
+   * @method configureAssertFn
+   * @for @ember-data/legacy-compat/utils
+   * @param method a function which takes a message and a condition
+   * @public
+   * @static
+   */
+  export function configureAssertFn(fn: (message: string, condition: unknown) => void): void;
+  /**
+   * Configure a function to be called to normalize
+   * a resource type string. Used by both formattedType
+   * and isEquivType to ensure consistent normalization
+   * during comparison.
+   *
+   * If validation fails or the type turns out be unnormalized
+   * the configured mismatch reporter and assert functions will
+   * be called.
+   *
+   * @method configureTypeNormalization
+   * @for @ember-data/legacy-compat/utils
+   * @param method a function which takes a string and returns a string
+   * @public
+   * @static
+   */
+  export function configureTypeNormalization(fn: (type: string) => string): void;
+  /**
+   * Converts a potentially unnormalized type into the format expected
+   * by our EmberData Cache. Currently this is singular-dasherized.
+   *
+   * you should not rely on this function to give you an exact format
+   * for display purposes. Formatting for display should be handled
+   * differently if the exact format matters.
+   *
+   * Asserts invalid types (undefined, null, '') in dev.
+   *
+   * **Usage**
+   *
+   * ```js
+   * import formattedType from 'soxhub-client/helpers/formatted-type';
+   *
+   * formattedType('post'); // => 'post'
+   * formattedType('posts'); // => 'post'
+   * formattedType('Posts'); // => 'post'
+   * formattedType('post-comment'); // => 'post-comment'
+   * formattedType('post-comments'); // => 'post-comment'
+   * formattedType('post_comment'); // => 'post-comment'
+   * formattedType('postComment'); // => 'post-comment'
+   * formattedType('PostComment'); // => 'post-comment'
+   * ```
+   *
+   * @method formattedType
+   * @for @ember-data/legacy-compat/utils
+   * @param {string} type the potentially un-normalized type
+   * @return {string} the normalized type
+   * @public
+   * @static
+   */
+  export function formattedType<T extends string>(type: T | string): T;
+  /**
+   * Format an id to the format expected by the EmberData Cache.
+   * Currently this means that id should be `string | null`.
+   *
+   * Asserts invalid IDs (undefined, '', 0, '0') in dev.
+   *
+   * **Usage**
+   *
+   * ```js
+   * import formattedId from 'client/utils/formatted-id';
+   *
+   * formattedId('1'); // => '1'
+   * formattedId(1); // => '1'
+   * formattedId(null); // => null
+   *	```
+   *
+   * @method formattedId
+   * @for @ember-data/legacy-compat/utils
+   * @param {string | number | null} id the potentially un-normalized id
+   * @return {string | null} the normalized id
+   * @public
+   * @static
+   */
+  export function formattedId(id: string | number): string;
+  export function formattedId(id: null): null;
+  export function formattedId(id: string | number | null): string | null;
+  /**
+   * Compares two types for strict equality, converting them to
+   * the format expected by the EmberData Cache to ensure
+   * differences in format are accounted for in the comparison.
+   *
+   * Asserts when expected or actual are invalid types in dev.
+   * Expected may never be null.
+   *
+   * ```js
+   * isEquivType('posts', 'post'); // true
+   * isEquivType('post', 'post'); // true
+   * isEquivType('posts', 'posts'); // true
+   * isEquivType('post-comment', 'postComment'); // true
+   * isEquivType('post-comment', 'PostComment'); // true
+   * isEquivType('post-comment', 'post_comment'); // true
+   * isEquivType('post-comment', 'post-comment'); // true
+   * isEquivType('post-comment', 'post'); // false
+   * isEquivType('posts', null); // false
+   * ```
+   *
+   * @method isEquivType
+   * @for @ember-data/legacy-compat/utils
+   * @param {string} expected a potentially unnormalized type to match against
+   * @param {string} actual a potentially unnormalized type to match against
+   * @return {boolean} true if the types are equivalent
+   * @public
+   * @static
+   */
+  export function isEquivType(expected: string, actual: string): boolean;
+  /**
+   * Compares two IDs for strict equality, converting them to
+   * the format expected by the EmberData Cache to ensure
+   * differences in format are accounted for in the comparison.
+   *
+   * Asserts when expected or actual are invalid IDs in dev.
+   * Expected may never be null.
+   *
+   * ```js
+   * isEquivId('1', 1); // true
+   * isEquivId('2', '2'); // true
+   * isEquivId(3, '3'); // true
+   * isEquivId(4, '3'); // false
+   * isEquivId(1, null); // false
+   * ```
+   *
+   * @method isEquivId
+   * @for @ember-data/legacy-compat/utils
+   * @param {string | number} expected a potentially un-normalized id to match against
+   * @param {string | number} actual a potentially un-normalized id to match against
+   * @return {boolean} true if the ids are equivalent
+   * @public
+   * @static
+   */
+  export function isEquivId(expected: string | number, actual: string | number | null): boolean;
+  export {};
+}
+//# sourceMappingURL=utils.d.ts.map

package/unstable-preview-types/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAmBA,KAAK,QAAQ,GAAG,CAAC,IAAI,EAAE,cAAc,GAAG,gBAAgB,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,KAAK,IAAI,CAAC;AA0BtG;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CAAC,EAAE,EAAE,QAAQ,GAAG,IAAI,CAE5D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,KAAK,IAAI,GAAG,IAAI,CAEzF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,0BAA0B,CAAC,EAAE,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAE7E;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,MAAM,GAAG,CAAC,CAiBnE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;AACzD,wBAAgB,WAAW,CAAC,EAAE,EAAE,IAAI,GAAG,IAAI,CAAC;AAC5C,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAAC;AAoBvE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAYrE;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,OAAO,CAyB5F"}