common.ts

import {
	DRAFT_STATE,
	DRAFTABLE,
	Objectish,
	Drafted,
	AnyObject,
	AnyMap,
	AnySet,
	ImmerState,
	ArchType,
	die,
	StrictMode
} from "../internal"

export const getPrototypeOf = Object.getPrototypeOf

/** Returns true if the given value is an Immer draft */
/*#__PURE__*/
export function isDraft(value: any): boolean {
	return !!value && !!value[DRAFT_STATE]
}

/** Returns true if the given value can be drafted by Immer */
/*#__PURE__*/
export function isDraftable(value: any): boolean {
	if (!value) return false
	return (
		isPlainObject(value) ||
		Array.isArray(value) ||
		!!value[DRAFTABLE] ||
		!!value.constructor?.[DRAFTABLE] ||
		isMap(value) ||
		isSet(value)
	)
}

const objectCtorString = Object.prototype.constructor.toString()
const cachedCtorStrings = new WeakMap()
/*#__PURE__*/
export function isPlainObject(value: any): boolean {
	if (!value || typeof value !== "object") return false
	const proto = Object.getPrototypeOf(value)
	if (proto === null || proto === Object.prototype) return true

	const Ctor =
		Object.hasOwnProperty.call(proto, "constructor") && proto.constructor
	if (Ctor === Object) return true

	if (typeof Ctor !== "function") return false

	let ctorString = cachedCtorStrings.get(Ctor)
	if (ctorString === undefined) {
		ctorString = Function.toString.call(Ctor)
		cachedCtorStrings.set(Ctor, ctorString)
	}

	return ctorString === objectCtorString
}

/** Get the underlying object that is represented by the given draft */
/*#__PURE__*/
export function original<T>(value: T): T | undefined
export function original(value: Drafted<any>): any {
	if (!isDraft(value)) die(15, value)
	return value[DRAFT_STATE].base_
}

/**
 * Each iterates a map, set or array.
 * Or, if any other kind of object, all of its own properties.
 *
 * @param obj The object to iterate over
 * @param iter The iterator function
 * @param strict When true (default), includes symbols and non-enumerable properties.
 *               When false, uses looseiteration over only enumerable string properties.
 */
export function each<T extends Objectish>(
	obj: T,
	iter: (key: string | number, value: any, source: T) => void,
	strict?: boolean
): void
export function each(obj: any, iter: any, strict: boolean = true) {
	if (getArchtype(obj) === ArchType.Object) {
		// If strict, we do a full iteration including symbols and non-enumerable properties
		// Otherwise, we only iterate enumerable string properties for performance
		const keys = strict ? Reflect.ownKeys(obj) : Object.keys(obj)
		keys.forEach(key => {
			iter(key, obj[key], obj)
		})
	} else {
		obj.forEach((entry: any, index: any) => iter(index, entry, obj))
	}
}

/*#__PURE__*/
export function getArchtype(thing: any): ArchType {
	const state: undefined | ImmerState = thing[DRAFT_STATE]
	return state
		? state.type_
		: Array.isArray(thing)
		? ArchType.Array
		: isMap(thing)
		? ArchType.Map
		: isSet(thing)
		? ArchType.Set
		: ArchType.Object
}

/*#__PURE__*/
export function has(thing: any, prop: PropertyKey): boolean {
	return getArchtype(thing) === ArchType.Map
		? thing.has(prop)
		: Object.prototype.hasOwnProperty.call(thing, prop)
}

/*#__PURE__*/
export function get(thing: AnyMap | AnyObject, prop: PropertyKey): any {
	// @ts-ignore
	return getArchtype(thing) === ArchType.Map ? thing.get(prop) : thing[prop]
}

/*#__PURE__*/
export function set(thing: any, propOrOldValue: PropertyKey, value: any) {
	const t = getArchtype(thing)
	if (t === ArchType.Map) thing.set(propOrOldValue, value)
	else if (t === ArchType.Set) {
		thing.add(value)
	} else thing[propOrOldValue] = value
}

/*#__PURE__*/
export function is(x: any, y: any): boolean {
	// From: https://github.com/facebook/fbjs/blob/c69904a511b900266935168223063dd8772dfc40/packages/fbjs/src/core/shallowEqual.js
	if (x === y) {
		return x !== 0 || 1 / x === 1 / y
	} else {
		return x !== x && y !== y
	}
}

/*#__PURE__*/
export function isMap(target: any): target is AnyMap {
	return target instanceof Map
}

/*#__PURE__*/
export function isSet(target: any): target is AnySet {
	return target instanceof Set
}
/*#__PURE__*/
export function latest(state: ImmerState): any {
	return state.copy_ || state.base_
}

/*#__PURE__*/
export function shallowCopy(base: any, strict: StrictMode) {
	if (isMap(base)) {
		return new Map(base)
	}
	if (isSet(base)) {
		return new Set(base)
	}
	if (Array.isArray(base)) return Array.prototype.slice.call(base)

	const isPlain = isPlainObject(base)

	if (
		strict === true ||
		strict === "full" ||
		(strict === "class_only" && !isPlain)
	) {
		// Perform a strict copy
		const descriptors = Object.getOwnPropertyDescriptors(base)
		delete descriptors[DRAFT_STATE as any]
		let keys = Reflect.ownKeys(descriptors)
		for (let i = 0; i < keys.length; i++) {
			const key: any = keys[i]
			const desc = descriptors[key]
			if (desc.writable === false) {
				desc.writable = true
				desc.configurable = true
			}
			// like object.assign, we will read any _own_, get/set accessors. This helps in dealing
			// with libraries that trap values, like mobx or vue
			// unlike object.assign, non-enumerables will be copied as well
			if (desc.get || desc.set)
				descriptors[key] = {
					configurable: true,
					writable: true, // could live with !!desc.set as well here...
					enumerable: desc.enumerable,
					value: base[key]
				}
		}
		return Object.create(getPrototypeOf(base), descriptors)
	} else {
		// perform a sloppy copy
		const proto = getPrototypeOf(base)
		if (proto !== null && isPlain) {
			// v8 has a perf cliff at 1020 properties where it
			// switches from "fast properties" to "dictionary mode" at 1020 keys:
			// - https://github.com/v8/v8/blob/754e7ba956b06231c487e09178aab9baba1f46fe/src/objects/property-details.h#L242-L247
			// - https://github.com/v8/v8/blob/754e7ba956b06231c487e09178aab9baba1f46fe/test/mjsunit/dictionary-prototypes.js
			// At that size, object spread gets drastically slower,
			// and an `Object.keys()` loop becomes _faster_.
			// Immer currently expects that we also copy symbols.  That would require either a `Reflect.ownKeys()`,
			// or `.keys()` + `.getOwnPropertySymbols()`.
			// For v10.x, we can keep object spread the default,
			// and offer an option to switch to just strings to enable better perf
			// with larger objects. For v11, we can flip those defaults.
			if (strict === "strings_only") {
				const copy: Record<string | symbol, any> = {}
				Object.keys(base).forEach(key => {
					copy[key] = base[key]
				})
				return copy
			}

			return {...base} // assumption: better inner class optimization than the assign below
		}
		const obj = Object.create(proto)
		return Object.assign(obj, base)
	}
}

/**
 * Freezes draftable objects. Returns the original object.
 * By default freezes shallowly, but if the second argument is `true` it will freeze recursively.
 *
 * @param obj
 * @param deep
 */
export function freeze<T>(obj: T, deep?: boolean): T
export function freeze<T>(obj: any, deep: boolean = false): T {
	if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj)) return obj
	if (getArchtype(obj) > 1 /* Map or Set */) {
		Object.defineProperties(obj, {
			set: dontMutateMethodOverride,
			add: dontMutateMethodOverride,
			clear: dontMutateMethodOverride,
			delete: dontMutateMethodOverride
		})
	}
	Object.freeze(obj)
	if (deep)
		// See #590, don't recurse into non-enumerable / Symbol properties when freezing
		// So use Object.values (only string-like, enumerables) instead of each()
		Object.values(obj).forEach(value => freeze(value, true))
	return obj
}

function dontMutateFrozenCollections() {
	die(2)
}

const dontMutateMethodOverride = {
	value: dontMutateFrozenCollections
}

export function isFrozen(obj: any): boolean {
	// Fast path: primitives and null/undefined are always "frozen"
	if (obj === null || typeof obj !== "object") return true
	return Object.isFrozen(obj)
}