Byte-shave field names and arrow functions

Author: markerikson

src/core/finalize.ts

@@ -108,9 +108,8 @@ function markStateFinalized(state: ImmerState) {
 	state.scope_.unfinalizedDrafts_--
 }
 
-function isSameScope(state: ImmerState, rootScope: ImmerScope) {
-	return state.scope_ === rootScope
-}
+let isSameScope = (state: ImmerState, rootScope: ImmerScope) =>
+	state.scope_ === rootScope
 
 // A reusable empty array to avoid allocations
 const EMPTY_LOCATIONS_RESULT: (string | symbol | number)[] = []
@@ -180,7 +179,7 @@ export function registerChildFinalizationCallback(
 		}
 
 		// Handle potential set value finalization first
-		rootScope.mapSetPlugin_?.fixPotentialSetContents(state)
+		rootScope.mapSetPlugin_?.fixSetContents(state)
 
 		const finalizedValue = getFinalValue(state)
 

src/core/immerClass.ts

@@ -32,7 +32,9 @@ import {
 	AnySet,
 	isObjectish,
 	isFunction,
-	isBoolean
+	isBoolean,
+	PluginMapSet,
+	PluginPatches
 } from "../internal"
 
 interface ProducersFns {
@@ -122,7 +124,7 @@ export class Immer implements ProducersFns {
 			if (patchListener) {
 				const p: Patch[] = []
 				const ip: Patch[] = []
-				getPlugin("Patches").generateReplacementPatches_(base, result, {
+				getPlugin(PluginPatches).generateReplacementPatches_(base, result, {
 					patches_: p,
 					inversePatches_: ip
 				} as ImmerScope) // dummy scope
@@ -217,7 +219,7 @@ export class Immer implements ProducersFns {
 			patches = patches.slice(i + 1)
 		}
 
-		const applyPatchesImpl = getPlugin("Patches").applyPatches_
+		const applyPatchesImpl = getPlugin(PluginPatches).applyPatches_
 		if (isDraft(base)) {
 			// N.B: never hits if some patch a replacement, patches are never drafts
 			return applyPatchesImpl(base, patches)
@@ -239,9 +241,9 @@ export function createProxy<T extends Objectish>(
 	// returning a tuple here lets us skip a proxy access
 	// to DRAFT_STATE later
 	const [draft, state] = isMap(value)
-		? getPlugin("MapSet").proxyMap_(value, parent)
+		? getPlugin(PluginMapSet).proxyMap_(value, parent)
 		: isSet(value)
-		? getPlugin("MapSet").proxySet_(value, parent)
+		? getPlugin(PluginMapSet).proxySet_(value, parent)
 		: createProxyProxy(value, parent)
 
 	const scope = parent?.scope_ ?? getCurrentScope()
@@ -257,7 +259,7 @@ export function createProxy<T extends Objectish>(
 	} else {
 		// It's a root draft, register it with the scope
 		state.callbacks_.push(function rootDraftCleanup(rootScope) {
-			rootScope.mapSetPlugin_?.fixPotentialSetContents(state)
+			rootScope.mapSetPlugin_?.fixSetContents(state)
 
 			const {patchPlugin_} = rootScope
 

src/core/proxy.ts

@@ -18,7 +18,12 @@ import {
 	createProxy,
 	ArchType,
 	ImmerScope,
-	handleCrossReference
+	handleCrossReference,
+	WRITABLE,
+	CONFIGURABLE,
+	ENUMERABLE,
+	VALUE,
+	isArray
 } from "../internal"
 
 interface ProxyBaseState extends ImmerBaseState {
@@ -51,9 +56,9 @@ export function createProxyProxy<T extends Objectish>(
 	base: T,
 	parent?: ImmerState
 ): [Drafted<T, ProxyState>, ProxyState] {
-	const isArray = Array.isArray(base)
+	const baseIsArray = isArray(base)
 	const state: ProxyState = {
-		type_: isArray ? ArchType.Array : (ArchType.Object as any),
+		type_: baseIsArray ? ArchType.Array : (ArchType.Object as any),
 		// Track which produce call this is associated with.
 		scope_: parent ? parent.scope_ : getCurrentScope()!,
 		// True for both shallow and deep changes.
@@ -86,7 +91,7 @@ export function createProxyProxy<T extends Objectish>(
 	// Note that in the case of an array, we put the state in an array to have better Reflect defaults ootb
 	let target: T = state as any
 	let traps: ProxyHandler<object | Array<any>> = objectTraps
-	if (isArray) {
+	if (baseIsArray) {
 		target = [state] as any
 		traps = arrayTraps
 	}
@@ -201,10 +206,10 @@ export const objectTraps: ProxyHandler<ProxyState> = {
 		const desc = Reflect.getOwnPropertyDescriptor(owner, prop)
 		if (!desc) return desc
 		return {
-			writable: true,
-			configurable: state.type_ !== ArchType.Array || prop !== "length",
-			enumerable: desc.enumerable,
-			value: owner[prop]
+			[WRITABLE]: true,
+			[CONFIGURABLE]: state.type_ !== ArchType.Array || prop !== "length",
+			[ENUMERABLE]: desc[ENUMERABLE],
+			[VALUE]: owner[prop]
 		}
 	},
 	defineProperty() {
@@ -226,8 +231,9 @@ const arrayTraps: ProxyHandler<[ProxyArrayState]> = {}
 each(objectTraps, (key, fn) => {
 	// @ts-ignore
 	arrayTraps[key] = function() {
-		arguments[0] = arguments[0][0]
-		return fn.apply(this, arguments)
+		const args = arguments
+		args[0] = args[0][0]
+		return fn.apply(this, args)
 	}
 })
 arrayTraps.deleteProperty = function(state, prop) {
@@ -256,8 +262,8 @@ function peek(draft: Drafted, prop: PropertyKey) {
 function readPropFromProto(state: ImmerState, source: any, prop: PropertyKey) {
 	const desc = getDescriptorFromProto(source, prop)
 	return desc
-		? `value` in desc
-			? desc.value
+		? VALUE in desc
+			? desc[VALUE]
 			: // This is a very special case, if the prop is a getter defined by the
 			  // prototype, we should invoke it with the draft as context!
 			  desc.get?.call(state.draft_)

src/core/scope.ts

@@ -9,7 +9,9 @@ import {
 	getPlugin,
 	PatchesPlugin,
 	MapSetPlugin,
-	isPluginLoaded
+	isPluginLoaded,
+	PluginMapSet,
+	PluginPatches
 } from "../internal"
 
 /** Each scope represents a `produce` call. */
@@ -31,34 +33,32 @@ export interface ImmerScope {
 
 let currentScope: ImmerScope | undefined
 
-export function getCurrentScope() {
-	return currentScope!
-}
+export let getCurrentScope = () => currentScope!
 
-function createScope(
+let createScope = (
 	parent_: ImmerScope | undefined,
 	immer_: Immer
-): ImmerScope {
-	return {
-		drafts_: [],
-		parent_,
-		immer_,
-		// Whenever the modified draft contains a draft from another scope, we
-		// need to prevent auto-freezing so the unowned draft can be finalized.
-		canAutoFreeze_: true,
-		unfinalizedDrafts_: 0,
-		handledSet_: new Set(),
-		processedForPatches_: new Set(),
-		mapSetPlugin_: isPluginLoaded("MapSet") ? getPlugin("MapSet") : undefined
-	}
-}
+): ImmerScope => ({
+	drafts_: [],
+	parent_,
+	immer_,
+	// Whenever the modified draft contains a draft from another scope, we
+	// need to prevent auto-freezing so the unowned draft can be finalized.
+	canAutoFreeze_: true,
+	unfinalizedDrafts_: 0,
+	handledSet_: new Set(),
+	processedForPatches_: new Set(),
+	mapSetPlugin_: isPluginLoaded(PluginMapSet)
+		? getPlugin(PluginMapSet)
+		: undefined
+})
 
 export function usePatchesInScope(
 	scope: ImmerScope,
 	patchListener?: PatchListener
 ) {
 	if (patchListener) {
-		scope.patchPlugin_ = getPlugin("Patches") // assert we have the plugin
+		scope.patchPlugin_ = getPlugin(PluginPatches) // assert we have the plugin
 		scope.patches_ = []
 		scope.inversePatches_ = []
 		scope.patchListener_ = patchListener
@@ -78,9 +78,8 @@ export function leaveScope(scope: ImmerScope) {
 	}
 }
 
-export function enterScope(immer: Immer) {
-	return (currentScope = createScope(currentScope, immer))
-}
+export let enterScope = (immer: Immer) =>
+	(currentScope = createScope(currentScope, immer))
 
 function revokeDraft(draft: Drafted) {
 	const state: ImmerState = draft[DRAFT_STATE]

src/immer.ts

@@ -110,18 +110,14 @@ export const finishDraft = /* @__PURE__ */ immer.finishDraft.bind(immer)
  *
  * @param value
  */
-export function castDraft<T>(value: T): Draft<T> {
-	return value as any
-}
+export let castDraft = <T>(value: T): Draft<T> => value as any
 
 /**
  * This function is actually a no-op, but can be used to cast a mutable type
  * to an immutable type and make TypeScript happy
  * @param value
  */
-export function castImmutable<T>(value: T): Immutable<T> {
-	return value as any
-}
+export let castImmutable = <T>(value: T): Immutable<T> => value as any
 
 export {Immer}
 

src/plugins/mapset.ts

@@ -15,7 +15,8 @@ import {
 	die,
 	ArchType,
 	each,
-	getValue
+	getValue,
+	PluginMapSet
 } from "../internal"
 
 export function enableMapSet() {
@@ -312,7 +313,7 @@ export function enableMapSet() {
 		if (state.revoked_) die(3, JSON.stringify(latest(state)))
 	}
 
-	function fixPotentialSetContents(target: ImmerState) {
+	function fixSetContents(target: ImmerState) {
 		// For sets we clone before iterating, otherwise we can get in endless loop due to modifying during iteration, see #628
 		// To preserve insertion order in all cases we then clear the set
 		if (target.type_ === ArchType.Set && target.copy_) {
@@ -324,5 +325,5 @@ export function enableMapSet() {
 		}
 	}
 
-	loadPlugin("MapSet", {proxyMap_, proxySet_, fixPotentialSetContents})
+	loadPlugin(PluginMapSet, {proxyMap_, proxySet_, fixSetContents})
 }

src/plugins/patches.ts

@@ -25,7 +25,11 @@ import {
 	getProxyDraft,
 	ImmerScope,
 	isObjectish,
-	isFunction
+	isFunction,
+	CONSTRUCTOR,
+	PluginPatches,
+	isArray,
+	PROTOTYPE
 } from "../internal"
 
 export function enablePatches() {
@@ -332,10 +336,10 @@ export function enablePatches() {
 				// See #738, avoid prototype pollution
 				if (
 					(parentType === ArchType.Object || parentType === ArchType.Array) &&
-					(p === "__proto__" || p === "constructor")
+					(p === "__proto__" || p === CONSTRUCTOR)
 				)
 					die(errorOffset + 3)
-				if (isFunction(base) && p === "prototype") die(errorOffset + 3)
+				if (isFunction(base) && p === PROTOTYPE) die(errorOffset + 3)
 				base = get(base, p)
 				if (!isObjectish(base)) die(errorOffset + 2, path.join("/"))
 			}
@@ -396,7 +400,7 @@ export function enablePatches() {
 	function deepClonePatchValue<T>(obj: T): T
 	function deepClonePatchValue(obj: any) {
 		if (!isDraftable(obj)) return obj
-		if (Array.isArray(obj)) return obj.map(deepClonePatchValue)
+		if (isArray(obj)) return obj.map(deepClonePatchValue)
 		if (isMap(obj))
 			return new Map(
 				Array.from(obj.entries()).map(([k, v]) => [k, deepClonePatchValue(v)])
@@ -414,7 +418,7 @@ export function enablePatches() {
 		} else return obj
 	}
 
-	loadPlugin("Patches", {
+	loadPlugin(PluginPatches, {
 		applyPatches_,
 		generatePatches_,
 		generateReplacementPatches_,