@warp-drive/legacy 5.9.0-alpha.21 → 5.9.0-alpha.22

package/dist/compat/utils.d.ts

@@ -0,0 +1,151 @@
+//#region src/compat/utils.d.ts
+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.
+ *
+ * @param fn - a function which takes a mismatch-type ('formatted-id' | 'formatted-type'), actual, and expected value
+ * @public
+ */
+declare 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.
+ *
+ * @param fn - a function which takes a message and a condition
+ * @public
+ */
+declare 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.
+ *
+ * @param fn - a function which takes a string and returns a string
+ * @public
+ */
+declare function configureTypeNormalization(fn: (type: string) => string): void;
+/**
+ * Converts a potentially unnormalized type into the format expected
+ * by our WarpDrive 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'
+ * ```
+ *
+ * @param type the potentially un-normalized type
+ * @return the normalized type
+ * @public
+ */
+declare function formattedType<T extends string>(type: T | string): T;
+/**
+ * Format an id to the format expected by the WarpDrive 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
+ *	```
+ *
+ * @param id the potentially un-normalized id
+ * @return the normalized id
+ * @public
+ */
+declare function formattedId(id: string | number): string;
+declare function formattedId(id: null): null;
+declare function formattedId(id: string | number | null): string | null;
+/**
+ * Like {@link formattedId}, but asserts that `id` is not `null` rather
+ * than allowing and passing through `null`.
+ *
+ * @public
+ */
+declare function expectId(id: string | number): string;
+/**
+ * Throws, since `id` is `null`.
+ *
+ * @public
+ */
+declare function expectId(id: null): never;
+/**
+ * Compares two types for strict equality, converting them to
+ * the format expected by the WarpDrive 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
+ * ```
+ *
+ * @param expected a potentially unnormalized type to match against
+ * @param actual a potentially unnormalized type to match against
+ * @return true if the types are equivalent
+ * @public
+ */
+declare function isEquivType(expected: string, actual: string): boolean;
+/**
+ * Compares two IDs for strict equality, converting them to
+ * the format expected by the WarpDrive 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
+ * ```
+ *
+ * @param expected a potentially un-normalized id to match against
+ * @param actual a potentially un-normalized id to match against
+ * @return true if the ids are equivalent
+ * @public
+ */
+declare function isEquivId(expected: string | number, actual: string | number | null): boolean;
+//#endregion
+export { configureAssertFn, configureMismatchReporter, configureTypeNormalization, expectId, formattedId, formattedType, isEquivId, isEquivType };
+//# sourceMappingURL=utils.d.ts.map

package/dist/compat/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","names":[],"sources":["../../src/compat/utils.ts"],"mappings":";KAcK,YAAY,yCAAyC,iBAAiB;;;;;;;;;iBA0B3D,0BAA0B,IAAI;;;;;;;;;iBAY9B,kBAAkB,KAAK,iBAAiB;;;;;;;;;;;;;;iBAiBxC,2BAA2B,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmChC,cAAc,kBAAkB,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;iBAuCnD,YAAY;iBACZ,YAAY;iBACZ,YAAY;;;;;;;iBA0BZ,SAAS;;;;;;iBAMT,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgCT,YAAY,kBAAkB;;;;;;;;;;;;;;;;;;;;;;iBAmC9B,UAAU,2BAA2B"}

package/dist/compat/utils.js

@@ -1,238 +1,219 @@
-import { singularize, dasherize } from '@warp-drive/utilities/string';
-import { macroCondition, getGlobalConfig } from '@embroider/macros';
+import { getGlobalConfig, macroCondition } from "@embroider/macros";
+import { dasherize, singularize } from "@warp-drive/utilities/string";
 
+//#region src/compat/utils.ts
 /**
-  Utilities for helping to migrate to stricter
-  and more consistent use of IDs and types.
+Utilities for helping to migrate to stricter
+and more consistent use of IDs and types.
 
-  @module
+@module
 */
-
-let MismatchReporter = function () {};
-
-// TODO: @runspired This pattern prevents AssertFn from being removed in production builds
-// but we should enable that if we can.
-let _AssertFn = function () {};
+let MismatchReporter = function() {};
+let _AssertFn = function() {};
 const AssertFn = (message, condition) => {
-  if (!condition) {
-    _AssertFn(message, condition);
-  }
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(message);
-    }
-  })(condition) : {};
+	if (!condition) _AssertFn(message, condition);
+	macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) && ((test) => {
+		if (!test) throw new Error(message);
+	})(condition);
 };
-let NormalizedType = str => {
-  return singularize(dasherize(str));
+let NormalizedType = (str) => {
+	return singularize(dasherize(str));
 };
-
 /**
- * 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.
- *
- * @param fn - a function which takes a mismatch-type ('formatted-id' | 'formatted-type'), actual, and expected value
- * @public
- */
+* 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.
+*
+* @param fn - a function which takes a mismatch-type ('formatted-id' | 'formatted-type'), actual, and expected value
+* @public
+*/
 function configureMismatchReporter(fn) {
-  MismatchReporter = fn;
+	MismatchReporter = fn;
 }
-
 /**
- * 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.
- *
- * @param fn - a function which takes a message and a condition
- * @public
- */
+* 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.
+*
+* @param fn - a function which takes a message and a condition
+* @public
+*/
 function configureAssertFn(fn) {
-  _AssertFn = fn;
+	_AssertFn = fn;
 }
-
 /**
- * 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.
- *
- * @param fn - a function which takes a string and returns a string
- * @public
- */
+* 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.
+*
+* @param fn - a function which takes a string and returns a string
+* @public
+*/
 function configureTypeNormalization(fn) {
-  NormalizedType = fn;
+	NormalizedType = fn;
 }
-const NORMALIZED_TYPES = new Map();
-
+const NORMALIZED_TYPES = /* @__PURE__ */ new Map();
 /**
- * Converts a potentially unnormalized type into the format expected
- * by our WarpDrive 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'
- * ```
- *
- * @param type the potentially un-normalized type
- * @return the normalized type
- * @public
- */
+* Converts a potentially unnormalized type into the format expected
+* by our WarpDrive 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'
+* ```
+*
+* @param type the potentially un-normalized type
+* @return the normalized type
+* @public
+*/
 function formattedType(type) {
-  AssertFn('formattedType: type must not be null', type !== null);
-  AssertFn('formattedType: type must not be undefined', type !== undefined);
-  AssertFn('formattedType: type must be a string', typeof type === 'string');
-  AssertFn('formattedType: type must not be empty', type.length > 0);
-  let normalized = NORMALIZED_TYPES.get(type);
-  if (normalized === undefined) {
-    normalized = NormalizedType(type);
-    NORMALIZED_TYPES.set(type, normalized);
-  }
-  if (normalized !== type) {
-    MismatchReporter('formatted-type', type, normalized);
-  }
-  return normalized;
+	AssertFn("formattedType: type must not be null", type !== null);
+	AssertFn("formattedType: type must not be undefined", type !== void 0);
+	AssertFn("formattedType: type must be a string", typeof type === "string");
+	AssertFn("formattedType: type must not be empty", type.length > 0);
+	let normalized = NORMALIZED_TYPES.get(type);
+	if (normalized === void 0) {
+		normalized = NormalizedType(type);
+		NORMALIZED_TYPES.set(type, normalized);
+	}
+	if (normalized !== type) MismatchReporter("formatted-type", type, normalized);
+	return normalized;
 }
-
 /**
- * Format an id to the format expected by the WarpDrive 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
- *	```
- *
- * @param id the potentially un-normalized id
- * @return the normalized id
- * @public
- */
-
+* Format an id to the format expected by the WarpDrive 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
+*	```
+*
+* @param id the potentially un-normalized id
+* @return the normalized id
+* @public
+*/
 function formattedId(id) {
-  AssertFn('formattedId: id must not be undefined', id !== undefined);
-  AssertFn('formattedId: id must be a number, string or null', typeof id === 'number' || typeof id === 'string' || id === null);
-  AssertFn('formattedId: id must not be empty', typeof id === 'number' || id === null || typeof id === 'string' && id.length > 0);
-  AssertFn('formattedId: id must not be 0', id !== '0' && id !== 0);
-  const formatted = id === null ? null : String(id);
-  if (formatted !== id) {
-    MismatchReporter('formatted-id', id, formatted);
-  }
-  return id === null ? null : String(id);
+	AssertFn("formattedId: id must not be undefined", id !== void 0);
+	AssertFn("formattedId: id must be a number, string or null", typeof id === "number" || typeof id === "string" || id === null);
+	AssertFn("formattedId: id must not be empty", typeof id === "number" || id === null || typeof id === "string" && id.length > 0);
+	AssertFn("formattedId: id must not be 0", id !== "0" && id !== 0);
+	const formatted = id === null ? null : String(id);
+	if (formatted !== id) MismatchReporter("formatted-id", id, formatted);
+	return id === null ? null : String(id);
 }
-
 /**
- * Like {@link formattedId}, but asserts that `id` is not `null` rather
- * than allowing and passing through `null`.
- *
- * @public
- */
-
+* Like {@link formattedId}, but asserts that `id` is not `null` rather
+* than allowing and passing through `null`.
+*
+* @public
+*/
 /**
- * Throws, since `id` is `null`.
- *
- * @public
- */
-
+* Throws, since `id` is `null`.
+*
+* @public
+*/
 function expectId(id) {
-  AssertFn('expectId: id must not be null', id !== null);
-  return formattedId(id);
+	AssertFn("expectId: id must not be null", id !== null);
+	return formattedId(id);
 }
-
 /**
- * Compares two types for strict equality, converting them to
- * the format expected by the WarpDrive 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
- * ```
- *
- * @param expected a potentially unnormalized type to match against
- * @param actual a potentially unnormalized type to match against
- * @return true if the types are equivalent
- * @public
- */
+* Compares two types for strict equality, converting them to
+* the format expected by the WarpDrive 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
+* ```
+*
+* @param expected a potentially unnormalized type to match against
+* @param actual a potentially unnormalized type to match against
+* @return true if the types are equivalent
+* @public
+*/
 function isEquivType(expected, actual) {
-  AssertFn('isEquivType: Expected type must not be null', expected !== null);
-  AssertFn('isEquivType: Expected type must not be undefined', expected !== undefined);
-  AssertFn('isEquivType: Expected type must be a string', typeof expected === 'string');
-  AssertFn('isEquivType: Expected type must not be empty', expected.length > 0);
-  AssertFn('isEquivType: Actual type must not be null', actual !== null);
-  AssertFn('isEquivType: Actual type must not be undefined', actual !== undefined);
-  AssertFn('isEquivType: Actual type must be a string', typeof actual === 'string');
-  AssertFn('isEquivType: Actual type must not be empty', actual.length > 0);
-  return expected === actual || formattedType(expected) === formattedType(actual);
+	AssertFn("isEquivType: Expected type must not be null", expected !== null);
+	AssertFn("isEquivType: Expected type must not be undefined", expected !== void 0);
+	AssertFn("isEquivType: Expected type must be a string", typeof expected === "string");
+	AssertFn("isEquivType: Expected type must not be empty", expected.length > 0);
+	AssertFn("isEquivType: Actual type must not be null", actual !== null);
+	AssertFn("isEquivType: Actual type must not be undefined", actual !== void 0);
+	AssertFn("isEquivType: Actual type must be a string", typeof actual === "string");
+	AssertFn("isEquivType: Actual type must not be empty", actual.length > 0);
+	return expected === actual || formattedType(expected) === formattedType(actual);
 }
-
 /**
- * Compares two IDs for strict equality, converting them to
- * the format expected by the WarpDrive 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
- * ```
- *
- * @param expected a potentially un-normalized id to match against
- * @param actual a potentially un-normalized id to match against
- * @return true if the ids are equivalent
- * @public
- */
+* Compares two IDs for strict equality, converting them to
+* the format expected by the WarpDrive 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
+* ```
+*
+* @param expected a potentially un-normalized id to match against
+* @param actual a potentially un-normalized id to match against
+* @return true if the ids are equivalent
+* @public
+*/
 function isEquivId(expected, actual) {
-  AssertFn('isEquivId: Expected id must not be null', expected !== null);
-  AssertFn('isEquivId: Expected id must not be undefined', expected !== undefined);
-  AssertFn('isEquivId: Expected id must be a number or string', typeof expected === 'number' || typeof expected === 'string');
-  AssertFn('isEquivId: Expected id must not be empty', typeof expected === 'number' || typeof expected === 'string' && expected.length > 0);
-  AssertFn('isEquivId: Expected id must not be 0', expected !== '0' && expected !== 0);
-  AssertFn('isEquivId: Actual id must not be undefined', actual !== undefined);
-  AssertFn('isEquivId: Actual id must be a number, string or null', typeof actual === 'number' || typeof actual === 'string' || actual === null);
-  AssertFn('isEquivId: Actual id must not be empty', actual === null || typeof actual === 'number' || typeof actual === 'string' && actual.length > 0);
-  AssertFn('isEquivId: Actual id must not be 0', actual !== '0' && actual !== 0);
-  return expected === actual || formattedId(expected) === formattedId(actual);
+	AssertFn("isEquivId: Expected id must not be null", expected !== null);
+	AssertFn("isEquivId: Expected id must not be undefined", expected !== void 0);
+	AssertFn("isEquivId: Expected id must be a number or string", typeof expected === "number" || typeof expected === "string");
+	AssertFn("isEquivId: Expected id must not be empty", typeof expected === "number" || typeof expected === "string" && expected.length > 0);
+	AssertFn("isEquivId: Expected id must not be 0", expected !== "0" && expected !== 0);
+	AssertFn("isEquivId: Actual id must not be undefined", actual !== void 0);
+	AssertFn("isEquivId: Actual id must be a number, string or null", typeof actual === "number" || typeof actual === "string" || actual === null);
+	AssertFn("isEquivId: Actual id must not be empty", actual === null || typeof actual === "number" || typeof actual === "string" && actual.length > 0);
+	AssertFn("isEquivId: Actual id must not be 0", actual !== "0" && actual !== 0);
+	return expected === actual || formattedId(expected) === formattedId(actual);
 }
-export { configureAssertFn, configureMismatchReporter, configureTypeNormalization, expectId, formattedId, formattedType, isEquivId, isEquivType };
+
+//#endregion
+export { configureAssertFn, configureMismatchReporter, configureTypeNormalization, expectId, formattedId, formattedType, isEquivId, isEquivType };
+//# sourceMappingURL=utils.js.map

package/dist/compat/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":["dasherize","singularize","macroCondition","getGlobalConfig","MismatchReporter","_AssertFn","AssertFn","message","condition","WarpDrive","env","DEBUG","test","Error","NormalizedType","str","configureMismatchReporter","fn","configureAssertFn","configureTypeNormalization","NORMALIZED_TYPES","Map","formattedType","type","undefined","length","normalized","get","set","formattedId","id","formatted","String","expectId","isEquivType","expected","actual","isEquivId"],"sources":["../../src/compat/utils.ts"],"sourcesContent":["/**\n  Utilities for helping to migrate to stricter\n  and more consistent use of IDs and types.\n\n  @module\n*/\nimport { assert } from '@warp-drive/core/build-config/macros';\nimport { dasherize, singularize } from '@warp-drive/utilities/string';\n\ninterface AssertFunc {\n  (desc: string, condition: unknown): asserts condition;\n  (desc: string): never;\n}\n\ntype Reporter = (type: 'formatted-id' | 'formatted-type', actual: unknown, expected: unknown) => void;\ntype Normalizer = (type: string) => string;\n\nlet MismatchReporter: Reporter = function () {};\n\n// TODO: @runspired This pattern prevents AssertFn from being removed in production builds\n// but we should enable that if we can.\nlet _AssertFn: (message: string, condition: unknown) => void = function () {};\nconst AssertFn: AssertFunc = ((message: string, condition: unknown) => {\n  if (!condition) {\n    _AssertFn(message, condition);\n  }\n  assert(message, condition);\n}) as unknown as AssertFunc;\nlet NormalizedType: Normalizer = (str: string) => {\n  return singularize(dasherize(str));\n};\n\n/**\n * Configure a function to be called when an id or type\n * changes during normalization. This is useful for instrumenting\n * to discover places where usage in the app is not consistent.\n *\n * @param fn - a function which takes a mismatch-type ('formatted-id' | 'formatted-type'), actual, and expected value\n * @public\n */\nexport function configureMismatchReporter(fn: Reporter): void {\n  MismatchReporter = fn;\n}\n\n/**\n * Configure a function to be called when an id or type\n * fails validation. This is useful for instrumenting\n * to discover places where usage in the app is not consistent.\n *\n * @param fn - a function which takes a message and a condition\n * @public\n */\nexport function configureAssertFn(fn: (message: string, condition: unknown) => void): void {\n  _AssertFn = fn;\n}\n\n/**\n * Configure a function to be called to normalize\n * a resource type string. Used by both formattedType\n * and isEquivType to ensure consistent normalization\n * during comparison.\n *\n * If validation fails or the type turns out be unnormalized\n * the configured mismatch reporter and assert functions will\n * be called.\n *\n * @param fn - a function which takes a string and returns a string\n * @public\n */\nexport function configureTypeNormalization(fn: (type: string) => string): void {\n  NormalizedType = fn;\n}\n\nconst NORMALIZED_TYPES = new Map<string, string>();\n\n/**\n * Converts a potentially unnormalized type into the format expected\n * by our WarpDrive Cache. Currently this is singular-dasherized.\n *\n * you should not rely on this function to give you an exact format\n * for display purposes. Formatting for display should be handled\n * differently if the exact format matters.\n *\n * Asserts invalid types (undefined, null, '') in dev.\n *\n * **Usage**\n *\n * ```js\n * import formattedType from 'soxhub-client/helpers/formatted-type';\n *\n * formattedType('post'); // => 'post'\n * formattedType('posts'); // => 'post'\n * formattedType('Posts'); // => 'post'\n * formattedType('post-comment'); // => 'post-comment'\n * formattedType('post-comments'); // => 'post-comment'\n * formattedType('post_comment'); // => 'post-comment'\n * formattedType('postComment'); // => 'post-comment'\n * formattedType('PostComment'); // => 'post-comment'\n * ```\n *\n * @param type the potentially un-normalized type\n * @return the normalized type\n * @public\n */\nexport function formattedType<T extends string>(type: T | string): T {\n  AssertFn('formattedType: type must not be null', type !== null);\n  AssertFn('formattedType: type must not be undefined', type !== undefined);\n  AssertFn('formattedType: type must be a string', typeof type === 'string');\n  AssertFn('formattedType: type must not be empty', type.length > 0);\n  let normalized = NORMALIZED_TYPES.get(type);\n\n  if (normalized === undefined) {\n    normalized = NormalizedType(type);\n    NORMALIZED_TYPES.set(type, normalized);\n  }\n\n  if (normalized !== type) {\n    MismatchReporter('formatted-type', type, normalized);\n  }\n\n  return normalized as T;\n}\n\n/**\n * Format an id to the format expected by the WarpDrive Cache.\n * Currently this means that id should be `string | null`.\n *\n * Asserts invalid IDs (undefined, '', 0, '0') in dev.\n *\n * **Usage**\n *\n * ```js\n * import formattedId from 'client/utils/formatted-id';\n *\n * formattedId('1'); // => '1'\n * formattedId(1); // => '1'\n * formattedId(null); // => null\n *\t```\n *\n * @param id the potentially un-normalized id\n * @return the normalized id\n * @public\n */\nexport function formattedId(id: string | number): string;\nexport function formattedId(id: null): null;\nexport function formattedId(id: string | number | null): string | null;\nexport function formattedId(id: string | number | null): string | null {\n  AssertFn('formattedId: id must not be undefined', id !== undefined);\n  AssertFn(\n    'formattedId: id must be a number, string or null',\n    typeof id === 'number' || typeof id === 'string' || id === null\n  );\n  AssertFn(\n    'formattedId: id must not be empty',\n    typeof id === 'number' || id === null || (typeof id === 'string' && id.length > 0)\n  );\n  AssertFn('formattedId: id must not be 0', id !== '0' && id !== 0);\n\n  const formatted = id === null ? null : String(id);\n  if (formatted !== id) {\n    MismatchReporter('formatted-id', id, formatted);\n  }\n  return id === null ? null : String(id);\n}\n\n/**\n * Like {@link formattedId}, but asserts that `id` is not `null` rather\n * than allowing and passing through `null`.\n *\n * @public\n */\nexport function expectId(id: string | number): string;\n/**\n * Throws, since `id` is `null`.\n *\n * @public\n */\nexport function expectId(id: null): never;\nexport function expectId(id: string | number | null): string {\n  AssertFn('expectId: id must not be null', id !== null);\n\n  return formattedId(id);\n}\n\n/**\n * Compares two types for strict equality, converting them to\n * the format expected by the WarpDrive Cache to ensure\n * differences in format are accounted for in the comparison.\n *\n * Asserts when expected or actual are invalid types in dev.\n * Expected may never be null.\n *\n * ```js\n * isEquivType('posts', 'post'); // true\n * isEquivType('post', 'post'); // true\n * isEquivType('posts', 'posts'); // true\n * isEquivType('post-comment', 'postComment'); // true\n * isEquivType('post-comment', 'PostComment'); // true\n * isEquivType('post-comment', 'post_comment'); // true\n * isEquivType('post-comment', 'post-comment'); // true\n * isEquivType('post-comment', 'post'); // false\n * isEquivType('posts', null); // false\n * ```\n *\n * @param expected a potentially unnormalized type to match against\n * @param actual a potentially unnormalized type to match against\n * @return true if the types are equivalent\n * @public\n */\nexport function isEquivType(expected: string, actual: string): boolean {\n  AssertFn('isEquivType: Expected type must not be null', expected !== null);\n  AssertFn('isEquivType: Expected type must not be undefined', expected !== undefined);\n  AssertFn('isEquivType: Expected type must be a string', typeof expected === 'string');\n  AssertFn('isEquivType: Expected type must not be empty', expected.length > 0);\n\n  AssertFn('isEquivType: Actual type must not be null', actual !== null);\n  AssertFn('isEquivType: Actual type must not be undefined', actual !== undefined);\n  AssertFn('isEquivType: Actual type must be a string', typeof actual === 'string');\n  AssertFn('isEquivType: Actual type must not be empty', actual.length > 0);\n\n  return expected === actual || formattedType(expected) === formattedType(actual);\n}\n\n/**\n * Compares two IDs for strict equality, converting them to\n * the format expected by the WarpDrive Cache to ensure\n * differences in format are accounted for in the comparison.\n *\n * Asserts when expected or actual are invalid IDs in dev.\n * Expected may never be null.\n *\n * ```js\n * isEquivId('1', 1); // true\n * isEquivId('2', '2'); // true\n * isEquivId(3, '3'); // true\n * isEquivId(4, '3'); // false\n * isEquivId(1, null); // false\n * ```\n *\n * @param expected a potentially un-normalized id to match against\n * @param actual a potentially un-normalized id to match against\n * @return true if the ids are equivalent\n * @public\n */\nexport function isEquivId(expected: string | number, actual: string | number | null): boolean {\n  AssertFn('isEquivId: Expected id must not be null', expected !== null);\n  AssertFn('isEquivId: Expected id must not be undefined', expected !== undefined);\n  AssertFn(\n    'isEquivId: Expected id must be a number or string',\n    typeof expected === 'number' || typeof expected === 'string'\n  );\n  AssertFn(\n    'isEquivId: Expected id must not be empty',\n    typeof expected === 'number' || (typeof expected === 'string' && expected.length > 0)\n  );\n  AssertFn('isEquivId: Expected id must not be 0', expected !== '0' && expected !== 0);\n\n  AssertFn('isEquivId: Actual id must not be undefined', actual !== undefined);\n  AssertFn(\n    'isEquivId: Actual id must be a number, string or null',\n    typeof actual === 'number' || typeof actual === 'string' || actual === null\n  );\n  AssertFn(\n    'isEquivId: Actual id must not be empty',\n    actual === null || typeof actual === 'number' || (typeof actual === 'string' && actual.length > 0)\n  );\n  AssertFn('isEquivId: Actual id must not be 0', actual !== '0' && actual !== 0);\n\n  return expected === actual || formattedId(expected) === formattedId(actual);\n}\n"],"mappings":";;;;;;;;;;AAiBA,IAAII,mBAA6B,WAAY,CAAC;AAI9C,IAAIC,YAA2D,WAAY,CAAC;AAC5E,MAAMC,YAAyBC,SAAiBC,cAAuB;CACrE,IAAI,CAACA,WACHH,UAAUE,SAASC,SAAS;CAE9BN,eAAAC,gBAAA,CAAA,CAAAM,UAAAC,IAAAC,KAAA,OAAAC,SAAA;EAAA,IAAA,CAAAA,MAAA,MAAA,IAAAC,MAAON,OAAO;CAAA,EAAA,CAAEC,SAAS;AAC3B;AACA,IAAIM,kBAA8BC,QAAgB;CAChD,OAAOd,YAAYD,UAAUe,GAAG,CAAC;AACnC;;;;;;;;;AAUA,SAAgBC,0BAA0BC,IAAoB;CAC5Db,mBAAmBa;AACrB;;;;;;;;;AAUA,SAAgBC,kBAAkBD,IAAyD;CACzFZ,YAAYY;AACd;;;;;;;;;;;;;;AAeA,SAAgBE,2BAA2BF,IAAoC;CAC7EH,iBAAiBG;AACnB;AAEA,MAAMG,mCAAmB,IAAIC,IAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BjD,SAAgBC,cAAgCC,MAAqB;CACnEjB,SAAS,wCAAwCiB,SAAS,IAAI;CAC9DjB,SAAS,6CAA6CiB,SAASC,MAAS;CACxElB,SAAS,wCAAwC,OAAOiB,SAAS,QAAQ;CACzEjB,SAAS,yCAAyCiB,KAAKE,SAAS,CAAC;CACjE,IAAIC,aAAaN,iBAAiBO,IAAIJ,IAAI;CAE1C,IAAIG,eAAeF,QAAW;EAC5BE,aAAaZ,eAAeS,IAAI;EAChCH,iBAAiBQ,IAAIL,MAAMG,UAAU;CACvC;CAEA,IAAIA,eAAeH,MACjBnB,iBAAiB,kBAAkBmB,MAAMG,UAAU;CAGrD,OAAOA;AACT;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgBG,YAAYC,IAA2C;CACrExB,SAAS,yCAAyCwB,OAAON,MAAS;CAClElB,SACE,oDACA,OAAOwB,OAAO,YAAY,OAAOA,OAAO,YAAYA,OAAO,IAC7D;CACAxB,SACE,qCACA,OAAOwB,OAAO,YAAYA,OAAO,QAAS,OAAOA,OAAO,YAAYA,GAAGL,SAAS,CAClF;CACAnB,SAAS,iCAAiCwB,OAAO,OAAOA,OAAO,CAAC;CAEhE,MAAMC,YAAYD,OAAO,OAAO,OAAOE,OAAOF,EAAE;CAChD,IAAIC,cAAcD,IAChB1B,iBAAiB,gBAAgB0B,IAAIC,SAAS;CAEhD,OAAOD,OAAO,OAAO,OAAOE,OAAOF,EAAE;AACvC;;;;;;;;;;;;AAeA,SAAgBG,SAASH,IAAoC;CAC3DxB,SAAS,iCAAiCwB,OAAO,IAAI;CAErD,OAAOD,YAAYC,EAAE;AACvB;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,SAAgBI,YAAYC,UAAkBC,QAAyB;CACrE9B,SAAS,+CAA+C6B,aAAa,IAAI;CACzE7B,SAAS,oDAAoD6B,aAAaX,MAAS;CACnFlB,SAAS,+CAA+C,OAAO6B,aAAa,QAAQ;CACpF7B,SAAS,gDAAgD6B,SAASV,SAAS,CAAC;CAE5EnB,SAAS,6CAA6C8B,WAAW,IAAI;CACrE9B,SAAS,kDAAkD8B,WAAWZ,MAAS;CAC/ElB,SAAS,6CAA6C,OAAO8B,WAAW,QAAQ;CAChF9B,SAAS,8CAA8C8B,OAAOX,SAAS,CAAC;CAExE,OAAOU,aAAaC,UAAUd,cAAca,QAAQ,MAAMb,cAAcc,MAAM;AAChF;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgBC,UAAUF,UAA2BC,QAAyC;CAC5F9B,SAAS,2CAA2C6B,aAAa,IAAI;CACrE7B,SAAS,gDAAgD6B,aAAaX,MAAS;CAC/ElB,SACE,qDACA,OAAO6B,aAAa,YAAY,OAAOA,aAAa,QACtD;CACA7B,SACE,4CACA,OAAO6B,aAAa,YAAa,OAAOA,aAAa,YAAYA,SAASV,SAAS,CACrF;CACAnB,SAAS,wCAAwC6B,aAAa,OAAOA,aAAa,CAAC;CAEnF7B,SAAS,8CAA8C8B,WAAWZ,MAAS;CAC3ElB,SACE,yDACA,OAAO8B,WAAW,YAAY,OAAOA,WAAW,YAAYA,WAAW,IACzE;CACA9B,SACE,0CACA8B,WAAW,QAAQ,OAAOA,WAAW,YAAa,OAAOA,WAAW,YAAYA,OAAOX,SAAS,CAClG;CACAnB,SAAS,sCAAsC8B,WAAW,OAAOA,WAAW,CAAC;CAE7E,OAAOD,aAAaC,UAAUP,YAAYM,QAAQ,MAAMN,YAAYO,MAAM;AAC5E"}