@vertexvis/utils 0.24.5-canary.4 → 1.0.0-testing.0

package/dist/eventTargets.d.ts

@@ -1,10 +1,10 @@
-/**
- * Adds a listener to the given `target`, and returns a promise that
- * resolves with the first event emitted of the given `type`.
- *
- * @param target The target to add an event listener to.
- * @param type The event type to listen for.
- * @param opts Options to pass to `addEventListener`.
- * @returns A promise that resolves with the first event emitted of `type`.
- */
-export declare function once<E extends Event>(target: EventTarget, type: string, opts?: boolean | AddEventListenerOptions): Promise<E>;
+/**
+ * Adds a listener to the given `target`, and returns a promise that
+ * resolves with the first event emitted of the given `type`.
+ *
+ * @param target The target to add an event listener to.
+ * @param type The event type to listen for.
+ * @param opts Options to pass to `addEventListener`.
+ * @returns A promise that resolves with the first event emitted of `type`.
+ */
+export declare function once<E extends Event>(target: EventTarget, type: string, opts?: boolean | AddEventListenerOptions): Promise<E>;

package/dist/index.d.ts

@@ -1,19 +1,19 @@
-/**
- * @module Utils
- */
-import * as Async from './async';
-import * as BinaryReader from './binaryReader';
-import * as Color from './color';
-import * as EventTargets from './eventTargets';
-import * as Mapper from './mapper';
-import * as Objects from './objects';
-import * as Range from './range';
-import * as Sets from './sets';
-import * as Strings from './strings';
-import * as Uri from './uri';
-import * as UUID from './uuid';
-export * from './disposable';
-export * from './eventDispatcher';
-export * from './mappedTypes';
-export * from './predicate';
-export { Async, BinaryReader, Color, EventTargets, Mapper, Objects, Range, Sets, Strings, Uri, UUID, };
+/**
+ * @module Utils
+ */
+import * as Async from './async';
+import * as BinaryReader from './binaryReader';
+import * as Color from './color';
+import * as EventTargets from './eventTargets';
+import * as Mapper from './mapper';
+import * as Objects from './objects';
+import * as Range from './range';
+import * as Sets from './sets';
+import * as Strings from './strings';
+import * as Uri from './uri';
+import * as UUID from './uuid';
+export * from './disposable';
+export * from './eventDispatcher';
+export * from './mappedTypes';
+export * from './predicate';
+export { Async, BinaryReader, Color, EventTargets, Mapper, Objects, Range, Sets, Strings, Uri, UUID, };

package/dist/mappedTypes.d.ts

@@ -1,49 +1,49 @@
-/**
- * This file is only for mapped TypeScript types. It should NOT include
- * constants classes or methods.
- */
-/**
- * A type that recursively makes each property of `T` optional.
- *
- * @example
- * ```
- * type Foo = { a: number };
- * type Bar = { foo: Foo };
- * type Baz = DeepPartial<Bar>; // { foo?: { a?: number } }
- * ```
- */
-export declare type DeepPartial<T> = T extends Record<string, unknown> ? {
-    [K in keyof T]?: DeepPartial<T[K]>;
-} : T;
-/**
- * A type that recursively makes each property of `T` required.
- * Optionally excluding a nested path specified by a list of keys.
- *
- * @example
- * ```
- * type Foo = { a?: { c?: number }, b?: string };
- * type Bar = { foo: Foo };
- * type Baz = DeepRequired<Bar, []>; // { foo: { a: { c: number }, b: string } }
- * type Baz = DeepRequired<Bar, ['a', 'c']>; // { foo: { a: { c?: number }, b: string } }
- * type Baz = DeepRequired<Bar, ['a'] | ['b']>; // { foo: { a: { c?: number }, b?: string } }
- * ```
- */
-export declare type DeepRequired<T, P extends string[]> = T extends unknown[] ? T : T extends Record<string, unknown> ? Pick<T, Extract<keyof T, P[0]>> & Required<{
-    [K in Exclude<keyof T, P[0]>]: NonNullable<DeepRequired<T[K], ShiftUnion<K, P>>>;
-}> : T;
-declare type Shift<T extends unknown[]> = ((...t: T) => unknown) extends (first: unknown, ...rest: infer Rest) => unknown ? Rest : never;
-declare type ShiftUnion<P extends PropertyKey, T extends unknown[]> = T extends unknown[] ? (T[0] extends P ? Shift<T> : never) : never;
-/**
- * A type that extends `Required` that in addition to making fields
- * not undefined, also makes them not nullable.
- *
- * @example
- * ```
- * type Foo = { a?: number | null };
- * type Bar = RequiredAndNonNullable<Bar>; // { a: number }
- * ```
- */
-export declare type RequiredAndNonNullable<T> = Required<{
-    [P in keyof T]: NonNullable<T[P]>;
-}>;
-export {};
+/**
+ * This file is only for mapped TypeScript types. It should NOT include
+ * constants classes or methods.
+ */
+/**
+ * A type that recursively makes each property of `T` optional.
+ *
+ * @example
+ * ```
+ * type Foo = { a: number };
+ * type Bar = { foo: Foo };
+ * type Baz = DeepPartial<Bar>; // { foo?: { a?: number } }
+ * ```
+ */
+export type DeepPartial<T> = T extends Record<string, unknown> ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : T;
+/**
+ * A type that recursively makes each property of `T` required.
+ * Optionally excluding a nested path specified by a list of keys.
+ *
+ * @example
+ * ```
+ * type Foo = { a?: { c?: number }, b?: string };
+ * type Bar = { foo: Foo };
+ * type Baz = DeepRequired<Bar, []>; // { foo: { a: { c: number }, b: string } }
+ * type Baz = DeepRequired<Bar, ['a', 'c']>; // { foo: { a: { c?: number }, b: string } }
+ * type Baz = DeepRequired<Bar, ['a'] | ['b']>; // { foo: { a: { c?: number }, b?: string } }
+ * ```
+ */
+export type DeepRequired<T, P extends string[]> = T extends unknown[] ? T : T extends Record<string, unknown> ? Pick<T, Extract<keyof T, P[0]>> & Required<{
+    [K in Exclude<keyof T, P[0]>]: NonNullable<DeepRequired<T[K], ShiftUnion<K, P>>>;
+}> : T;
+type Shift<T extends unknown[]> = ((...t: T) => unknown) extends (first: unknown, ...rest: infer Rest) => unknown ? Rest : never;
+type ShiftUnion<P extends PropertyKey, T extends unknown[]> = T extends unknown[] ? (T[0] extends P ? Shift<T> : never) : never;
+/**
+ * A type that extends `Required` that in addition to making fields
+ * not undefined, also makes them not nullable.
+ *
+ * @example
+ * ```
+ * type Foo = { a?: number | null };
+ * type Bar = RequiredAndNonNullable<Bar>; // { a: number }
+ * ```
+ */
+export type RequiredAndNonNullable<T> = Required<{
+    [P in keyof T]: NonNullable<T[P]>;
+}>;
+export {};