@surface/core/internal/common/object.d.ts

Provides core functionality of many @surfaces modules.

import type { ArrayPathOf, ArrayPathOfValue, Cast, Constructor, Delegate, Indexer, Intersect, Mix } from "../types/index.js";
import type MergeRules from "../types/merge-rules.js";
declare const PRIVATES: unique symbol;
export declare enum DeepMergeFlags {
    IgnoreUndefined = 1,
    ConcatArrays = 2,
    MergeArrays = 4
}
export declare function clone<T extends object>(source: T): T;
export declare function deepEqual<T>(left: T, right: T, compare?: (left: unknown, right: unknown) => boolean): boolean;
/**
 * Deeply merges two or more objects.
 * @param sources Objects to merge.
 */
export declare function deepMerge<TSources extends object[]>(sources: TSources, flags?: DeepMergeFlags): Intersect<TSources>;
export declare function freeze<T extends object>(target: T): T;
export declare function isEsm(module: unknown): module is object;
export declare function isPrimitive(value: unknown): boolean;
export declare function isReadonly(descriptor: PropertyDescriptor): boolean;
export declare function isReadonly(target: object, key: string): boolean;
export declare function getPropertyDescriptor(target: object, key: string | symbol): PropertyDescriptor | null;
export declare function getValue<T extends object, P extends ArrayPathOf<T, P>>(target: T, ...path: [P, ...P[]]): ArrayPathOfValue<T, P>;
export declare function getValue(root: object, ...path: [string, ...string[]]): unknown;
/**
 * Merges two or more objects using optional rules.
 * @param sources objects to merge
 * @param rules   rules used to control merge
 * */
export declare function hasFlags<T extends number>(value: T, flags: T): boolean;
export declare function merge<TSources extends [object, ...object[]]>(sources: TSources, rules?: MergeRules<Cast<Intersect<TSources>, object>>): Intersect<TSources>;
export declare function mix<T extends Constructor, M extends ((superClass: Constructor<any>) => Constructor)[]>(constructor: T, mixins: [...M]): T & Mix<M>;
/**
 * Create an object using the provided keys.
 * @param keys   Object keys
 * @param target If provided, all keys will inserted on target object
 */
export declare function objectFactory(keys: [string, unknown][], target?: Indexer): object;
export declare function makePath(source: object, options?: {
    keySeparator?: string;
    keyTransform?: Delegate<[string], string>;
    valueSeparator?: string;
}): string[];
export declare function privatesFrom<T extends {
    [PRIVATES]?: Indexer;
}>(target: T): Indexer;
export declare function proxyFrom<TInstances extends object[]>(...instances: TInstances): Intersect<TInstances>;
export declare function resolveError(error: unknown): Error;
export declare function setValue<T extends object, P extends ArrayPathOf<T, P>>(value: ArrayPathOfValue<T, P>, root: T, ...path: P): void;
export declare function enumerateKeys(target: object): IterableIterator<PropertyKey>;
export {};