@humeris/boule - npm Package Compare versions

Comparing version 1.0.1 to 2.0.0

dist/boolean.d.ts

@@ -6,2 +6,4 @@ export declare type If<C extends boolean, A, B> = C extends true ? A : B;
 export declare type AnyTrue<T extends Array<boolean>> = T extends Array<false> ? false : true;
+export declare type AnyFalse<T extends Array<boolean>> = T extends Array<true> ? false : true;
 export declare type AllTrue<T extends Array<boolean>> = T extends Array<true> ? true : false;
+export declare type AllFalse<T extends Array<boolean>> = T extends Array<false> ? true : false;

dist/predicates.d.ts

@@ -1,2 +0,2 @@
-import { AllTrue, And, AnyTrue, Not } from "./boolean";
+import { AllFalse, AllTrue, And, AnyTrue, Not } from "./boolean";
 export declare type IsSubtype<T, U> = T extends U ? true : false;
@@ -6,33 +6,46 @@ export declare type IsAny<T> = IsSubtype<[T], T & []>;
 export declare type IsUnknown<T> = And<Not<IsAny<T>>, IsSubtype<unknown, T>>;
-export declare type IsReified<T> = Not<AnyTrue<[IsAny<T>, IsUnknown<T>, IsNever<T>]>>;
-export declare type IsEqual<T, U> = AnyTrue<[
+export declare type IsReified<T> = AllFalse<[IsAny<T>, IsUnknown<T>, IsNever<T>]>;
+export declare type IsCompatible<T, U> = IsSubtype<[T, U], [U, T]>;
+declare type NonNilable<T> = T extends null | undefined | void ? never : T;
+declare type MAX_DEPTH = 8;
+export declare type Is<T, U, DepthMeter extends never[] = []> = DepthMeter["length"] extends MAX_DEPTH ? true : And<IsReified<T>, IsReified<U>> extends true ? CompareNormalized<Normalize<T>, Normalize<U>, [never, never, ...DepthMeter]> : AnyTrue<[
     And<IsAny<T>, IsAny<U>>,
     And<IsNever<T>, IsNever<U>>,
-    And<IsUnknown<T>, IsUnknown<U>>,
-    AllTrue<[IsReified<T>, IsReified<U>, IsSubtype<T, U>, IsSubtype<U, T>]>
+    And<IsUnknown<T>, IsUnknown<U>>
 ]>;
-declare type StructurallyEqual<T, U> = IsSubtype<{
-    [K in keyof T]: K extends keyof U ? Is<T[K], U[K]> : never;
+declare type CompareNormalized<T extends NormalizedData, U extends NormalizedData, DepthMeter extends never[]> = IsCompatible<keyof T, keyof U> extends true ? And<IsSubtype<{
+    [K in Exclude<keyof T & keyof U, typeof data>]: Is<T[K], U[K], [never, ...DepthMeter]>;
 }, {
-    [K in keyof T]: true;
-}>;
-declare type AnyFunction = (...args: Array<any>) => any;
-declare type DeltaStructurallyEqual<T, U> = StructurallyEqual<Exclude<T, U>, Exclude<U, T>>;
-declare type ParametersEqual<T, U> = DeltaStructurallyEqual<Parameters<T extends AnyFunction ? T : never>, Parameters<U extends AnyFunction ? U : never>>;
-declare type ReturnTypesEqual<T, U> = DeltaStructurallyEqual<ReturnType<T extends AnyFunction ? T : never>, ReturnType<U extends AnyFunction ? U : never>>;
-export declare type Is<T, U> = AnyTrue<[
-    And<IsAny<T>, IsAny<U>>,
-    And<IsNever<T>, IsNever<U>>,
-    And<IsUnknown<T>, IsUnknown<U>>,
-    AllTrue<[
-        IsReified<T>,
-        IsReified<U>,
-        IsSubtype<T, U>,
-        IsSubtype<U, T>,
-        IsEqual<keyof Exclude<T, null | undefined>, keyof Exclude<U, null | undefined>>,
-        StructurallyEqual<T, U>,
-        ParametersEqual<T, U>,
-        ReturnTypesEqual<T, U>
-    ]>
-]>;
+    [K in Exclude<keyof T & keyof U, typeof data>]: true;
+}>, CompareData<T[typeof data], U[typeof data], [never, ...DepthMeter]>> : false;
+export declare type CompareData<T, U, DepthMeter extends never[]> = AllTrue<[
+    IsSubtype<T, object>,
+    IsSubtype<U, object>,
+    IsCompatible<T, U>
+]> extends true ? StructurallyEqual<NonNilable<T>, NonNilable<U>, [never, ...DepthMeter]> : IsCompatible<T, U>;
+declare type StructurallyEqual<T, U, DepthMeter extends never[]> = IsCompatible<keyof T, keyof U> extends true ? IsSubtype<{
+    [K in keyof T & keyof U]: Is<T[K], U[K], [never, ...DepthMeter]>;
+}, {
+    [K in keyof T & keyof U]: true;
+}> : false;
+declare const data: unique symbol;
+declare const parameters: unique symbol;
+declare const return_type: unique symbol;
+declare const constructor_parameters: unique symbol;
+declare type NormalizedData = {
+    [data]?: any;
+    [parameters]?: any;
+    [return_type]?: any;
+    [constructor_parameters]?: any;
+};
+declare type NormalizeConstructor<T> = T extends new (...args: infer P) => infer R ? T extends infer G & (new (...args: P) => R) ? {
+    [data]: G;
+    [constructor_parameters]: P;
+} : never : {
+    [data]: T;
+};
+declare type Normalize<T> = T extends (...args: infer P) => infer R ? T extends infer G & ((...args: P) => R) ? NormalizeConstructor<G> & {
+    [parameters]: P;
+    [return_type]: R;
+} : never : NormalizeConstructor<T>;
 export {};

package.json

 {
   "name": "@humeris/boule",
-  "version": "1.0.1",
+  "version": "2.0.0",
   "publisher": "humeris",
@@ -36,4 +36,4 @@ "license": "MIT",
     "rollup": "^2.23.1",
-    "typescript": "^4.0.1-rc"
+    "typescript": "^4.1.0-dev.20200817"
   }
 }

No alert changes

Improved metrics

Total package byte prevSize

4451

increased by33.5%

Lines of code

61

increased by32.61%

No dependency changes