type-enforcer-test-helper 1.3.10 → 2.0.0-alpha.0

package/types/src/data/testData.d.ts

@@ -1,289 +0,0 @@
-export namespace arrayData {
-    export let value: ArrayConstructor;
-    export let name: string;
-    export { validArrays as true };
-    let _false: any;
-    export { _false as false };
-    export { coerceArrayTrue as coerceTrue };
-    export let coerceFalse: any;
-}
-export namespace booleanData {
-    let value_1: BooleanConstructor;
-    export { value_1 as value };
-    let name_1: string;
-    export { name_1 as name };
-    export { validBooleans as true };
-    let _false_1: any;
-    export { _false_1 as false };
-    export let coerceTrue: any;
-    let coerceFalse_1: any[];
-    export { coerceFalse_1 as coerceFalse };
-}
-export namespace dateData {
-    let value_2: DateConstructor;
-    export { value_2 as value };
-    let name_2: string;
-    export { name_2 as name };
-    export { validDates as true };
-    let _false_2: any;
-    export { _false_2 as false };
-    let coerceTrue_1: string[];
-    export { coerceTrue_1 as coerceTrue };
-    let coerceFalse_2: any;
-    export { coerceFalse_2 as coerceFalse };
-}
-export namespace functionData {
-    let value_3: FunctionConstructor;
-    export { value_3 as value };
-    let name_3: string;
-    export { name_3 as name };
-    export { validFunctions as true };
-    let _false_3: any;
-    export { _false_3 as false };
-    let coerceTrue_2: any[];
-    export { coerceTrue_2 as coerceTrue };
-    let coerceFalse_3: any;
-    export { coerceFalse_3 as coerceFalse };
-}
-export namespace instanceData {
-    export { TestClass as value };
-    let name_4: string;
-    export { name_4 as name };
-    export { validInstances as true };
-    let _false_4: any;
-    export { _false_4 as false };
-    let coerceTrue_3: any[];
-    export { coerceTrue_3 as coerceTrue };
-    let coerceFalse_4: any[];
-    export { coerceFalse_4 as coerceFalse };
-}
-export namespace integerData {
-    let name_5: string;
-    export { name_5 as name };
-    export let skip: string[];
-    export { validIntegers as true };
-    let _false_5: any;
-    export { _false_5 as false };
-    export { coerceIntegerTrue as coerceTrue };
-    let coerceFalse_5: (string | number)[];
-    export { coerceFalse_5 as coerceFalse };
-}
-export namespace jsonData {
-    let name_6: string;
-    export { name_6 as name };
-    let _true: string[];
-    export { _true as true };
-    let _false_6: string[];
-    export { _false_6 as false };
-    let coerceTrue_4: any[];
-    export { coerceTrue_4 as coerceTrue };
-    let coerceFalse_6: any[];
-    export { coerceFalse_6 as coerceFalse };
-}
-export namespace floatData {
-    let name_7: string;
-    export { name_7 as name };
-    let skip_1: string[];
-    export { skip_1 as skip };
-    export { validFloats as true };
-    let _false_7: any;
-    export { _false_7 as false };
-    let coerceTrue_5: string[];
-    export { coerceTrue_5 as coerceTrue };
-    let coerceFalse_7: (string | number)[];
-    export { coerceFalse_7 as coerceFalse };
-}
-export namespace numberData {
-    let value_4: NumberConstructor;
-    export { value_4 as value };
-    let name_8: string;
-    export { name_8 as name };
-    let skip_2: string[];
-    export { skip_2 as skip };
-    let _true_1: (number | Number)[];
-    export { _true_1 as true };
-    let _false_8: any;
-    export { _false_8 as false };
-    let coerceTrue_6: string[];
-    export { coerceTrue_6 as coerceTrue };
-    export { coerceNumberFalse as coerceFalse };
-}
-export namespace mapData {
-    let value_5: any;
-    export { value_5 as value };
-    let name_9: string;
-    export { name_9 as name };
-    export { validMaps as true };
-    let _false_9: any;
-    export { _false_9 as false };
-    let coerceTrue_7: string[];
-    export { coerceTrue_7 as coerceTrue };
-    let coerceFalse_8: any;
-    export { coerceFalse_8 as coerceFalse };
-}
-export namespace objectData {
-    let value_6: ObjectConstructor;
-    export { value_6 as value };
-    let name_10: string;
-    export { name_10 as name };
-    export { validObjects as true };
-    let _false_10: boolean[];
-    export { _false_10 as false };
-    export { coerceObjectTrue as coerceTrue };
-    export { validStrings as coerceFalse };
-}
-export namespace promiseData {
-    let value_7: any;
-    export { value_7 as value };
-    let name_11: string;
-    export { name_11 as name };
-    export { validPromises as true };
-    let _false_11: any;
-    export { _false_11 as false };
-    export { validFunctions as coerceTrue };
-    let coerceFalse_9: any;
-    export { coerceFalse_9 as coerceFalse };
-}
-export namespace regExpData {
-    let value_8: RegExpConstructor;
-    export { value_8 as value };
-    let name_12: string;
-    export { name_12 as name };
-    export { validRegExps as true };
-    let _false_12: any;
-    export { _false_12 as false };
-    let coerceTrue_8: string[];
-    export { coerceTrue_8 as coerceTrue };
-    let coerceFalse_10: any;
-    export { coerceFalse_10 as coerceFalse };
-}
-export namespace setData {
-    let value_9: any;
-    export { value_9 as value };
-    let name_13: string;
-    export { name_13 as name };
-    export { validSets as true };
-    let _false_13: any;
-    export { _false_13 as false };
-    let coerceTrue_9: any[][];
-    export { coerceTrue_9 as coerceTrue };
-    let coerceFalse_11: any;
-    export { coerceFalse_11 as coerceFalse };
-}
-export namespace stringData {
-    let value_10: StringConstructor;
-    export { value_10 as value };
-    let name_14: string;
-    export { name_14 as name };
-    export { validStrings as true };
-    let _false_14: any;
-    export { _false_14 as false };
-    let coerceTrue_10: any;
-    export { coerceTrue_10 as coerceTrue };
-    let coerceFalse_12: any[];
-    export { coerceFalse_12 as coerceFalse };
-}
-export namespace symbolData {
-    let value_11: any;
-    export { value_11 as value };
-    let name_15: string;
-    export { name_15 as name };
-    export { validSymbols as true };
-    let _false_15: any;
-    export { _false_15 as false };
-    import coerceTrue_11 = stringData.coerceTrue;
-    export { coerceTrue_11 as coerceTrue };
-    import coerceFalse_13 = stringData.coerceFalse;
-    export { coerceFalse_13 as coerceFalse };
-}
-export namespace weakMapData {
-    let value_12: any;
-    export { value_12 as value };
-    let name_16: string;
-    export { name_16 as name };
-    export { validWeakMaps as true };
-    let _false_16: any;
-    export { _false_16 as false };
-    let coerceTrue_12: ((number | typeof TestClass)[] | (string | typeof TestClass)[])[][];
-    export { coerceTrue_12 as coerceTrue };
-    let coerceFalse_14: any;
-    export { coerceFalse_14 as coerceFalse };
-}
-export namespace weakSetData {
-    let value_13: any;
-    export { value_13 as value };
-    let name_17: string;
-    export { name_17 as name };
-    export { validWeakSets as true };
-    let _false_17: any;
-    export { _false_17 as false };
-    let coerceTrue_13: TestClass[][];
-    export { coerceTrue_13 as coerceTrue };
-    let coerceFalse_15: any;
-    export { coerceFalse_15 as coerceFalse };
-}
-export const testTypes: ({
-    value: FunctionConstructor;
-    name: string;
-    true: (() => void)[];
-    false: any;
-    coerceTrue: any[];
-    coerceFalse: any;
-} | {
-    name: string;
-    skip: string[];
-    true: (number | Number)[];
-    false: any;
-    coerceTrue: string[];
-    coerceFalse: (string | number)[];
-} | {
-    value: any;
-    name: string;
-    true: any[];
-    false: any;
-    coerceTrue: string[];
-    coerceFalse: any;
-} | {
-    value: any;
-    name: string;
-    true: any[];
-    false: any;
-    coerceTrue: (() => void)[];
-    coerceFalse: any;
-} | {
-    value: any;
-    name: string;
-    true: any[];
-    false: any;
-    coerceTrue: any[][];
-    coerceFalse: any;
-} | {
-    value: any;
-    name: string;
-    true: any[];
-    false: any;
-    coerceTrue: any;
-    coerceFalse: any[];
-})[];
-import { validArrays } from './testValues.js';
-import { coerceArrayTrue } from './coercible.js';
-import { validBooleans } from './testValues.js';
-import { validDates } from './testValues.js';
-import { validFunctions } from './testValues.js';
-import TestClass from './TestClass.js';
-import { validInstances } from './testValues.js';
-import { validIntegers } from './testValues.js';
-import { coerceIntegerTrue } from './coercible.js';
-import { validFloats } from './testValues.js';
-import { coerceNumberFalse } from './coercible.js';
-import { validMaps } from './testValues.js';
-import { validObjects } from './testValues.js';
-import { coerceObjectTrue } from './coercible.js';
-import { validStrings } from './testValues.js';
-import { validPromises } from './testValues.js';
-import { validRegExps } from './testValues.js';
-import { validSets } from './testValues.js';
-import { validSymbols } from './testValues.js';
-import { validWeakMaps } from './testValues.js';
-import { validWeakSets } from './testValues.js';
-//# sourceMappingURL=testData.d.ts.map

package/types/src/data/testData.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"testData.d.ts","sourceRoot":"","sources":["../../../src/data/testData.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8YA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkBE;4BAnYK,iBAAiB;gCArBjB,gBAAgB;8BAqBhB,iBAAiB;2BAAjB,iBAAiB;+BAAjB,iBAAiB;sBApBF,gBAAgB;+BAoB/B,iBAAiB;8BAAjB,iBAAiB;kCArBjB,gBAAgB;4BAqBhB,iBAAiB;kCArBjB,gBAAgB;0BAqBhB,iBAAiB;6BAAjB,iBAAiB;iCArBjB,gBAAgB;6BAqBhB,iBAAiB;8BAAjB,iBAAiB;6BAAjB,iBAAiB;0BAAjB,iBAAiB;6BAAjB,iBAAiB;8BAAjB,iBAAiB;8BAAjB,iBAAiB"}

package/types/src/data/testValues.d.ts

@@ -1,26 +0,0 @@
-export const validArrays: any[][];
-export const validBooleans: (boolean | Boolean)[];
-export const validDates: Date[];
-export const validFunctions: (() => void)[];
-export const validInstances: TestClass[];
-export const validIntegers: (number | Number)[];
-export const validFloats: (number | Number)[];
-export const validInfinities: number[];
-export const validMaps: any[];
-export const validObjects: any[];
-export const validPromises: any[];
-export const validRegExps: RegExp[];
-export const validSets: any[];
-export const validStrings: (string | String)[];
-export const validSymbols: any[];
-export const validWeakMaps: any[];
-export const validWeakSets: any[];
-/**
- * Undefined, null, and NaN
- *
- * @constant {Array} validNots
- */
-export const validNots: number[];
-export const testValues: number[];
-import TestClass from './TestClass.js';
-//# sourceMappingURL=testValues.d.ts.map

package/types/src/data/testValues.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"testValues.d.ts","sourceRoot":"","sources":["../../../src/data/testValues.js"],"names":[],"mappings":"AAcA,kCAQE;AAQF,kDAME;AAQF,gCAGE;AASF,4CAQE;AAQF,yCAIE;AAQF,gDAKE;AAQF,8CAOE;AAQF,uCAGE;AAQF,8BAGE;AAQF,iCAKE;AAQF,kCAIE;AAQF,oCAIE;AAQF,8BAGE;AAQF,+CAKE;AAQF,iCAAwD;AAQxD,kCAGE;AAQF,kCAA+D;AAE/D;;;;GAIG;AACH,iCAAgD;AAEhD,kCAiBE;sBAhPoB,gBAAgB"}

package/types/src/multiTest.d.ts

@@ -1,14 +0,0 @@
-declare function _default(settings: {
-    values: object | any[];
-    values2?: object | any[];
-    test: Function;
-    filter?: Function;
-    message?: Function;
-    inputKey?: string;
-    outputKey?: string;
-    output?: unknown;
-    eachPair?: boolean;
-    assertion?: string;
-}): void;
-export default _default;
-//# sourceMappingURL=multiTest.d.ts.map

package/types/src/multiTest.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"multiTest.d.ts","sourceRoot":"","sources":["../../src/multiTest.js"],"names":[],"mappings":"AAmCe;IAXqB,MAAM,EAA/B,MAAM,QAAQ;IACY,OAAO,GAAjC,MAAM,QAAQ;IACS,IAAI;IACH,MAAM;IACN,OAAO;IACP,QAAQ,GAAhC,MAAM;IACkB,SAAS,GAAjC,MAAM;IACwB,MAAM,GAApC,OAAO;IACiB,QAAQ,GAAhC,OAAO;IACiB,SAAS,GAAjC,MAAM;SA2FhB"}

package/types/src/testCheck.d.ts

@@ -1,11 +0,0 @@
-/**
- * Test a type-enforcer check function (isArray, isBoolean, etc.).
- *
- * @function testCheck
- *
- * @param {object} data - A data object (arrayData, booleanData, etc.).
- * @param {Function} check - The function to test.
- * @param {object} is - An object that includes this function.
- */
-export default function _default(data: object, check: Function, is: object): void;
-//# sourceMappingURL=testCheck.d.ts.map

package/types/src/testCheck.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"testCheck.d.ts","sourceRoot":"","sources":["../../src/testCheck.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,uCAJW,MAAM,uBAEN,MAAM,QAwDhB"}

package/types/src/testEnforce.d.ts

@@ -1,12 +0,0 @@
-/**
- * Test an enforce function (enforceArray, enforceBoolean, etc.).
- *
- * @function testEnforce
- *
- * @param {object} data - A data object (arrayData, booleanData, etc.).
- * @param {Function} enforcer - The function to test.
- * @param {object} enforce - An object that includes this function.
- * @param {Function} coercer - A function that does a coercion just like this function.
- */
-export default function _default(data: object, enforcer: Function, enforce: object, coercer: Function): void;
-//# sourceMappingURL=testEnforce.d.ts.map

package/types/src/testEnforce.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"testEnforce.d.ts","sourceRoot":"","sources":["../../src/testEnforce.js"],"names":[],"mappings":"AAMA;;;;;;;;;GASG;AACH,uCALW,MAAM,+BAEN,MAAM,2BAiIhB"}

package/types/src/testMethod.d.ts

@@ -1,27 +0,0 @@
-/**
- * Test a chainable method function (methodArray, methodBoolean, etc.).
- *
- * @function testMethod
- *
- * @param {object} settings - Settings object.
- * @param {object} settings.name - The name used in type-enforcer namespaces for this type.
- * @param {object} settings.init - The expected value returned by the method immediately after instantiation.
- * @param {object} settings.extraProps - An object of extra properties to be passed in when the method is instantiated.
- * @param {Array} settings.true - An array of values that are valid for this method.
- * @param {Array} settings.false - An array of values that are NOT valid for this method.
- * @param {Array|false} [settings.coerce] - An array of objects with values that can be coerced by this method.
- * @param {unknown} settings.coerce[].value - The value to be coerced.
- * @param {unknown} settings.coerce[].coerced - The expected result of coercion.
- * @param {Array} settings.coerceTrue - Alternatively, an array of values that are coercible by this method.
- * @param {Function} thisMethod - The function to test.
- * @param {object} method - An object that includes this function.
- */
-export default function _default(settings: {
-    name: object;
-    init: object;
-    extraProps: object;
-    true: any[];
-    false: any[];
-    coerce?: any[] | false;
-}, thisMethod: Function, method: object): void;
-//# sourceMappingURL=testMethod.d.ts.map

package/types/src/testMethod.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"testMethod.d.ts","sourceRoot":"","sources":["../../src/testMethod.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;;GAiBG;AACH;IAZ4B,IAAI,EAArB,MAAM;IACW,IAAI,EAArB,MAAM;IACW,UAAU,EAA3B,MAAM;IACU,IAAI;IACJ,KAAK;IACE,MAAM,GAA7B,QAAM,KAAK;iCAKX,MAAM,QA6YhB"}

package/types/src/utility/difference.d.ts

@@ -1,3 +0,0 @@
-declare function _default(array1: any, ...args: any[]): any;
-export default _default;
-//# sourceMappingURL=difference.d.ts.map

package/types/src/utility/difference.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"difference.d.ts","sourceRoot":"","sources":["../../../src/utility/difference.js"],"names":[],"mappings":"AAAe,4DAGd"}