@jgengine/core 0.11.0 → 0.13.0

package/dist/economy/unlockPoints.js

@@ -0,0 +1,103 @@
+import { evalCurve } from "../game/progression.js";
+const DEFAULT_PER_LEVEL = { kind: "const", value: 1 };
+function sanitizeAmount(value) {
+    return Number.isFinite(value) && value > 0 ? value : 0;
+}
+/**
+ * Spendable unlock-point economy — the seam between leveling and a tech tree. Points are earned
+ * per level (via a configurable, possibly non-uniform grant curve) or granted directly, then
+ * spent to unlock nodes; spending can defer prerequisite checks to an injected predicate so it
+ * composes with `economy/techTree` (or any gate) without depending on it. Individual unlocks
+ * refund, and `respec` fully refunds a build while preserving lifetime earned points. All state
+ * is plain and JSON round-trips.
+ *
+ * @capability unlock-points spendable point pool earned per level and spent to unlock nodes, with refund and respec
+ */
+export function createUnlockPoints(config = {}) {
+    const perLevel = config.perLevel ?? DEFAULT_PER_LEVEL;
+    const unlocked = new Map();
+    let earned = 0;
+    const load = (state) => {
+        unlocked.clear();
+        earned = sanitizeAmount(state.earned);
+        for (const [id, cost] of Object.entries(state.unlocked)) {
+            const paid = Number.isFinite(cost) && cost >= 0 ? cost : 0;
+            unlocked.set(id, paid);
+        }
+    };
+    if (config.state !== undefined) {
+        load(config.state);
+    }
+    else {
+        earned = sanitizeAmount(config.start ?? 0);
+    }
+    const spentTotal = () => {
+        let total = 0;
+        for (const cost of unlocked.values())
+            total += cost;
+        return total;
+    };
+    const availablePoints = () => earned - spentTotal();
+    const grantLevel = (level) => {
+        const amount = sanitizeAmount(evalCurve(perLevel, level));
+        earned += amount;
+        return amount;
+    };
+    return {
+        available: availablePoints,
+        earned: () => earned,
+        spent: spentTotal,
+        grant(amount) {
+            earned += sanitizeAmount(amount);
+        },
+        grantForLevel: grantLevel,
+        grantOnLevelUp(fromLevel, toLevel) {
+            let total = 0;
+            for (let level = fromLevel + 1; level <= toLevel; level += 1)
+                total += grantLevel(level);
+            return total;
+        },
+        canAfford(cost) {
+            return availablePoints() >= cost;
+        },
+        spend(unlockId, cost, opts) {
+            if (!Number.isFinite(cost) || cost < 0)
+                return { ok: false, reason: "invalid-cost" };
+            if (unlocked.has(unlockId))
+                return { ok: false, reason: "already-unlocked" };
+            if (opts?.requires !== undefined && !opts.requires()) {
+                return { ok: false, reason: "missing-prerequisites" };
+            }
+            if (availablePoints() < cost)
+                return { ok: false, reason: "insufficient-points" };
+            unlocked.set(unlockId, cost);
+            return { ok: true, available: availablePoints() };
+        },
+        isUnlocked(id) {
+            return unlocked.has(id);
+        },
+        costOf(id) {
+            return unlocked.get(id) ?? 0;
+        },
+        unlockedIds() {
+            return [...unlocked.keys()];
+        },
+        refund(unlockId) {
+            return unlocked.delete(unlockId);
+        },
+        respec() {
+            const refunded = spentTotal();
+            unlocked.clear();
+            return refunded;
+        },
+        snapshot() {
+            const map = {};
+            for (const [id, cost] of unlocked)
+                map[id] = cost;
+            return { earned, unlocked: map };
+        },
+        hydrate(state) {
+            load(state);
+        },
+    };
+}

package/dist/editor/commandApply.d.ts

@@ -0,0 +1,5 @@
+import type { EditorCommand, EditorSessionState } from "./commands.js";
+/** Apply a mutating editor command; returns null when the command type has no handler. @internal */
+export declare function applyMutating(state: EditorSessionState, command: EditorCommand): EditorSessionState | null;
+/** True when the command changes document structure (not select/undo/redo). @internal */
+export declare function isStructural(command: EditorCommand): boolean;