@paulirish/trace_engine 0.0.8 → 0.0.10

package/core/platform/typescript-utilities.d.ts

@@ -0,0 +1,56 @@
+/**
+ * This is useful to keep TypeScript happy in a test - if you have a value
+ * that's potentially `null` you can use this function to assert that it isn't,
+ * and satisfy TypeScript that the value is present.
+ */
+export declare function assertNotNullOrUndefined<T>(val: T): asserts val is NonNullable<T>;
+export declare function assertNever(type: never, message: string): never;
+/**
+ * This is useful to check on the type-level that the unhandled cases of
+ * a switch are exactly `T` (where T is usually a union type of enum values).
+ * @param caseVariable
+ */
+export declare function assertUnhandled<T>(_caseVariable: T): T;
+export declare type FieldsThatExtend<Type, Selector> = {
+    [Key in keyof Type]: Type[Key] extends Selector ? Key : never;
+}[keyof Type];
+export declare type PickFieldsThatExtend<Type, Selector> = Pick<Type, FieldsThatExtend<Type, Selector>>;
+/**
+ * Turns a Union type (a | b) into an Intersection type (a & b).
+ * This is a helper type to implement the "NoUnion" guard.
+ *
+ * Adapted from https://stackoverflow.com/a/50375286.
+ *
+ * The tautological `T extends any` is necessary to trigger distributivity for
+ * plain unions, e.g. in IntersectionFromUnion<'a'|'b'> TypeScript expands it
+ * to  ('a' extends any ? (arg: 'a') => void : never)
+ *  |  ('b' extends any ? (arg: 'b') => void : never)
+ *
+ * The second extends clause then asks TypeScript to find a type of the form
+ * `(arg: infer U) => void` that upper-bounds the union, i.e., intuitively,
+ * a type that converts to each of the union members. This forces U to be the
+ * intersection of 'a' and 'b' in the example.
+ *
+ * Please note that some intersection types are simply impossible, e.g.
+ * `string & number`. There is no type that fulfills both at the same time. A
+ * union of this kind is reduced to `never`.
+ */
+declare type IntersectionFromUnion<T> = (T extends any ? (arg: T) => void : never) extends ((arg: infer U) => void) ? U : never;
+/**
+ * When writing generic code it may be desired to disallow Union types from
+ * being passed. This type can be used in those cases.
+ *
+ *   function foo<T>(argument: NoUnion<T>) {...}
+ *
+ * Would result in a compile error for foo<a|b>(...); invocations as `argument`
+ * would be typed as `never`.
+ *
+ * Adapted from https://stackoverflow.com/a/50641073.
+ *
+ * Conditional types become distributive when receiving a union type. To
+ * prevent this from happening, we use `[T] extends [IntersectionFromUnion<T>]`
+ * instead of `T extends IntersectionFromUnion<T>`.
+ * See: https://www.typescriptlang.org/docs/handbook/2/conditional-types.html
+ */
+export declare type NoUnion<T> = [T] extends [IntersectionFromUnion<T>] ? T : never;
+export {};

package/core/platform/typescript-utilities.js

@@ -0,0 +1,13 @@
+export function assertNotNullOrUndefined(val, message) {
+  if (val === null || val === void 0) {
+    throw new Error(`Expected given value to not be null/undefined but it was: ${val}${message ? `
+${message}` : ""}`);
+  }
+}
+export function assertNever(type, message) {
+  throw new Error(message);
+}
+export function assertUnhandled(_caseVariable) {
+  return _caseVariable;
+}
+//# sourceMappingURL=typescript-utilities.js.map

package/core/platform/typescript-utilities.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../front_end/core/platform/typescript-utilities.ts"],
+  "sourcesContent": ["// Copyright 2020 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\n\n/**\n * This is useful to keep TypeScript happy in a test - if you have a value\n * that's potentially `null` you can use this function to assert that it isn't,\n * and satisfy TypeScript that the value is present.\n */\nexport function assertNotNullOrUndefined<T>(val: T, message?: string): asserts val is NonNullable<T> {\n  if (val === null || val === undefined) {\n    throw new Error(`Expected given value to not be null/undefined but it was: ${val}${message ? `\\n${message}` : ''}`);\n  }\n}\n\nexport function assertNever(type: never, message: string): never {\n  throw new Error(message);\n}\n\n/**\n * This is useful to check on the type-level that the unhandled cases of\n * a switch are exactly `T` (where T is usually a union type of enum values).\n * @param caseVariable\n */\nexport function assertUnhandled<T>(_caseVariable: T): T {\n  return _caseVariable;\n}\n\nexport type FieldsThatExtend<Type, Selector> = {\n  [Key in keyof Type]: Type[Key] extends Selector ? Key : never;\n}[keyof Type];\n\nexport type PickFieldsThatExtend<Type, Selector> = Pick<Type, FieldsThatExtend<Type, Selector>>;\n\n/**\n * Turns a Union type (a | b) into an Intersection type (a & b).\n * This is a helper type to implement the \"NoUnion\" guard.\n *\n * Adapted from https://stackoverflow.com/a/50375286.\n *\n * The tautological `T extends any` is necessary to trigger distributivity for\n * plain unions, e.g. in IntersectionFromUnion<'a'|'b'> TypeScript expands it\n * to  ('a' extends any ? (arg: 'a') => void : never)\n *  |  ('b' extends any ? (arg: 'b') => void : never)\n *\n * The second extends clause then asks TypeScript to find a type of the form\n * `(arg: infer U) => void` that upper-bounds the union, i.e., intuitively,\n * a type that converts to each of the union members. This forces U to be the\n * intersection of 'a' and 'b' in the example.\n *\n * Please note that some intersection types are simply impossible, e.g.\n * `string & number`. There is no type that fulfills both at the same time. A\n * union of this kind is reduced to `never`.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype IntersectionFromUnion<T> = (T extends any ? (arg: T) => void : never) extends((arg: infer U) => void) ? U : never;\n\n/**\n * When writing generic code it may be desired to disallow Union types from\n * being passed. This type can be used in those cases.\n *\n *   function foo<T>(argument: NoUnion<T>) {...}\n *\n * Would result in a compile error for foo<a|b>(...); invocations as `argument`\n * would be typed as `never`.\n *\n * Adapted from https://stackoverflow.com/a/50641073.\n *\n * Conditional types become distributive when receiving a union type. To\n * prevent this from happening, we use `[T] extends [IntersectionFromUnion<T>]`\n * instead of `T extends IntersectionFromUnion<T>`.\n * See: https://www.typescriptlang.org/docs/handbook/2/conditional-types.html\n */\nexport type NoUnion<T> = [T] extends [IntersectionFromUnion<T>] ? T : never;\n"],
+  "mappings": "AASO,yCAAqC,KAAQ,SAAiD;AACnG,MAAI,QAAQ,QAAQ,QAAQ,QAAW;AACrC,UAAM,IAAI,MAAM,6DAA6D,MAAM,UAAU;AAAA,EAAK,YAAY;AAAA;AAAA;AAI3G,4BAAqB,MAAa,SAAwB;AAC/D,QAAM,IAAI,MAAM;AAAA;AAQX,gCAA4B,eAAqB;AACtD,SAAO;AAAA;",
+  "names": []
+}