use-entity 0.0.1-alpha → 0.1.0

package/src/__tests__/useEntity.test.ts

@@ -1,271 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { act, renderHook } from "@testing-library/react";
-import { createEntityStore } from "../useEntity.ts";
-
-type TestEntity = { id: string; name: string };
-
-describe("useEntity", () => {
-	test("exposes selectors for the initial state", () => {
-		const initial: TestEntity[] = [
-			{ id: "1", name: "Alpha" },
-			{ id: "2", name: "Beta" },
-		];
-		const { useEntity } = createEntityStore<TestEntity>(initial);
-
-		const { result } = renderHook(() => useEntity());
-
-		expect(result.current[0].all).toEqual(initial);
-		expect(result.current[0].ids).toEqual(["1", "2"]);
-		expect(result.current[0].byId("2")).toEqual({
-			id: "2",
-			name: "Beta",
-		});
-	});
-
-	test("supports add and remove operations", () => {
-		const { useEntity } = createEntityStore<TestEntity>();
-		const { result } = renderHook(() => useEntity());
-		const [, actions] = result.current;
-
-		act(() => {
-			actions.addOne({ id: "1", name: "Alpha" });
-			actions.addMany([
-				{ id: "2", name: "Beta" },
-				{ id: "3", name: "Gamma" },
-			]);
-		});
-
-		expect(result.current[0].all).toHaveLength(3);
-		expect([...result.current[0].ids].sort()).toEqual(["1", "2", "3"]);
-
-		act(() => {
-			actions.removeOne("2");
-			actions.removeMany(["1", "3"]);
-		});
-
-		expect(result.current[0].all).toEqual([]);
-
-		act(() => {
-			actions.addOne({ id: "4", name: "Delta" });
-			actions.removeAll();
-		});
-
-		expect(result.current[0].all).toEqual([]);
-	});
-
-	test("supports update and upsert operations", () => {
-		const { useEntity } = createEntityStore<TestEntity>([
-			{ id: "1", name: "Alpha" },
-		]);
-		const { result } = renderHook(() => useEntity());
-		const [, actions] = result.current;
-
-		act(() => {
-			actions.updateOne({ id: "1", changes: { name: "Alpha+" } });
-		});
-
-		expect(result.current[0].byId("1")).toEqual({
-			id: "1",
-			name: "Alpha+",
-		});
-
-		act(() => {
-			actions.upsertOne({ id: "2", name: "Beta" });
-			actions.updateMany([
-				{ id: "1", changes: { name: "Alpha++" } },
-				{ id: "2", changes: { name: "Beta+" } },
-			]);
-			actions.upsertMany({
-				"2": { id: "2", name: "Beta++" },
-				"3": { id: "3", name: "Gamma" },
-			});
-		});
-
-		expect(result.current[0].byId("1")).toEqual({
-			id: "1",
-			name: "Alpha++",
-		});
-		expect(result.current[0].byId("2")).toEqual({
-			id: "2",
-			name: "Beta++",
-		});
-		expect(result.current[0].byId("3")).toEqual({
-			id: "3",
-			name: "Gamma",
-		});
-	});
-
-	test("supports set operations and total/entities selectors", () => {
-		const { useEntity } = createEntityStore<TestEntity>();
-		const { result } = renderHook(() => useEntity());
-		const [, actions] = result.current;
-
-		act(() => {
-			actions.setOne({ id: "1", name: "Alpha" });
-			actions.setMany([
-				{ id: "2", name: "Beta" },
-				{ id: "3", name: "Gamma" },
-			]);
-		});
-
-		expect(result.current[0].total).toBe(3);
-		expect(result.current[0].entities).toEqual({
-			"1": { id: "1", name: "Alpha" },
-			"2": { id: "2", name: "Beta" },
-			"3": { id: "3", name: "Gamma" },
-		});
-
-		act(() => {
-			actions.setAll([{ id: "4", name: "Delta" }]);
-		});
-
-		expect(result.current[0].all).toEqual([{ id: "4", name: "Delta" }]);
-		expect(result.current[0].total).toBe(1);
-	});
-
-	test("returns undefined for missing entities", () => {
-		const { useEntity } = createEntityStore<TestEntity>();
-		const { result } = renderHook(() => useEntity());
-
-		expect(result.current[0].byId("missing")).toBeUndefined();
-	});
-
-	test("ignores remove/update of missing entities", () => {
-		const { useEntity } = createEntityStore<TestEntity>([
-			{ id: "1", name: "Alpha" },
-		]);
-		const { result } = renderHook(() => useEntity());
-		const [, actions] = result.current;
-
-		act(() => {
-			actions.removeOne("missing");
-			actions.removeMany(["missing-a", "missing-b"]);
-			actions.updateOne({ id: "missing", changes: { name: "Nope" } });
-			actions.updateMany([{ id: "missing-2", changes: { name: "Nope 2" } }]);
-		});
-
-		expect(result.current[0].all).toEqual([{ id: "1", name: "Alpha" }]);
-	});
-
-	test("keeps selectors in sync after multiple operations", () => {
-		const { useEntity } = createEntityStore<TestEntity>();
-		const { result } = renderHook(() => useEntity());
-		const [, actions] = result.current;
-
-		act(() => {
-			actions.addMany([
-				{ id: "1", name: "Alpha" },
-				{ id: "2", name: "Beta" },
-			]);
-			actions.removeOne("1");
-			actions.upsertOne({ id: "2", name: "Beta+" });
-			actions.upsertMany({
-				"3": { id: "3", name: "Gamma" },
-				"4": { id: "4", name: "Delta" },
-			});
-		});
-
-		expect([...result.current[0].ids].sort()).toEqual(["2", "3", "4"]);
-		expect(result.current[0].byId("2")).toEqual({
-			id: "2",
-			name: "Beta+",
-		});
-	});
-
-	test("selector full returns the full selector object", () => {
-		const { useEntity } = createEntityStore<TestEntity>([
-			{ id: "1", name: "Alpha" },
-			{ id: "2", name: "Beta" },
-		]);
-		const { result } = renderHook(() => useEntity("full"));
-
-		expect(result.current[0].all).toEqual([
-			{ id: "1", name: "Alpha" },
-			{ id: "2", name: "Beta" },
-		]);
-		expect(result.current[0].byId("2")).toEqual({ id: "2", name: "Beta" });
-	});
-
-	test("selector all returns array of entities", () => {
-		const { useEntity } = createEntityStore<TestEntity>([
-			{ id: "1", name: "Alpha" },
-		]);
-		const { result } = renderHook(() => useEntity("all"));
-		const [, actions] = result.current;
-
-		expect(result.current[0]).toEqual([{ id: "1", name: "Alpha" }]);
-
-		act(() => {
-			actions.addOne({ id: "2", name: "Beta" });
-		});
-
-		expect(result.current[0]).toEqual([
-			{ id: "1", name: "Alpha" },
-			{ id: "2", name: "Beta" },
-		]);
-	});
-
-	test("selector ids returns array of entity ids", () => {
-		const { useEntity } = createEntityStore<TestEntity>([
-			{ id: "1", name: "Alpha" },
-			{ id: "2", name: "Beta" },
-		]);
-		const { result } = renderHook(() => useEntity("ids"));
-		const [, actions] = result.current;
-
-		expect([...result.current[0]].sort()).toEqual(["1", "2"]);
-
-		act(() => {
-			actions.addOne({ id: "3", name: "Gamma" });
-		});
-
-		expect([...result.current[0]].sort()).toEqual(["1", "2", "3"]);
-	});
-
-	test("selector entities returns entity map", () => {
-		const { useEntity } = createEntityStore<TestEntity>([
-			{ id: "1", name: "Alpha" },
-		]);
-		const { result } = renderHook(() => useEntity("entities"));
-		const [, actions] = result.current;
-
-		expect(result.current[0]).toEqual({
-			"1": { id: "1", name: "Alpha" },
-		});
-
-		act(() => {
-			actions.addOne({ id: "2", name: "Beta" });
-		});
-
-		expect(result.current[0]).toEqual({
-			"1": { id: "1", name: "Alpha" },
-			"2": { id: "2", name: "Beta" },
-		});
-	});
-
-	test("selector total returns total entity count", () => {
-		const { useEntity } = createEntityStore<TestEntity>([
-			{ id: "1", name: "Alpha" },
-			{ id: "2", name: "Beta" },
-		]);
-		const { result } = renderHook(() => useEntity("total"));
-		const [, actions] = result.current;
-
-		expect(result.current[0]).toBe(2);
-
-		act(() => {
-			actions.removeOne("1");
-		});
-
-		expect(result.current[0]).toBe(1);
-	});
-
-	test("defaults to full selector when no selector is provided", () => {
-		const { useEntity } = createEntityStore<TestEntity>([
-			{ id: "1", name: "Alpha" },
-		]);
-		const { result } = renderHook(() => useEntity());
-
-		expect(result.current[0].all).toEqual([{ id: "1", name: "Alpha" }]);
-	});
-});

package/src/types.ts

@@ -1,48 +0,0 @@
-import type { EntityId, Update } from "@reduxjs/toolkit";
-import type { UncheckedIndexedAccess } from "./uncheckedindexed.ts";
-
-export interface EntityStateAdapter<T, Id extends EntityId> {
-	addOne(entity: T): void;
-
-	addMany(entities: readonly T[] | Record<Id, T>): void;
-
-	setOne(entity: T): void;
-
-	setMany(entities: readonly T[] | Record<Id, T>): void;
-
-	setAll(entities: readonly T[] | Record<Id, T>): void;
-
-	removeOne(key: Id): void;
-
-	removeMany(keys: readonly Id[]): void;
-
-	removeAll(): void;
-
-	updateOne(update: Update<T, Id>): void;
-
-	updateMany(updates: ReadonlyArray<Update<T, Id>>): void;
-
-	upsertOne(entity: T): void;
-
-	upsertMany(entities: readonly T[] | Record<Id, T>): void;
-}
-
-type Id<T> = {
-	[K in keyof T]: T[K];
-} & {};
-
-export interface EntitySelectors<T, IdType extends EntityId> {
-	selectIds: () => IdType[];
-	selectEntities: () => Record<IdType, T>;
-	selectAll: () => T[];
-	selectTotal: () => number;
-	selectById: (id: IdType) => Id<UncheckedIndexedAccess<T>>;
-}
-
-export interface EntitySelectorsData<T, IdType extends EntityId> {
-	ids: IdType[];
-	entities: Record<IdType, T>;
-	all: T[];
-	total: number;
-	byId: (id: IdType) => Id<UncheckedIndexedAccess<T>>;
-}

package/src/uncheckedindexed.ts

@@ -1,16 +0,0 @@
-// inlined from https://github.com/EskiMojo14/uncheckedindexed
-// relies on remaining as a TS file, not .d.ts
-type IfMaybeUndefined<T, True, False> = [undefined] extends [T] ? True : False;
-
-const testAccess = ({} as Record<string, 0>).a;
-
-export type IfUncheckedIndexedAccess<True, False> = IfMaybeUndefined<
-	typeof testAccess,
-	True,
-	False
->;
-
-export type UncheckedIndexedAccess<T> = IfUncheckedIndexedAccess<
-	T | undefined,
-	T
->;

package/src/useEntity.ts

@@ -1,128 +0,0 @@
-import {
-	createEntityAdapter,
-	type EntityAdapter,
-	type EntitySelectors,
-	type EntityState,
-} from "@reduxjs/toolkit";
-import { Store, useStore } from "@tanstack/react-store";
-import { useMemo } from "react";
-import type { EntitySelectorsData, EntityStateAdapter } from "./types.ts";
-
-const getEntityActionsTanstack = <
-	T extends {
-		id: string;
-	},
->(
-	store: Store<EntityState<T, T["id"]>>,
-	adapter: EntityAdapter<T, T["id"]>,
-): EntityStateAdapter<T, T["id"]> => ({
-	setOne: (entity) => store.setState((prev) => adapter.setOne(prev, entity)),
-	setMany: (entities) =>
-		store.setState((prev) => adapter.setMany(prev, entities)),
-	setAll: (entities) =>
-		store.setState((prev) => adapter.setAll(prev, entities)),
-
-	addOne: (entity) => store.setState((prev) => adapter.addOne(prev, entity)),
-	addMany: (entities) =>
-		store.setState((prev) => adapter.addMany(prev, entities)),
-
-	removeOne: (entityId) =>
-		store.setState((prev) => adapter.removeOne(prev, entityId)),
-	removeMany: (entityIds) =>
-		store.setState((prev) => adapter.removeMany(prev, entityIds)),
-	removeAll: () => store.setState((prev) => adapter.removeAll(prev)),
-
-	updateOne: (update) =>
-		store.setState((prev) => adapter.updateOne(prev, update)),
-	updateMany: (updates) =>
-		store.setState((prev) => adapter.updateMany(prev, updates)),
-
-	upsertOne: (entity) =>
-		store.setState((prev) => adapter.upsertOne(prev, entity)),
-	upsertMany: (entities) =>
-		store.setState((prev) => adapter.upsertMany(prev, entities)),
-});
-
-const getEntityStateTanstack = <
-	T extends {
-		id: string;
-	},
->(
-	entityState: EntityState<T, T["id"]>,
-	selectors: EntitySelectors<T, EntityState<T, T["id"]>, T["id"]>,
-): EntitySelectorsData<T, T["id"]> => ({
-	all: selectors.selectAll(entityState),
-	byId: (id) => selectors.selectById(entityState, id),
-	ids: selectors.selectIds(entityState) as T["id"][],
-	entities: selectors.selectEntities(entityState),
-	total: selectors.selectTotal(entityState),
-});
-const getSelectors = <
-	T extends {
-		id: string;
-	},
->(
-	baseSelectors: EntitySelectors<T, EntityState<T, T["id"]>, T["id"]>,
-) =>
-	({
-		all: baseSelectors.selectAll,
-		entities: baseSelectors.selectEntities,
-		ids: baseSelectors.selectIds,
-		total: baseSelectors.selectTotal,
-		full: (state) => getEntityStateTanstack(state, baseSelectors),
-	}) satisfies Record<
-		keyof Omit<EntitySelectorsData<T, T["id"]>, "byId"> | "full",
-		(state: EntityState<T, T["id"]>) => unknown
-	>;
-
-export const createEntityStore = <
-	T extends {
-		id: string;
-	},
->(
-	initialState?: T[],
-) => {
-	const adapter = createEntityAdapter<T>();
-	const store = new Store(
-		initialState
-			? adapter.setAll(adapter.getInitialState(), initialState)
-			: adapter.getInitialState(),
-	);
-	const baseSelectors = adapter.getSelectors<EntityState<T, T["id"]>>(
-		(input) => input,
-	);
-	const MySelectors = getSelectors(baseSelectors);
-
-	type SelectorKey = keyof typeof MySelectors;
-	type SelectorReturn<K extends SelectorKey> = ReturnType<
-		(typeof MySelectors)[K]
-	>;
-
-	function useEntity(): [
-		SelectorReturn<"full">,
-		EntityStateAdapter<T, T["id"]>,
-	];
-	function useEntity(
-		selector: "full",
-	): [SelectorReturn<"full">, EntityStateAdapter<T, T["id"]>];
-	function useEntity<K extends Exclude<SelectorKey, "full">>(
-		selector: K,
-	): [SelectorReturn<K>, EntityStateAdapter<T, T["id"]>];
-
-	function useEntity<K extends SelectorKey>(selector: K = "full" as K) {
-		const entityState = useStore(
-			store,
-			MySelectors[selector] as () => SelectorReturn<K>,
-		);
-		const actions = useMemo<EntityStateAdapter<T, T["id"]>>(
-			() => getEntityActionsTanstack(store, adapter),
-			[],
-		);
-		return [entityState, actions] satisfies [
-			SelectorReturn<K>,
-			EntityStateAdapter<T, T["id"]>,
-		];
-	}
-
-	return { useEntity, store, adapter };
-};

package/testing-library.ts

@@ -1,10 +0,0 @@
-import { afterEach, expect } from "bun:test";
-import * as matchers from "@testing-library/jest-dom/matchers";
-import { cleanup } from "@testing-library/react";
-
-expect.extend(matchers);
-
-// Optional: cleans up `render` after each test
-afterEach(() => {
-	cleanup();
-});

package/tsconfig.json

@@ -1,29 +0,0 @@
-{
-	"compilerOptions": {
-		// Environment setup & latest features
-		"lib": ["ESNext"],
-		"target": "ESNext",
-		"module": "Preserve",
-		"moduleDetection": "force",
-		"jsx": "react-jsx",
-		"allowJs": true,
-
-		// Bundler mode
-		"moduleResolution": "bundler",
-		"allowImportingTsExtensions": true,
-		"verbatimModuleSyntax": true,
-		"noEmit": true,
-
-		// Best practices
-		"strict": true,
-		"skipLibCheck": true,
-		"noFallthroughCasesInSwitch": true,
-		"noUncheckedIndexedAccess": true,
-		"noImplicitOverride": true,
-
-		// Some stricter flags (disabled by default)
-		"noUnusedLocals": false,
-		"noUnusedParameters": false,
-		"noPropertyAccessFromIndexSignature": false
-	}
-}