atom.io 0.27.4 → 0.28.0

package/internal/src/ingest-updates/ingest-atom-update.ts

@@ -14,5 +14,5 @@ export function ingestAtomUpdate(
 	if (atomUpdate.family) {
 		Object.assign(token, { family: atomUpdate.family })
 	}
-	setIntoStore(token, value, store)
+	setIntoStore(store, token, value)
 }

package/internal/src/ingest-updates/ingest-creation-disposal.ts

@@ -22,7 +22,7 @@ export function ingestCreationEvent(
 			break
 		}
 		case `oldValue`: {
-			disposeFromStore(update.token, store)
+			disposeFromStore(store, update.token)
 			break
 		}
 	}
@@ -35,7 +35,7 @@ export function ingestDisposalEvent(
 ): void {
 	switch (applying) {
 		case `newValue`: {
-			disposeFromStore(update.token, store)
+			disposeFromStore(store, update.token)
 			break
 		}
 		case `oldValue`: {
@@ -56,9 +56,18 @@ function createInStore(token: ReadableToken<any>, store: Store): void {
 				return
 			}
 			if (store.config.lifespan === `immortal`) {
-				throw new Error(`No molecule found for key "${token.family.subKey}"`)
+				store.logger.error(
+					`🐞`,
+					`atom`,
+					token.family.key,
+					`tried to create member`,
+					`"${token.family.subKey}"`,
+					`but a molecule with that key was not found in store`,
+					`"${store.config.name}"`,
+				)
+				return
 			}
-			initFamilyMemberInStore(family, parseJson(token.family.subKey), store)
+			initFamilyMemberInStore(store, family, parseJson(token.family.subKey))
 		}
 	}
 }
@@ -79,7 +88,7 @@ export function ingestMoleculeCreationEvent(
 			)
 			break
 		case `oldValue`:
-			disposeFromStore(update.token, store)
+			disposeFromStore(store, update.token)
 			break
 	}
 }
@@ -90,7 +99,7 @@ export function ingestMoleculeDisposalEvent(
 ): void {
 	switch (applying) {
 		case `newValue`:
-			disposeFromStore(update.token, store)
+			disposeFromStore(store, update.token)
 			break
 		case `oldValue`:
 			{

package/internal/src/molecule/create-molecule-family.ts

@@ -10,8 +10,8 @@ import type { Store } from "../store"
 import { Subject } from "../subject"
 
 export function createMoleculeFamily<M extends MoleculeConstructor>(
-	options: MoleculeFamilyOptions<M>,
 	store: Store,
+	options: MoleculeFamilyOptions<M>,
 ): MoleculeFamilyToken<M> {
 	const subject = new Subject<MoleculeCreation<M>>()
 

package/internal/src/molecule/dispose-molecule.ts

@@ -15,22 +15,14 @@ export function disposeMolecule<M extends MoleculeConstructor>(
 	store: Store,
 ): void {
 	let molecule: Molecule<M>
-	try {
-		molecule = withdraw(token, store)
-	} catch (thrown) {
-		if (thrown instanceof Error) {
-			store.logger.error(
-				`🐞`,
-				`molecule`,
-				JSON.stringify(token.key),
-				`Failed to dispose molecule, because it was not found in the store.`,
-				thrown.message,
-			)
-		}
-		return
-	}
+	molecule = withdraw(token, store)
 	const { family } = token
 
+	for (const join of molecule.joins.values()) {
+		join.relations.delete(molecule.key)
+		join.molecules.delete(molecule.stringKey)
+	}
+
 	const context: MoleculeToken<any>[] = []
 	for (const above of molecule.above.values()) {
 		context.push(deposit(above))
@@ -55,7 +47,7 @@ export function disposeMolecule<M extends MoleculeConstructor>(
 			disposalEvent.family = token.family
 		}
 		for (const state of molecule.tokens.values()) {
-			disposeFromStore(state, store)
+			disposeFromStore(store, state)
 		}
 		for (const child of molecule.below.values()) {
 			if (child.family?.dependsOn === `all`) {
@@ -79,9 +71,6 @@ export function disposeMolecule<M extends MoleculeConstructor>(
 		store.molecules.delete(molecule.stringKey)
 	}
 
-	for (const join of molecule.joins.values()) {
-		join.molecules.delete(molecule.stringKey)
-	}
 	for (const parent of molecule.above.values()) {
 		parent.below.delete(molecule.stringKey)
 	}

package/internal/src/molecule/grow-molecule-in-store.ts

@@ -83,7 +83,7 @@ export function growMoleculeInStore(
 	family: ReadableFamilyToken<any, any>,
 	store: Store,
 ): ReadableToken<any> {
-	const stateToken = initFamilyMemberInStore(family, molecule.key, store)
+	const stateToken = initFamilyMemberInStore(store, family, molecule.key)
 	molecule.tokens.set(stateToken.key, stateToken)
 	const isTransaction =
 		isChildStore(store) && store.transactionMeta.phase === `building`

package/internal/src/molecule/make-molecule-in-store.ts

@@ -68,17 +68,17 @@ export function makeMoleculeInStore<M extends MoleculeConstructor>(
 
 	const toolkit = {
 		get: ((...ps: Parameters<typeof getState>) =>
-			getFromStore(...ps, newest(rootStore))) as typeof getState,
+			getFromStore(newest(rootStore), ...ps)) as typeof getState,
 		set: ((...ps: Parameters<typeof setState>) => {
-			setIntoStore(...ps, newest(rootStore))
+			setIntoStore(newest(rootStore), ...ps)
 		}) as typeof setState,
-		seek: ((t, k) => seekInStore(t, k, newest(rootStore))) as typeof seekState,
-		json: (t) => getJsonToken(t, newest(rootStore)),
+		seek: ((t, k) => seekInStore(newest(rootStore), t, k)) as typeof seekState,
+		json: (t) => getJsonToken(newest(rootStore), t),
 		run: (t, i = arbitrary()) => actUponStore(t, i, newest(store)),
 		make: (ctx, f, k, ...args) =>
 			makeMoleculeInStore(newest(rootStore), ctx, f, k, ...args),
 		dispose: (t) => {
-			disposeFromStore(t, newest(rootStore))
+			disposeFromStore(newest(rootStore), t)
 		},
 		env: () => getEnvironmentData(newest(rootStore)),
 		bond: ((

package/internal/src/mutable/create-mutable-atom-family.ts

@@ -10,8 +10,7 @@ import type {
 import type { Json } from "atom.io/json"
 import { selectJsonFamily, stringifyJson } from "atom.io/json"
 
-import type { MutableAtomFamily } from ".."
-import { throwInCaseOfConflictingFamily } from "../families/throw-in-case-of-conflicting-family"
+import { type MutableAtomFamily, prettyPrintTokenType } from ".."
 import { newest } from "../lineage"
 import { createMutableAtom } from "../mutable"
 import type { Store } from "../store"
@@ -24,8 +23,8 @@ export function createMutableAtomFamily<
 	J extends Json.Serializable,
 	K extends string,
 >(
-	options: MutableAtomFamilyOptions<T, J, K>,
 	store: Store,
+	options: MutableAtomFamilyOptions<T, J, K>,
 	internalRoles?: string[],
 ): MutableAtomFamilyToken<T, J, K> {
 	const familyToken = {
@@ -33,7 +32,17 @@ export function createMutableAtomFamily<
 		type: `mutable_atom_family`,
 	} as const satisfies MutableAtomFamilyToken<T, J, K>
 
-	throwInCaseOfConflictingFamily(familyToken, store)
+	const existing = store.families.get(options.key)
+	if (existing) {
+		store.logger.error(
+			`❗`,
+			`mutable_atom_family`,
+			options.key,
+			`Overwriting an existing ${prettyPrintTokenType(
+				existing,
+			)} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`,
+		)
+	}
 
 	const subject = new Subject<
 		StateCreation<MutableAtomToken<T, J>> | StateDisposal<MutableAtomToken<T, J>>
@@ -56,7 +65,7 @@ export function createMutableAtomFamily<
 			individualOptions.effects = options.effects(key)
 		}
 
-		const token = createMutableAtom(individualOptions, family, target)
+		const token = createMutableAtom(target, individualOptions, family)
 
 		subject.next({ type: `state_creation`, token })
 		return token
@@ -64,7 +73,7 @@ export function createMutableAtomFamily<
 
 	const atomFamily = Object.assign(familyFunction, familyToken, {
 		subject,
-		install: (s: Store) => createMutableAtomFamily(options, s),
+		install: (s: Store) => createMutableAtomFamily(s, options),
 		toJson: options.toJson,
 		fromJson: options.fromJson,
 		internalRoles,

package/internal/src/mutable/create-mutable-atom.ts

@@ -20,9 +20,9 @@ export function createMutableAtom<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
 >(
+	store: Store,
 	options: MutableAtomOptions<T, J>,
 	family: FamilyMetadata | undefined,
-	store: Store,
 ): MutableAtomToken<T, J> {
 	store.logger.info(
 		`🔨`,
@@ -52,7 +52,7 @@ export function createMutableAtom<
 				options.key,
 				`installing in store "${s.config.name}"`,
 			)
-			return createMutableAtom(options, family, s)
+			return createMutableAtom(s, options, family)
 		},
 		subject,
 	} as const
@@ -70,7 +70,7 @@ export function createMutableAtom<
 		for (const effect of options.effects) {
 			const cleanup = effect({
 				setSelf: (next) => {
-					setIntoStore(token, next, store)
+					setIntoStore(store, token, next)
 				},
 				onSet: (handle: UpdateHandler<T>) =>
 					subscribeToState(token, handle, `effect[${effectIndex}]`, store),

package/internal/src/mutable/get-json-token.ts

@@ -14,8 +14,8 @@ export const getJsonToken = <
 	Core extends Transceiver<any>,
 	SerializableCore extends Json.Serializable,
 >(
-	mutableAtomToken: MutableAtomToken<Core, SerializableCore>,
 	store: Store,
+	mutableAtomToken: MutableAtomToken<Core, SerializableCore>,
 ): WritableSelectorToken<SerializableCore> => {
 	if (mutableAtomToken.family) {
 		const target = newest(store)
@@ -29,7 +29,7 @@ export const getJsonToken = <
 		}
 		const family = withdraw(jsonFamilyToken, target)
 		const subKey = JSON.parse(mutableAtomToken.family.subKey)
-		const jsonToken = findInStore(family, subKey, store)
+		const jsonToken = findInStore(store, family, subKey)
 		return jsonToken
 	}
 	const token: WritableSelectorToken<SerializableCore> = {

package/internal/src/mutable/tracker-family.ts

@@ -29,11 +29,11 @@ export class FamilyTracker<
 			typeof this.Update | null,
 			FamilyMemberKey
 		>(
+			store,
 			{
 				key: `*${mutableAtoms.key}`,
 				default: null,
 			},
-			store,
 			[`mutable`, `updates`],
 		)
 		this.latestUpdateAtoms = withdraw(updateAtoms, store)
@@ -43,7 +43,7 @@ export class FamilyTracker<
 			(event) => {
 				if (event.token.family) {
 					const key = parseJson(event.token.family.subKey) as FamilyMemberKey
-					seekInStore(this.latestUpdateAtoms, key, store)
+					seekInStore(store, this.latestUpdateAtoms, key)
 					new Tracker<Core>(event.token, store)
 				}
 			},
@@ -53,7 +53,7 @@ export class FamilyTracker<
 			(event) => {
 				if (event.token.family) {
 					const key = parseJson(event.token.family.subKey) as FamilyMemberKey
-					const mutableAtomToken = seekInStore(this.mutableAtoms, key, store)
+					const mutableAtomToken = seekInStore(store, this.mutableAtoms, key)
 					if (mutableAtomToken) {
 						new Tracker<Core>(mutableAtomToken, store)
 					}

package/internal/src/mutable/tracker.ts

@@ -37,12 +37,12 @@ export class Tracker<Mutable extends Transceiver<any>> {
 		const latestUpdateState = createRegularAtom<
 			(Mutable extends Transceiver<infer Signal> ? Signal : never) | null
 		>(
+			store,
 			{
 				key: latestUpdateStateKey,
 				default: null,
 			},
 			familyMetaData,
-			store,
 		)
 		if (store.parent?.valueMap.has(latestUpdateStateKey)) {
 			const parentValue = store.parent.valueMap.get(latestUpdateStateKey)
@@ -62,11 +62,11 @@ export class Tracker<Mutable extends Transceiver<any>> {
 		const subscriptionKey = `tracker:${target.config.name}:${
 			isChildStore(target) ? target.transactionMeta.update.key : `main`
 		}:${mutableState.key}`
-		const originalInnerValue = getFromStore(mutableState, target)
+		const originalInnerValue = getFromStore(target, mutableState)
 		this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
 			subscriptionKey,
 			(update) => {
-				setIntoStore(latestUpdateState, update, target)
+				setIntoStore(target, latestUpdateState, update)
 			},
 		)
 		this.unsubscribeFromState = subscribeToState(
@@ -77,7 +77,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 					this.unsubscribeFromInnerValue = update.newValue.subscribe(
 						subscriptionKey,
 						(transceiverUpdate) => {
-							setIntoStore(latestUpdateState, transceiverUpdate, target)
+							setIntoStore(target, latestUpdateState, transceiverUpdate)
 						},
 					)
 				}
@@ -109,18 +109,14 @@ export class Tracker<Mutable extends Transceiver<any>> {
 							{ key: timelineId, type: `timeline` },
 							(update) => {
 								unsubscribe()
-								setIntoStore(
-									mutableState,
-									(transceiver) => {
-										if (update === `redo` && newValue) {
-											transceiver.do(newValue)
-										} else if (update === `undo` && oldValue) {
-											transceiver.undo(oldValue)
-										}
-										return transceiver
-									},
-									target,
-								)
+								setIntoStore(target, mutableState, (transceiver) => {
+									if (update === `redo` && newValue) {
+										transceiver.do(newValue)
+									} else if (update === `undo` && oldValue) {
+										transceiver.undo(oldValue)
+									}
+									return transceiver
+								})
 							},
 							subscriptionKey,
 							target,
@@ -133,15 +129,15 @@ export class Tracker<Mutable extends Transceiver<any>> {
 					subscriptionKey,
 					() => {
 						unsubscribe()
-						const mutable = getFromStore(mutableState, target)
+						const mutable = getFromStore(target, mutableState)
 						const updateNumber =
 							newValue === null ? -1 : mutable.getUpdateNumber(newValue)
 						const eventOffset = updateNumber - mutable.cacheUpdateNumber
 						if (newValue && eventOffset === 1) {
 							setIntoStore(
+								target,
 								mutableState,
 								(transceiver) => (transceiver.do(newValue), transceiver),
-								target,
 							)
 						} else {
 							target.logger.info(

package/internal/src/pretty-print.ts

@@ -18,20 +18,5 @@ export type AtomIOToken =
 	| TransactionToken<any>
 
 export function prettyPrintTokenType(token: AtomIOToken): string {
-	switch (token.type) {
-		case `atom_family`:
-			return `Atom Family`
-		case `molecule_family`:
-			return `Molecule Family`
-		case `mutable_atom_family`:
-			return `Mutable Atom Family`
-		case `readonly_selector`:
-			return `Readonly Selector`
-		case `readonly_selector_family`:
-			return `Readonly Selector Family`
-		case `selector_family`:
-			return `Selector Family`
-		default:
-			return capitalize(token.type)
-	}
+	return token.type.split(`_`).map(capitalize).join(` `)
 }

package/internal/src/selector/create-readonly-selector.ts

@@ -12,9 +12,9 @@ import { Subject } from "../subject"
 import { registerSelector } from "./register-selector"
 
 export const createReadonlySelector = <T>(
+	store: Store,
 	options: ReadonlySelectorOptions<T>,
 	family: FamilyMetadata | undefined,
-	store: Store,
 ): ReadonlySelectorToken<T> => {
 	const target = newest(store)
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
@@ -34,7 +34,7 @@ export const createReadonlySelector = <T>(
 	const readonlySelector: ReadonlySelector<T> = {
 		...options,
 		subject,
-		install: (s: Store) => createReadonlySelector(options, family, s),
+		install: (s: Store) => createReadonlySelector(s, options, family),
 		get: getSelf,
 		type: `readonly_selector`,
 		...(family && { family }),

package/internal/src/selector/create-standalone-selector.ts

@@ -10,25 +10,25 @@ import { createReadonlySelector } from "./create-readonly-selector"
 import { createWritableSelector } from "./create-writable-selector"
 
 export function createStandaloneSelector<T>(
-	options: WritableSelectorOptions<T>,
 	store: Store,
+	options: WritableSelectorOptions<T>,
 ): WritableSelectorToken<T>
 export function createStandaloneSelector<T>(
-	options: ReadonlySelectorOptions<T>,
 	store: Store,
+	options: ReadonlySelectorOptions<T>,
 ): ReadonlySelectorToken<T>
 export function createStandaloneSelector<T>(
-	options: ReadonlySelectorOptions<T> | WritableSelectorOptions<T>,
 	store: Store,
+	options: ReadonlySelectorOptions<T> | WritableSelectorOptions<T>,
 ): ReadonlySelectorToken<T> | WritableSelectorToken<T> {
 	const isWritable = `set` in options
 
 	if (isWritable) {
-		const state = createWritableSelector(options, undefined, store)
+		const state = createWritableSelector(store, options, undefined)
 		store.on.selectorCreation.next(state)
 		return state
 	}
-	const state = createReadonlySelector(options, undefined, store)
+	const state = createReadonlySelector(store, options, undefined)
 	store.on.selectorCreation.next(state)
 	return state
 }

package/internal/src/selector/create-writable-selector.ts

@@ -15,9 +15,9 @@ import { isRootStore } from "../transaction"
 import { registerSelector } from "./register-selector"
 
 export const createWritableSelector = <T>(
+	store: Store,
 	options: WritableSelectorOptions<T>,
 	family: FamilyMetadata | undefined,
-	store: Store,
 ): WritableSelectorToken<T> => {
 	const target = newest(store)
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
@@ -57,7 +57,7 @@ export const createWritableSelector = <T>(
 	const mySelector: WritableSelector<T> = {
 		...options,
 		subject,
-		install: (s: Store) => createWritableSelector(options, family, s),
+		install: (s: Store) => createWritableSelector(s, options, family),
 		get: getSelf,
 		set: setSelf,
 		type: `selector`,

package/internal/src/selector/dispose-selector.ts

@@ -9,15 +9,8 @@ export function disposeSelector(
 ): void {
 	const target = newest(store)
 	const { key } = selectorToken
-	const selector = target.selectors.get(key) ?? target.readonlySelectors.get(key)
-	if (!selector) {
-		store.logger.info(
-			`❌`,
-			`selector`,
-			key,
-			`Tried to dispose selector, but it does not exist in the store.`,
-		)
-	} else if (!selector.family) {
+	const selector = withdraw(selectorToken, target)
+	if (!selector.family) {
 		store.logger.error(
 			`❌`,
 			`selector`,

package/internal/src/selector/register-selector.ts

@@ -43,12 +43,12 @@ export const registerSelector = (
 			const [family, key] = params
 			switch (family.type) {
 				case `molecule_family`:
-					return getFromStore(family, key, store)
+					return getFromStore(store, family, key)
 				default:
 					if (store.config.lifespan === `ephemeral`) {
-						dependency = findInStore(family, key, store)
+						dependency = findInStore(store, family, key)
 					} else {
-						const maybeDependency = seekInStore(family, key, store)
+						const maybeDependency = seekInStore(store, family, key)
 						if (maybeDependency) {
 							dependency = maybeDependency
 						} else {
@@ -61,7 +61,7 @@ export const registerSelector = (
 		}
 
 		if (dependency.type === `molecule`) {
-			return getFromStore(dependency, store)
+			return getFromStore(store, dependency)
 		}
 
 		const dependencyState = withdraw(dependency, store)
@@ -108,8 +108,8 @@ export const registerSelector = (
 			value = params[2]
 			const maybeToken =
 				store.config.lifespan === `ephemeral`
-					? findInStore(family, key, store)
-					: seekInStore(family, key, store)
+					? findInStore(store, family, key)
+					: seekInStore(store, family, key)
 			if (!maybeToken) {
 				throw new NotFoundError(family, key, store)
 			}
@@ -119,7 +119,7 @@ export const registerSelector = (
 		const state = withdraw(token, target)
 		setAtomOrSelector(state, value, target)
 	}) as typeof setState,
-	find: ((token, key) => findInStore(token, key, store)) as typeof findState,
-	seek: ((token, key) => seekInStore(token, key, store)) as typeof seekState,
-	json: (token) => getJsonToken(token, store),
+	find: ((token, key) => findInStore(store, token, key)) as typeof findState,
+	seek: ((token, key) => seekInStore(store, token, key)) as typeof seekState,
+	json: (token) => getJsonToken(store, token),
 })

package/internal/src/set-state/set-into-store.ts

@@ -1,72 +1,62 @@
 import type { WritableFamilyToken, WritableToken } from "atom.io"
 import { type Canonical, stringifyJson } from "atom.io/json"
 
-import { findInStore, seekInStore } from "../families"
-import { NotFoundError } from "../not-found-error"
+import { findInStore } from "../families"
 import { closeOperation, openOperation } from "../operation"
 import type { Store } from "../store"
 import { withdraw } from "../store"
 import { setAtomOrSelector } from "./set-atom-or-selector"
 
 export function setIntoStore<T, New extends T>(
+	store: Store,
 	token: WritableToken<T>,
 	value: New | ((oldValue: T) => New),
-	store: Store,
 ): void
 
 export function setIntoStore<T, K extends Canonical, New extends T>(
+	store: Store,
 	token: WritableFamilyToken<T, K>,
 	key: K,
 	value: New | ((oldValue: T) => New),
-	store: Store,
 ): void
 
 export function setIntoStore<T, New extends T>(
+	store: Store,
 	...params:
 		| [
 				token: WritableFamilyToken<T, Canonical>,
 				key: Canonical,
 				value: New | ((oldValue: T) => New),
-				store: Store,
-		  ]
-		| [
-				token: WritableToken<T>,
-				value: New | ((oldValue: T) => New),
-				store: Store,
 		  ]
+		| [token: WritableToken<T>, value: New | ((oldValue: T) => New)]
 ): void {
 	let token: WritableToken<T>
 	let value: New | ((oldValue: T) => New)
-	let store: Store
-	if (params.length === 3) {
+	if (params.length === 2) {
 		token = params[0]
 		value = params[1]
-		store = params[2]
 	} else {
 		const family = params[0]
 		const key = params[1]
 		value = params[2]
-		store = params[3]
-		const maybeToken =
-			store.config.lifespan === `ephemeral`
-				? findInStore(family, key, store)
-				: seekInStore(family, key, store)
-		if (!maybeToken) {
-			store.logger.error(
-				`❗`,
-				family.type,
-				family.key,
-				`tried to set member`,
-				stringifyJson(key),
-				`to`,
-				value,
-				`but it was not found in store`,
-				store.config.name,
-			)
-			return
-		}
+		const maybeToken = findInStore(store, family, key)
 		token = maybeToken
 	}
+	if (`counterfeit` in token) {
+		const disposal = store.disposalTraces.buffer.find(
+			(item) => item?.key === token.key,
+		)
+		store.logger.error(
+			`❌`,
+			token.type,
+			token.key,
+			`could not be set because it was not found in the store "${store.config.name}".`,
+			disposal
+				? `This state was previously disposed:\n${disposal.trace}`
+				: `No previous disposal trace was found.`,
+		)
+		return
+	}
 
 	const rejectionTime = openOperation(token, store)
 	if (rejectionTime) {
@@ -80,7 +70,7 @@ export function setIntoStore<T, New extends T>(
 					token.key,
 					`resuming deferred setState from T-${rejectionTime}`,
 				)
-				setIntoStore(token, value, store)
+				setIntoStore(store, token, value)
 			},
 		)
 		return

package/internal/src/store/circular-buffer.ts

@@ -0,0 +1,34 @@
+export class CircularBuffer<T> {
+	protected _buffer: T[]
+	protected _index = 0
+	public constructor(array: T[])
+	public constructor(length: number)
+	public constructor(lengthOrArray: T[] | number) {
+		let length: number
+		if (typeof lengthOrArray === `number`) {
+			length = lengthOrArray
+		} else {
+			length = lengthOrArray.length
+		}
+		this._buffer = Array.from({ length })
+	}
+
+	public get buffer(): ReadonlyArray<T | undefined> {
+		return this._buffer
+	}
+
+	public get index(): number {
+		return this._index
+	}
+
+	public add(item: T): void {
+		this._buffer[this._index] = item
+		this._index = (this._index + 1) % this._buffer.length
+	}
+
+	public copy(): CircularBuffer<T> {
+		const copy = new CircularBuffer<T>([...this._buffer])
+		copy._index = this._index
+		return copy
+	}
+}