@amazon/vinyl-util 1.0.0

package/dist/types/ts3.7/util/object/mergeDeep.d.ts

@@ -0,0 +1,153 @@
+import { TypedArray } from '../../util/collection/typedArray';
+import { ReportableError } from '../../error/ReportableError';
+import { Cloneable } from '../../core/cloneable';
+/**
+ * Concatenates multiple arrays together where each element is deeply cloned.
+ */
+export declare function mergeDeep<T extends Array<any>>(sources: readonly T[], options?: Partial<MergeOptions>): T;
+/**
+ * Deep clones the given object.
+ */
+export declare function mergeDeep<T>(sources: readonly [
+    T
+], options?: Partial<MergeOptions>): T;
+/**
+ * Deep merges the two objects.
+ * If common keys are both arrays, they will be concatenated, if common keys are both objects, they
+ * will be merged. Incompatible types, e.g. an object and an array will use the later source.
+ */
+export declare function mergeDeep<A, B>(sources: readonly [
+    A,
+    B
+], options?: Partial<MergeOptions>): A & B;
+/**
+ * Deep merges the three objects.
+ * If common keys are both arrays, they will be concatenated, if common keys are both objects, they
+ * will be merged. Incompatible types, e.g. an object and an array will use the later source.
+ */
+export declare function mergeDeep<A, B, C>(sources: readonly [
+    A,
+    B,
+    C
+], options?: Partial<MergeOptions>): A & B & C;
+/**
+ * Deep merges the four objects.
+ * If common keys are both arrays, they will be concatenated, if common keys are both objects, they
+ * will be merged. Incompatible types, e.g. an object and an array will use the later source.
+ */
+export declare function mergeDeep<A, B, C, D>(sources: readonly [
+    A,
+    B,
+    C,
+    D
+], options?: Partial<MergeOptions>): A & B & C & D;
+/**
+ * Deep merges the five objects.
+ * If common keys are both arrays, they will be concatenated, if common keys are both objects, they
+ * will be merged. Incompatible types, e.g. an object and an array will use the later source.
+ */
+export declare function mergeDeep<A, B, C, D, E>(sources: readonly [
+    A,
+    B,
+    C,
+    D,
+    E
+], options?: Partial<MergeOptions>): A & B & C & D & E;
+/**
+ * Deep merges the six objects.
+ * If common keys are both arrays, they will be concatenated, if common keys are both objects, they
+ * will be merged. Incompatible types, e.g. an object and an array will use the later source.
+ */
+export declare function mergeDeep<A, B, C, D, E, F>(sources: readonly [
+    A,
+    B,
+    C,
+    D,
+    E,
+    F
+], options?: Partial<MergeOptions>): A & B & C & D & E & F;
+/**
+ * Deep merges all objects.
+ * If common keys are both arrays, they will be concatenated, if common keys are both objects, they
+ * will be merged. Incompatible types, e.g. an object and an array will use the later source.
+ */
+export declare function mergeDeep(sources: readonly any[], options?: Partial<MergeOptions>): any;
+/**
+ * Merge options defines the behavior for {@link mergeDeep}.
+ * See the {@link defaultMergeOptions} for defaults that will be used if any merge options are
+ * omitted.
+ */
+export interface MergeOptions {
+    /**
+     * If an object does not pass any of the rules, if this is true (default) the reference will be
+     * copied. If false, a {@link MergeReferenceError} will be thrown.
+     * This only applies to objects, not functions or primitives.
+     */
+    readonly allowReferenceCopy: boolean;
+    /**
+     * The first merge rule where the second source object matches will be used.
+     * Rules are only checked for values that have a typeof value of 'object'
+     * If the first object does not pass the match, undefined will be passed to sourceA and the
+     * rule is expected to return a clone of sourceB.
+     * If no rules match, the value will be copied by reference unless `allowReferenceCopy` is
+     * false, in which case, a {@link MergeReferenceError} will be thrown.
+     */
+    readonly rules: readonly MergeRule<any>[];
+}
+/**
+ * A merge function to be provided to merge rules.
+ */
+export type MergeCallback<T = any> = (
+/**
+ * The first like object to merge, or undefined. If undefined is provided, a
+ * clone of sourceB is expected to be returned. If defined, this object is guaranteed to have
+ * passed {@link MergeRule.matches}
+ */
+sourceA: T | undefined, 
+/**
+ * The second object to merge or clone.
+ */
+sourceB: T, 
+/**
+ * The identifier to be used in error reporting.
+ */
+prop: string | number) => T;
+export interface MergeRule<T> {
+    /**
+     * Returns true if this MergeRule should be applied for the given object.
+     * @param object
+     */
+    readonly matches: (object: any) => object is T;
+    /**
+     * Merges the two sources.
+     * @param sourceA May be undefined, the first object to merge.
+     * @param sourceB The second object to merge or clone if sourceA is undefined.
+     * @param merge This callback may be used to merge or clone sub-properties.
+     */
+    readonly merge: (sourceA: T | undefined, sourceB: T, merge: MergeCallback) => T;
+}
+export declare class MergeReferenceError extends ReportableError {
+    constructor(propPath: string, source: any);
+}
+/**
+ * Cloneable objects are not expected to be mergeable, but should be cloned.
+ */
+export declare const cloneableMergeRule: MergeRule<Cloneable<any>>;
+export declare const arrayMergeRule: MergeRule<any[]>;
+export declare const plainObjectMergeRule: MergeRule<Record<any, any>>;
+export declare const regexpMergeRule: MergeRule<RegExp>;
+export declare const dateMergeRule: MergeRule<Date>;
+export declare const mapMergeRule: MergeRule<Map<any, any>>;
+export declare const setMergeRule: MergeRule<Set<any>>;
+/**
+ * Typed arrays will not concatenate by default like arrays. Typed arrays generally represent data,
+ * not configuration, and the more reasonable default is to clone, not concatenate.
+ */
+export declare const typedArrayMergeRule: MergeRule<TypedArray>;
+export declare const urlMergeRule: MergeRule<URL>;
+/**
+ * The default merge options provide rules for merging arrays, plain objects, RegExp, Date,
+ * Map, Set, and TypedArray.
+ */
+export declare const defaultMergeOptions: MergeOptions;
+//# sourceMappingURL=mergeDeep.d.ts.map

package/dist/types/ts3.7/util/object/mutableType.d.ts

@@ -0,0 +1,85 @@
+import { Fun } from '../../util/type';
+import { ReadonlyDate, ReadonlyMap, ReadonlySet } from './readonlyType';
+/**
+ * Recursively removes read only modifiers.
+ * Special core types such as read only Dates, Maps, and Sets will be converted to their writable
+ * variants.
+ */
+export type MutableDeep<T> = T extends readonly any[] ? any : T extends Fun | Blob ? T : T extends ReadonlyDate ? Date : T extends ReadonlyMap<infer K, infer V> ? MutableMapDeep<K, V> : T extends ReadonlySet<infer V> ? MutableSetDeep<V> : T extends object ? MutableObjectDeep<T> : T;
+/**
+ * Recursively marks a tuple (up to 4 in length) or an array as read only.
+ */
+export type MutableTupleOrArrayDeep<T extends readonly any[]> = T extends readonly [
+    infer V0
+] ? [
+    any
+] : T extends readonly [
+    infer V0,
+    infer V1
+] ? [
+    any,
+    any
+] : T extends readonly [
+    infer V0,
+    infer V1,
+    infer V2
+] ? [
+    any,
+    any,
+    any
+] : T extends readonly [
+    infer V0,
+    infer V1,
+    infer V2,
+    infer V3
+] ? [
+    any,
+    any,
+    any,
+    any
+] : T extends readonly [
+    infer V0,
+    infer V1,
+    infer V2,
+    infer V3,
+    infer V4
+] ? [
+    any,
+    any,
+    any,
+    any,
+    any
+] : MutableArrayDeep<T[number]>;
+/**
+ * A recursively deep mutable array. Do not use this directly, use {@link MutableDeep} instead,
+ * which works for dates, maps, sets, etc.
+ */
+export type MutableArrayDeep<T> = any[];
+/**
+ * A recursively deep mutable object. Do not use this directly, use {@link MutableDeep} instead,
+ * which works for dates, maps, sets, etc.
+ */
+export type MutableObjectDeep<T> = {
+    -readonly [P in keyof T]: any;
+};
+/**
+ * A map with mutable values.
+ */
+export type MutableMapDeep<K, V> = Map<K, any>;
+/**
+ * A Set type with mutable values.
+ */
+export type MutableSetDeep<V> = Set<any>;
+/**
+ * Removes read only modifiers from Objects, Arrays, Maps, Sets, or Dates.
+ * Other non-primitive types will retain their method signatures.
+ */
+export type Mutable<T> = T extends readonly any[] ? any[] : T extends Fun | Blob ? T : T extends ReadonlyDate ? Date : T extends ReadonlyMap<infer K, infer V> ? Map<K, V> : T extends ReadonlySet<infer V> ? Set<V> : T extends object ? MutableObject<T> : T;
+/**
+ * A mutable object. Do not use this directly, use {@link Mutable} instead,
+ * which works for dates, maps, sets, etc.
+ */
+export type MutableObject<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+//# sourceMappingURL=mutableType.d.ts.map

package/dist/types/ts3.7/util/object/object.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Returns the keys (both property names and symbols) of all own properties.
+ * Unlike `Object.keys`, this will also return non-enumerable properties.
+ * Does not return keys inherited from the object's prototype.
+ *
+ * Implementation details:
+ * If Reflect is supported, Reflect.ownKeys will be used, wrapping in a Set, otherwise
+ * Object.getOwnPropertyNames and Object.getOwnPropertySymbols will be used. This will typically
+ * be equivalent. Proxies may alter the order of keys but platforms that do not support Reflect
+ * will also typically not support Proxies.
+ *
+ * @see Reflect.ownKeys
+ * @see Object.getOwnPropertyNames
+ * @see Object.getOwnPropertySymbols
+ * @param obj
+ * @return Returns a `Set` of the own properties of the target object, including non-enumerable.
+ * The ordering will be: positive numeric indexes in order, strings in insertion order,
+ * symbols in insertion order.
+ */
+export declare function ownKeys<T>(obj: T): Set<keyof T>;
+/**
+ * Returns the prototype chain of the given object.
+ *
+ * Example:
+ * ```
+ * class A {}
+ * class B extends A {}
+ * class C extends B {}
+ * const c = new C()
+ * getPrototypeChain(c) // [c, C.prototype, B.prototype, A.prototype, Object.prototype]
+ * ```
+ * @param obj
+ */
+export declare function getPrototypeChain(obj: any): any[];
+/**
+ * Returns true if the given object represents a plain object and not a class instance.
+ */
+export declare function isPlainObject(value: any): boolean;
+/**
+ * Gets the object's value for the given key if it exists, otherwise sets [key] to
+ * `defaultValue`, returning the newly set value.
+ *
+ * @param object
+ * @param key
+ * @param defaultValue
+ */
+export declare function getOrSetProp<K extends keyof T, T extends object>(object: T, key: K, defaultValue: () => T[K]): T[K];
+/**
+ * Returns true if value is not null. Provides a type guard which can be used in filters.
+ * Example:
+ * [1, null, 2, 3, null, 4].filter(isNonNull) // type number[]
+ * @param value
+ */
+export declare function isNonNull<T>(value: T): value is NonNullable<T>;
+//# sourceMappingURL=object.d.ts.map

package/dist/types/ts3.7/util/object/readonlyType.d.ts

@@ -0,0 +1,100 @@
+import { Fun } from '../../util/type';
+/**
+ * Recursively marks Objects, Arrays, Maps, Sets, or Dates as read only.
+ * Other non-primitive types will retain their method signatures, potentially exposing mutation
+ * methods.
+ * This type does not represent an immutable value, merely a readonly variant of T.
+ */
+export type ReadonlyDeep<T> = T extends Array<any> ? any : T extends Fun ? T : T extends Date ? ReadonlyDate : T extends Map<infer K, infer V> ? ReadonlyMapDeep<K, V> : T extends Set<infer V> ? ReadonlySetDeep<any> : T extends object ? ReadonlyObjectDeep<T> : T;
+/**
+ * Recursively marks a tuple (up to 5 in length) or an array as read only.
+ */
+export type ReadonlyTupleOrArrayDeep<T extends any[]> = T extends [
+    infer V0
+] ? readonly [
+    any
+] : T extends [
+    infer V0,
+    infer V1
+] ? readonly [
+    any,
+    any
+] : T extends [
+    infer V0,
+    infer V1,
+    infer V2
+] ? readonly [
+    any,
+    any,
+    any
+] : T extends [
+    infer V0,
+    infer V1,
+    infer V2,
+    infer V3
+] ? readonly [
+    any,
+    any,
+    any,
+    any
+] : T extends [
+    infer V0,
+    infer V1,
+    infer V2,
+    infer V3,
+    infer V4
+] ? readonly [
+    any,
+    any,
+    any,
+    any,
+    any
+] : ReadonlyArrayDeep<T[number]>;
+/**
+ * A recursively deep read only array. Do not use this directly, use {@link ReadonlyDeep} instead,
+ * which works for Objects and Arrays.
+ */
+export type ReadonlyArrayDeep<E> = readonly any[];
+/**
+ * A recursively deep read only object. Do not use this directly, use {@link ReadonlyDeep} instead,
+ * which works for Objects and Arrays.
+ */
+export type ReadonlyObjectDeep<T> = {
+    readonly [P in keyof T]: any;
+};
+/**
+ * A shallow, readonly Record.
+ * Note, this differs from Record only by readonly modifiers, as such there is no compile time
+ * safety preventing a ReadonlyRecord from being assigned to a Record type.
+ */
+export type ReadonlyRecord<K extends keyof any, T> = {
+    readonly [P in K]: T;
+};
+/**
+ * A Date type with mutation functions omitted.
+ */
+export type ReadonlyDate = Readonly<Omit<Date, 'setDate' | 'setFullYear' | 'setHours' | 'setMilliseconds' | 'setMinutes' | 'setMonth' | 'setSeconds' | 'setTime' | 'setUTCDate' | 'setUTCFullYear' | 'setUTCHours' | 'setUTCMilliseconds' | 'setUTCMinutes' | 'setUTCMonth' | 'setUTCSeconds'>>;
+/**
+ * A Map type with mutation functions omitted.
+ */
+export type ReadonlyMap<K, V> = Readonly<Omit<Map<K, V>, 'clear' | 'delete' | 'set'>>;
+/**
+ * A deep, readonly map.
+ */
+export type ReadonlyMapDeep<K, V> = ReadonlyMap<K, any>;
+/**
+ * A Set type with mutation functions omitted.
+ */
+export type ReadonlySet<E> = Readonly<Omit<Set<E>, 'add' | 'clear' | 'delete'>>;
+/**
+ * A deep, readonly set.
+ */
+export type ReadonlySetDeep<E> = ReadonlySet<any>;
+/**
+ * A type alias to ReadonlyDeep that has the additional connotation that the value is constant.
+ *
+ * An immutable object may or may not be frozen, but write access should always consider to be
+ * forbidden.
+ */
+export type Immutable<T> = ReadonlyDeep<T>;
+//# sourceMappingURL=readonlyType.d.ts.map

package/dist/types/ts3.7/util/range/IntersectionRanges.d.ts

@@ -0,0 +1,37 @@
+import { Range, ReadonlyRanges, ReadonlyRangesImpl } from './Ranges';
+import { Maybe } from '../../util/type';
+export interface IntersectionRangesOptions {
+    /**
+     * If true, only recomputes ranges after a call to `invalidate`.
+     * After `invalidate()`, the ranges are recalculated on next read.
+     * Default: false
+     */
+    readonly useCache?: boolean;
+}
+/**
+ * Takes a list of ranges and computes the intersection ranges on read.
+ */
+export declare class IntersectionRanges extends ReadonlyRangesImpl {
+    private readonly options?;
+    private backingRanges;
+    private valid;
+    private _innerRanges;
+    constructor(
+    /**
+     * The ranges for which to compute the intersection.
+     */
+    innerRanges: readonly ReadonlyRanges[], options?: Maybe<IntersectionRangesOptions>);
+    get innerRanges(): readonly ReadonlyRanges[];
+    set innerRanges(value: readonly ReadonlyRanges[]);
+    get ranges(): ArrayLike<Range>;
+    /**
+     * Flags the intersection ranges as invalid.
+     * This has no effect if options.useCache is not true.
+     */
+    invalidate(): void;
+    /**
+     * Refreshes the backing ranges by computing intersection.
+     */
+    private validate;
+}
+//# sourceMappingURL=IntersectionRanges.d.ts.map

package/dist/types/ts3.7/util/range/Ranges.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Query utilities for a list of ranges.
+ * Ranges are expected to be start, end pairs where no two ranges overlap or touch.
+ * All ranges are in incremental order.
+ */
+export interface ReadonlyRanges extends Iterable<Range> {
+    /**
+     * Returns true if there are zero ranges.
+     */
+    readonly empty: boolean;
+    /**
+     * The ranges array like this reader encapsulates.
+     * Ranges are [start, end] tuples, they will always be ordered, never touch, and never overlap.
+     */
+    readonly ranges: ArrayLike<Range>;
+    /**
+     * Returns the range at the given value, or null if all ranges are outside the given tolerance.
+     * Range values are considered inclusive.
+     * That is, a ReadonlyRanges with `[0, 1]` will return `[0, 1]` for value `1`.
+     *
+     * @param value The value to compare to current ranges.
+     * @param tolerance The tolerance the value may be outside a range and still considered
+     * to be within. Default: 0
+     */
+    getRangeAt(value: number, tolerance?: number): Range | null;
+    /**
+     * Returns the range that includes the entire from-to span, within a given tolerance.
+     *
+     * Range values are considered inclusive.
+     * That is, a `ReadonlyRanges` with `[0, 2]` will return `[0, 2]` for
+     * `getRangeContaining(2, 2)` or `getRangeContaining(0, 0)`.
+     *
+     * `from` does not need to be lesser than `to`.
+     *
+     * @param from
+     * @param to
+     * @param tolerance
+     */
+    getRangeContaining(from: number, to: number, tolerance?: number): Range | null;
+    /**
+     * Returns all ranges where at least part of the range is within the given from-to span.
+     *
+     * `from` does not need to be lesser than `to`.
+     *
+     * @param from
+     * @param to
+     * @param tolerance
+     */
+    getRangesWithin(from: number, to: number, tolerance?: number): Range[];
+    [Symbol.iterator](): IterableIterator<Range>;
+}
+/**
+ * A [start, end] tuple.
+ */
+export type Range = readonly [
+    /*start*/ number,
+    /*end*/ number
+];
+export declare abstract class ReadonlyRangesImpl implements ReadonlyRanges {
+    /**
+     * An accessor to the backed ranges.
+     * Implementations must provide an ArrayLike<Range> for random-access reading.
+     * This will be called at most once per read operation.
+     */
+    abstract get ranges(): ArrayLike<Range>;
+    get empty(): boolean;
+    getRangeAt(value: number, tolerance?: number): Range | null;
+    getRangeContaining(from: number, to: number, tolerance?: number): Range | null;
+    getRangesWithin(from: number, to: number, tolerance?: number): Range[];
+    [Symbol.iterator](): IterableIterator<Range>;
+    toString(): string;
+}
+/**
+ * Creates a ReadonlyRanges view for the given array of ranges.
+ *
+ * @param value An array of ranges. The ReadonlyRanges reader does not clone
+ * this value and will access this backing array directly.
+ */
+export declare function rangesOf(value: readonly Range[]): ReadonlyRanges;
+/**
+ * A static, empty ranges representation.
+ */
+export declare const emptyRanges: ReadonlyRanges;
+/**
+ * A collection of Range start/end tuples.
+ * When ranges are added they are merged and sorted, making for fast within range checks.
+ */
+export declare class RangesImpl implements ReadonlyRanges {
+    private readonly reader;
+    readonly ranges: Range[];
+    /**
+     * @param ranges The non-normalized ranges to add.
+     * @see #add
+     */
+    constructor(ranges?: readonly Range[]);
+    get empty(): boolean;
+    /**
+     * Adds the given range to this list.
+     * If end is less than start, the range will not be added.
+     * Ranges will be merged when there is overlap or touching. Example,
+     * `add(1, 4); add(2, 5)` results in the final ranges: `[1, 5]`
+     */
+    add(start: number, end: number): void;
+    /**
+     * Removes the given range span from this list.
+     * Ranges partially intersecting will be changed to not include the start-end span.
+     * If start is after end, nothing will be removed.
+     */
+    remove(start: number, end: number): void;
+    /**
+     * Clears all ranges.
+     */
+    clear(): void;
+    getRangeAt(value: number, tolerance?: number): Range | null;
+    getRangeContaining(from: number, to: number, tolerance?: number): Range | null;
+    getRangesWithin(from: number, to: number, tolerance?: number): Range[];
+    clone(): RangesImpl;
+    [Symbol.iterator](): IterableIterator<Range>;
+    toString(): string;
+}
+/**
+ * Returns true if the two ranges intersect.
+ * Adjacent ranges (touching but not overlapping) will not be considered to intersect.
+ */
+export declare function rangeIntersects(rangeA: Range, rangeB: Range): boolean;
+//# sourceMappingURL=Ranges.d.ts.map

package/dist/types/ts3.7/util/range/UnionRanges.d.ts

@@ -0,0 +1,37 @@
+import { Range, ReadonlyRanges, ReadonlyRangesImpl } from './Ranges';
+import { Maybe } from '../../util/type';
+export interface UnionRangesOptions {
+    /**
+     * If true, only recomputes ranges after a call to `invalidate`.
+     * After `invalidate()`, the ranges are recalculated on next read.
+     * Default: false
+     */
+    readonly useCache?: boolean;
+}
+/**
+ * Takes a list of ranges and computes the union ranges on read.
+ */
+export declare class UnionRanges extends ReadonlyRangesImpl {
+    private readonly options?;
+    private readonly backingRanges;
+    private valid;
+    private _innerRanges;
+    constructor(
+    /**
+     * The ranges for which to compute the union.
+     */
+    innerRanges: readonly ReadonlyRanges[], options?: Maybe<UnionRangesOptions>);
+    get innerRanges(): readonly ReadonlyRanges[];
+    set innerRanges(value: readonly ReadonlyRanges[]);
+    get ranges(): readonly Range[];
+    /**
+     * Flags the union ranges as invalid.
+     * This has no effect if options.useCache is not true.
+     */
+    invalidate(): void;
+    /**
+     * Refreshes the backing ranges.
+     */
+    private validate;
+}
+//# sourceMappingURL=UnionRanges.d.ts.map

package/dist/types/ts3.7/util/range/timeRanges.d.ts

@@ -0,0 +1,14 @@
+import { Range, ReadonlyRanges } from './Ranges';
+/**
+ * Converts a `TimeRanges` object to an Array for utility purposes.
+ *
+ * @param timeRanges
+ */
+export declare function timeRangesToArray(timeRanges: TimeRanges): Range[];
+/**
+ * Creates a reader for a TimeRanges object for easier querying.
+ *
+ * @param timeRanges
+ */
+export declare function createTimeRangesReader(timeRanges: TimeRanges): ReadonlyRanges;
+//# sourceMappingURL=timeRanges.d.ts.map

package/dist/types/ts3.7/util/serialization/ParseError.d.ts

@@ -0,0 +1,48 @@
+export interface ParseError {
+    /**
+     * The full reason and location.
+     */
+    readonly message: string;
+    /**
+     * The reason for the error.
+     */
+    readonly reason: string;
+    /**
+     * A description of the location the error occurred.
+     */
+    readonly location: string;
+}
+export interface PrintStringPositionOptions {
+    /**
+     * The maximum number of character columns to output.
+     * The number of columns shown will be the min of this value and the number of columns
+     * at the index row.
+     * The default is 60.
+     */
+    maxColumns?: number;
+    /**
+     * The caret indicator.
+     * The caret will be printed on a second row, directly underneath the column index
+     * represents. This may more than one character, where the first character will align
+     * with the index column.
+     * The default value is '^'.
+     */
+    caret?: string;
+    /**
+     * A number between 0 and 1 representing the percentage of trailing to leading characters.
+     * 0 Indicates all trailing, 1 indicates all leading, and 0.5 indicates that the index
+     * column is as close to the middle as possible.
+     * The default value is 0.6.
+     */
+    split?: number;
+}
+/**
+ * Given a string and a position index, gets the row the index represents, displaying the
+ * surrounding characters, with a second row showing a caret indicator pointing at the index.
+ *
+ * @param str
+ * @param index The
+ * @param options Display options
+ */
+export declare function printStringPosition(str: string, index: number, options?: PrintStringPositionOptions): string;
+//# sourceMappingURL=ParseError.d.ts.map

package/dist/types/ts3.7/util/serialization/json.d.ts

@@ -0,0 +1,30 @@
+import { AnyRecord, Fun, IsAny } from '../../util/type';
+/**
+ * A representation of the conversion the toJson function will apply to make an input JSON compatible.
+ */
+export type Json<T = any> = IsAny<T> extends true ? AnyRecord : unknown extends T ? never : T extends bigint | symbol | Fun ? string : T extends {
+    toJSON(): infer R;
+} ? R : T extends boolean | number | string | null | undefined ? T : T extends Set<infer U> ? any[] : T extends readonly any[] ? any[] : {
+    [P in keyof T]: any;
+};
+/**
+ * Converts a dynamic value to a serializable value.
+ * The value must be either an object with a toJSON function, a primitive, or a plain object
+ * where all enumerable properties map to values supported by this function.
+ * Properties not enumerable will be omitted, properties not serializable will be converted
+ * to strings.
+ * - bigint -> value.toString
+ * - function -> [function <name>]
+ * - symbol -> [symbol <name>]
+ *
+ * Error instances have a special case where non-serializable errors will still have their
+ * name, message, and stack properties serialized.
+ *
+ * Note that this is not intended for use in serializing objects where all values are known;
+ * it's intended to cover the case of reporting or logging an unknown object that may or may not
+ * be serializable.
+ *
+ * @param value
+ */
+export declare function toJson<T>(value: T): Json<T>;
+//# sourceMappingURL=json.d.ts.map