xchess/lib/state-counter.js

Chess Engine

export {StateCounter}

import {IS_EMPTY, IS_ITERABLE} from './types.js'
import {INVALID_STATE_COUNT, INVALID_STATE_COUNTER} from './errors.js'

function VALIDATE_COUNT(value){
	if(!Number.isSafeInteger(value))
		throw INVALID_STATE_COUNT(value);
}

class StateCounter {

	#stat = new Map();

	constructor(iterator = []){
		for(const value of iterator)
			this.add(value);
	}

	#set(value, count){
		this.#stat.set(value, count);
		return count;
	}

	#setAll(values){
		const stat = new Map();
		for(const [state, count] of values){
			VALIDATE_COUNT(count);
			stat.set(state, count);
		}	this.#stat = stat;
	}

	setAll(values){
		const stat = new Map();
		if(IS_EMPTY(values))
			this.clear();
		else if(IS_ITERABLE(values))
			this.#setAll(values);
		else throw INVALID_STATE_COUNTER(values);
	}

	set(value, count){
		VALIDATE_COUNT(count);
		this.#set(value, count);
	}

	add(value){
		const count = this.count(value);
		if(count > 0)
			return this.#set(value, count + 1);
		return this.#set(value, 1);
	}

	delete(value){
		const count = this.count(value);
		if(count > 1){
			return this.#set(value, count - 1);
		} else {
			this.#stat.delete(value);
			return 0;
		}
	}

	has(value){
		return this.#stat.has(value);
	}

	count(value){
		return this.#stat.get(value) ?? 0;
	}

	clear(){
		this.#stat.clear();
		return this;
	}

	get size(){
		return this.#stat.size;
	}

	entries(){
		return this.#stat.entries();
	}

	keys(){
		return this.#stat.keys();
	}

	values(){
		return this.#stat.values();
	}

	[Symbol.iterator](){
		return this.entries();
	}
}