@voltro/plugin-inventory 0.0.0-stage → 0.87.0

package/dist/capture.js

@@ -0,0 +1,53 @@
+import { inventoryError as e } from "./errors.js";
+//#region src/capture.ts
+var t = (t, n) => {
+	if (!t || typeof t != "object" || Array.isArray(t)) throw e("invalid_input");
+	let r = Object.getPrototypeOf(t);
+	if (r !== Object.prototype && r !== null) throw e("invalid_input");
+	let i = Object.getOwnPropertyDescriptors(t), a = Object.create(null);
+	for (let t of Reflect.ownKeys(i)) {
+		if (typeof t != "string" || n && !n.includes(t)) throw e("invalid_input");
+		let r = i[t];
+		if (!r || !("value" in r) || !r.enumerable) throw e("invalid_input");
+		a[t] = r.value;
+	}
+	return Object.freeze(a);
+}, n = (t) => {
+	if (typeof t != "string" || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,119}$/.test(t)) throw e("invalid_input");
+	return t;
+}, r = (t, n, r) => {
+	if (typeof t != "number" || !Number.isSafeInteger(t) || Object.is(t, -0) || t < n || t > r) throw e("invalid_input");
+	return t;
+}, i = (t, n) => {
+	if (!Array.isArray(t) || t.length > n) throw e("invalid_input");
+	let r = Object.getOwnPropertyDescriptors(t);
+	if (Reflect.ownKeys(r).length !== t.length + 1) throw e("invalid_input");
+	return Object.freeze(Array.from({ length: t.length }, (t, n) => {
+		let i = r[String(n)];
+		if (!i || !("value" in i) || !i.enumerable) throw e("invalid_input");
+		return i.value;
+	}));
+}, a = (n) => {
+	let r = 0, a = 0, o = (n, s) => {
+		if (++r > 4096 || s > 16) throw e("limit_exceeded");
+		if (n === null || typeof n == "boolean") return n;
+		if (typeof n == "string") {
+			if (a += n.length * 3, a > 65536) throw e("limit_exceeded");
+			return n;
+		}
+		if (typeof n == "number") {
+			if (!Number.isFinite(n) || Object.is(n, -0)) throw e("invalid_attributes");
+			return n;
+		}
+		if (Array.isArray(n)) return Object.freeze(i(n, 4096).map((e) => o(e, s + 1)));
+		let c = t(n), l = Object.create(null);
+		for (let t of Object.keys(c).sort()) {
+			if (a += t.length * 3, a > 65536 || t.length > 120) throw e("limit_exceeded");
+			l[t] = o(c[t], s + 1);
+		}
+		return Object.freeze(l);
+	};
+	return o(n, 0);
+};
+//#endregion
+export { n as identifier, r as integer, a as jsonData, i as list, t as object };

package/dist/catalog.d.ts

@@ -0,0 +1,63 @@
+import { Context } from 'effect';
+import { Effect } from 'effect';
+import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
+
+/** Serializable content uses a declared item's version, never a stored Schema object. */
+declare interface CatalogItem {
+    readonly id: string;
+    readonly schemaVersion: number;
+    readonly kind: ItemKind;
+    readonly stackable: boolean;
+    readonly maxStack: number;
+    readonly tradable: boolean;
+    readonly rarity: string;
+    readonly tags: readonly string[];
+    readonly equipSlot: string | null;
+    readonly expiresAfter: number | null;
+    readonly display: {
+        readonly nameKey: string;
+        readonly icon: string | null;
+    };
+    readonly attributes: JsonValue;
+    readonly instanceDefaults: JsonValue;
+}
+
+export declare interface CatalogScope {
+    readonly tenantId: string;
+    readonly channel: string;
+    readonly locale: string;
+}
+
+export declare interface CatalogSnapshot {
+    readonly revision: string;
+    readonly items: readonly CatalogItem[];
+}
+
+export declare class CatalogSource extends CatalogSource_base {
+}
+
+declare const CatalogSource_base: Context.ServiceClass<CatalogSource, "@voltro/CatalogSource", CatalogSourceService>;
+
+/** Read only. Call at join/workflow boundaries, never from a room tick. */
+export declare interface CatalogSourceService {
+    readonly read: (scope: CatalogScope) => Effect.Effect<CatalogSnapshot, InventoryError>;
+}
+
+/** Public errors carry codes, never subjects, catalog values or provider causes. */
+declare class InventoryError extends InventoryError_base {
+}
+
+declare const InventoryError_base: Schema.Class<InventoryError, Schema.TaggedStruct<"InventoryError", {
+    readonly code: Schema.Literals<readonly ["invalid_input", "invalid_record", "invalid_item", "invalid_attributes", "conflict", "forbidden", "not_found", "unavailable", "limit_exceeded", "erased", "insufficient_items", "insufficient_funds", "payment_refused", "locked", "expired", "invalid_slot"]>;
+}>, YieldableError>;
+
+declare const ITEM_KINDS: readonly ["consumable", "equipment", "cosmetic", "currencyBundle", "key", "mod"];
+
+declare type ItemKind = typeof ITEM_KINDS[number];
+
+declare type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+
+export { }

package/dist/catalog.js

@@ -0,0 +1,5 @@
+import { Context as e } from "effect";
+//#region src/catalog.ts
+var t = class extends e.Service()("@voltro/CatalogSource") {};
+//#endregion
+export { t as CatalogSource };

package/dist/cmsCatalog.d.ts

@@ -0,0 +1,95 @@
+import { ContentEntities } from '@voltro/cms';
+import { ContentType } from '@voltro/cms';
+import { DataStore } from '@voltro/database';
+import { Effect } from 'effect';
+import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
+
+/** Serializable content uses a declared item's version, never a stored Schema object. */
+declare interface CatalogItem {
+    readonly id: string;
+    readonly schemaVersion: number;
+    readonly kind: ItemKind;
+    readonly stackable: boolean;
+    readonly maxStack: number;
+    readonly tradable: boolean;
+    readonly rarity: string;
+    readonly tags: readonly string[];
+    readonly equipSlot: string | null;
+    readonly expiresAfter: number | null;
+    readonly display: {
+        readonly nameKey: string;
+        readonly icon: string | null;
+    };
+    readonly attributes: JsonValue;
+    readonly instanceDefaults: JsonValue;
+}
+
+declare interface CatalogScope {
+    readonly tenantId: string;
+    readonly channel: string;
+    readonly locale: string;
+}
+
+declare interface CatalogSnapshot {
+    readonly revision: string;
+    readonly items: readonly CatalogItem[];
+}
+
+/** Read only. Call at join/workflow boundaries, never from a room tick. */
+declare interface CatalogSourceService {
+    readonly read: (scope: CatalogScope) => Effect.Effect<CatalogSnapshot, InventoryError>;
+}
+
+export declare interface CmsCatalogOptions {
+    readonly items: readonly ItemDefinition[];
+    readonly site: string;
+    /** Explicit channel-to-CMS-environment binding. No guessed live/staging environment. */
+    readonly environments: Readonly<Record<string, string>>;
+    readonly maxCatalogItems?: number;
+}
+
+export declare const cmsCatalogSource: (store: DataStore, input: CmsCatalogOptions) => CatalogSourceService;
+
+/** Public errors carry codes, never subjects, catalog values or provider causes. */
+declare class InventoryError extends InventoryError_base {
+}
+
+declare const InventoryError_base: Schema.Class<InventoryError, Schema.TaggedStruct<"InventoryError", {
+    readonly code: Schema.Literals<readonly ["invalid_input", "invalid_record", "invalid_item", "invalid_attributes", "conflict", "forbidden", "not_found", "unavailable", "limit_exceeded", "erased", "insufficient_items", "insufficient_funds", "payment_refused", "locked", "expired", "invalid_slot"]>;
+}>, YieldableError>;
+
+export declare const inventoryItemContentTables: ContentEntities;
+
+/** CMS owns drafts, releases and immutable revisions. Gameplay only reads published rows. */
+export declare const inventoryItemContentType: ContentType;
+
+declare const ITEM_KINDS: readonly ["consumable", "equipment", "cosmetic", "currencyBundle", "key", "mod"];
+
+declare interface ItemDefinition {
+    readonly id: string;
+    readonly kind: ItemKind;
+    readonly schemaVersion?: number;
+    readonly stackable: boolean;
+    readonly maxStack: number;
+    readonly tradable: boolean;
+    readonly rarity: string;
+    readonly tags: readonly string[];
+    readonly attributes: Schema.Top;
+    readonly instanceAttributes: Schema.Top;
+    readonly equipSlot?: string | null;
+    /** Milliseconds; resolved on grant, never by a tick. */
+    readonly expiresAfter?: number | null;
+    readonly display: {
+        readonly nameKey: string;
+        readonly icon?: string | null;
+    };
+}
+
+declare type ItemKind = typeof ITEM_KINDS[number];
+
+declare type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+
+export { }

package/dist/cmsCatalog.js

@@ -0,0 +1,80 @@
+import { InventoryError as e, inventoryError as t } from "./errors.js";
+import { integer as n, object as r } from "./capture.js";
+import { captureCatalogItem as i, captureItemContracts as a } from "./item.js";
+import { catalogScope as o, inventoryHash as s, inventoryIo as c } from "./sqlCatalog.js";
+import { Effect as l } from "effect";
+import { Schema as u, cmsContext as d, contentTypeToEntities as f, defineContentType as p } from "@voltro/cms";
+//#region src/cmsCatalog.ts
+var m = p({
+	name: "item",
+	displayName: "Game item",
+	pluralName: "Game items",
+	fields: {
+		itemId: u.String.pipe(u.maxLength(120), u.pattern(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,119}$/), u.unique()),
+		schemaVersion: u.Number,
+		definitionJson: u.String.pipe(u.maxLength(65536))
+	},
+	list: {
+		columns: ["itemId", "schemaVersion"],
+		defaultSort: {
+			field: "itemId",
+			dir: "asc"
+		}
+	}
+}), h = f(m), g = (u, f) => {
+	let p = r(f, [
+		"items",
+		"site",
+		"environments",
+		"maxCatalogItems"
+	]), h = a(p.items), g = r(p.environments), _ = p.site, v = n(p.maxCatalogItems ?? 1e4, 1, 1e4), y = (e) => {
+		if (typeof e != "string" || e.length < 1 || e.length > 64 || !/^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(e)) throw t("invalid_input");
+		return e;
+	}, b = y(_), x = Object.freeze(Object.fromEntries(Object.entries(g).map(([e, t]) => [o({
+		tenantId: "validation",
+		channel: e,
+		locale: "en"
+	}).channel, y(t)])));
+	if (Object.keys(x).length < 1 || Object.keys(x).length > 32) throw t("invalid_input");
+	return Object.freeze({ read: (n) => {
+		try {
+			let e = o(n), r = x[e.channel];
+			if (r === void 0) throw t("not_found");
+			let a = Object.freeze({
+				site: b,
+				environment: r,
+				locale: y(e.locale)
+			});
+			return c(async () => {
+				let n = await d(u, [m], { scope: a }).contentType("item").where("tenantId", "=", e.tenantId).orderBy("itemId", "asc").limit(v + 1).all();
+				if (n.length > v) throw t("limit_exceeded");
+				let o = Object.freeze(n.map((n) => {
+					if (n.tenantId !== e.tenantId || n.site !== b || n.environment !== r || n.locale !== e.locale || n.status !== "published" || typeof n.definitionJson != "string" || n.definitionJson.length > 65536) throw t("invalid_record");
+					let a;
+					try {
+						a = JSON.parse(n.definitionJson);
+					} catch {
+						throw t("invalid_record");
+					}
+					let o = i(a, h);
+					if (o.id !== n.itemId || o.schemaVersion !== n.schemaVersion) throw t("invalid_record");
+					return o;
+				}).sort((e, t) => e.id < t.id ? -1 : +(e.id > t.id)));
+				if (new Set(o.map((e) => e.id)).size !== o.length) throw t("conflict");
+				return Object.freeze({
+					revision: s({
+						site: b,
+						environment: r,
+						locale: e.locale,
+						items: o
+					}),
+					items: o
+				});
+			});
+		} catch (n) {
+			return l.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	} });
+};
+//#endregion
+export { g as cmsCatalogSource, h as inventoryItemContentTables, m as inventoryItemContentType };

package/dist/components.d.ts

@@ -0,0 +1,247 @@
+import { ReactNode } from 'react';
+import { Schema } from 'effect';
+
+/** Detached wire admission; no author Schema, storage, URL resolver or policy runs here. */
+export declare const captureInventoryPresentation: (instances: unknown, snapshot: unknown, equipped: unknown, at: number) => InventoryPresentation;
+
+/** Serializable content uses a declared item's version, never a stored Schema object. */
+declare interface CatalogItem {
+    readonly id: string;
+    readonly schemaVersion: number;
+    readonly kind: ItemKind;
+    readonly stackable: boolean;
+    readonly maxStack: number;
+    readonly tradable: boolean;
+    readonly rarity: string;
+    readonly tags: readonly string[];
+    readonly equipSlot: string | null;
+    readonly expiresAfter: number | null;
+    readonly display: {
+        readonly nameKey: string;
+        readonly icon: string | null;
+    };
+    readonly attributes: JsonValue;
+    readonly instanceDefaults: JsonValue;
+}
+
+declare interface CatalogSnapshot {
+    readonly revision: string;
+    readonly items: readonly CatalogItem[];
+}
+
+declare const CatalogSnapshotSchema: Schema.Struct<{
+    readonly revision: Schema.String;
+    readonly items: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly schemaVersion: Schema.Number;
+        readonly kind: Schema.Literals<readonly ["consumable", "equipment", "cosmetic", "currencyBundle", "key", "mod"]>;
+        readonly stackable: Schema.Boolean;
+        readonly maxStack: Schema.Number;
+        readonly tradable: Schema.Boolean;
+        readonly rarity: Schema.String;
+        readonly tags: Schema.$Array<Schema.String>;
+        readonly equipSlot: Schema.NullOr<Schema.String>;
+        readonly expiresAfter: Schema.NullOr<Schema.Number>;
+        readonly display: Schema.Struct<{
+            readonly nameKey: Schema.String;
+            readonly icon: Schema.NullOr<Schema.String>;
+        }>;
+        readonly attributes: Schema.Unknown;
+        readonly instanceDefaults: Schema.Unknown;
+    }>>;
+}>;
+
+declare type CopyProps = {
+    readonly locale?: 'en' | 'de' | undefined;
+    readonly copy?: InventoryUiCopy | undefined;
+};
+
+/** Read-only default; an app may supply its own authorized intention control. No craft RPC is invented. */
+export declare const CraftingPanel: (props: CraftingPanelProps) => ReactNode;
+
+export declare interface CraftingPanelProps extends CopyProps {
+    readonly view: InventoryPresentation;
+    readonly recipes: readonly Recipe[];
+    readonly at: number;
+    readonly title: (itemId: string) => string;
+    readonly currencyLabel?: ((currency: string) => string) | undefined;
+    readonly renderAction?: ((recipe: Recipe, batches: number, materialsAvailable: boolean) => ReactNode) | undefined;
+}
+
+export declare const inventoryCanEquip: (item: InventoryDisplayItem, slot: string) => boolean;
+
+export declare interface InventoryDisplayItem {
+    readonly instance: InventoryInstance;
+    readonly content: CatalogItem | undefined;
+    readonly equipped: boolean;
+    readonly expired: boolean;
+}
+
+declare interface InventoryEquip {
+    readonly slotSet: string;
+    readonly slot: string;
+    readonly instanceId: string | null;
+    readonly requestId: string;
+}
+
+/** Fixed-height rows, overscan and a retained focused row. All-items mode is available for traversal. */
+export declare const InventoryGrid: (props: InventoryGridProps) => ReactNode;
+
+export declare interface InventoryGridProps extends CopyProps, ItemContentProps {
+    readonly source: InventoryObservation<readonly (typeof InventoryInstanceSchema.Type)[]>;
+    readonly catalog: InventoryObservation<typeof CatalogSnapshotSchema.Type>;
+    readonly at: number;
+    readonly onSelect?: ItemCardProps['onSelect'];
+    readonly busy?: boolean | undefined;
+}
+
+declare interface InventoryInstance {
+    readonly id: string;
+    readonly itemId: string;
+    readonly schemaVersion: number;
+    readonly qty: number;
+    readonly attributes: JsonValue;
+    readonly acquiredAt: number;
+    readonly expiresAt: number | null;
+    readonly locked: boolean;
+    readonly source: string;
+}
+
+declare const InventoryInstanceSchema: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly itemId: Schema.String;
+    readonly schemaVersion: Schema.Number;
+    readonly qty: Schema.Number;
+    readonly attributes: Schema.Unknown;
+    readonly acquiredAt: Schema.Number;
+    readonly expiresAt: Schema.NullOr<Schema.Number>;
+    readonly locked: Schema.Boolean;
+    readonly source: Schema.String;
+}>;
+
+declare interface InventoryLoadout {
+    readonly slotSet: string;
+    readonly slot: string;
+    readonly instanceId: string;
+}
+
+export declare interface InventoryObservation<A> {
+    readonly data: A | undefined;
+    readonly loading: boolean;
+    readonly error: unknown;
+}
+
+export declare interface InventoryPresentation {
+    readonly items: readonly InventoryDisplayItem[];
+    readonly loadout: readonly InventoryLoadout[];
+    readonly catalog: CatalogSnapshot;
+}
+
+/** Calls the actual conserved selection rule; materials do not prove wallet affordability. */
+export declare const inventoryRecipePreview: (view: InventoryPresentation, original: Recipe, batches: number, at: number) => RecipePreview;
+
+export declare interface InventoryUiCopy {
+    readonly inventory: string;
+    readonly loading: string;
+    readonly unavailable: string;
+    readonly empty: string;
+    readonly noMatches: string;
+    readonly search: string;
+    readonly tag: string;
+    readonly allTags: string;
+    readonly showAll: string;
+    readonly virtualize: string;
+    readonly equipped: string;
+    readonly locked: string;
+    readonly expired: string;
+    readonly unknown: string;
+    readonly select: string;
+    readonly loadout: string;
+    readonly unequipped: string;
+    readonly recipes: string;
+    readonly batches: string;
+    readonly materials: string;
+    readonly materialsReady: string;
+    readonly materialsMissing: string;
+    readonly currencyCost: string;
+    readonly freeCost: string;
+    readonly serverCraft: string;
+    readonly count: (shown: number, total: number) => string;
+    readonly quantity: (amount: number) => string;
+}
+
+export declare const inventoryUiCopy: Readonly<Readonly<Record<"en" | "de", InventoryUiCopy>>>;
+
+declare const ITEM_KINDS: readonly ["consumable", "equipment", "cosmetic", "currencyBundle", "key", "mod"];
+
+/** The grid supplies an admitted detached view. Icons resolve only in the app-owned slot. */
+export declare const ItemCard: (props: ItemCardProps) => ReactNode;
+
+export declare interface ItemCardProps extends CopyProps, ItemContentProps {
+    readonly item: InventoryDisplayItem;
+    readonly onSelect?: ((instanceId: string) => void) | undefined;
+    readonly busy?: boolean | undefined;
+}
+
+declare type ItemContentProps = {
+    readonly title: (key: string) => string;
+    readonly renderIcon?: ((item: InventoryDisplayItem) => ReactNode) | undefined;
+};
+
+declare type ItemKind = typeof ITEM_KINDS[number];
+
+declare type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+
+/** Controlled by the server observation; never patches local item/loadout values. */
+export declare const LoadoutEditor: (props: LoadoutEditorProps) => ReactNode;
+
+export declare interface LoadoutEditorProps extends CopyProps, ItemContentProps {
+    readonly source: InventoryObservation<readonly (typeof InventoryInstanceSchema.Type)[]>;
+    readonly catalog: InventoryObservation<typeof CatalogSnapshotSchema.Type>;
+    readonly loadout: InventoryObservation<readonly InventoryLoadout[]>;
+    readonly slotSet: string;
+    readonly slots: readonly string[];
+    readonly at: number;
+    readonly busy: boolean;
+    readonly requestId: () => string;
+    readonly onEquip: (intention: InventoryEquip) => void;
+}
+
+declare interface Recipe {
+    readonly id: string;
+    readonly version: number;
+    readonly inputs: readonly RecipeIngredient[];
+    readonly outputs: readonly RecipeOutput[];
+    readonly maxBatches: number;
+    readonly cost: RecipeCurrencyCost | null;
+    readonly timeMs: 0;
+    readonly requires: null;
+}
+
+declare interface RecipeCurrencyCost {
+    readonly currency: string;
+    readonly amount: string;
+}
+
+declare interface RecipeIngredient {
+    readonly itemId: string;
+    readonly qty: number;
+}
+
+declare interface RecipeOutput extends RecipeIngredient {
+    readonly attributes?: JsonValue;
+}
+
+export declare interface RecipePreview {
+    readonly recipe: Recipe;
+    readonly batches: number;
+    readonly materialsAvailable: boolean;
+    readonly currencyCost: {
+        readonly currency: string;
+        readonly amount: string;
+    } | null;
+}
+
+export { }