@voltro/plugin-progression 0.0.0-stage → 0.88.0

package/dist/declarationFixtures.js

@@ -0,0 +1,142 @@
+import { defaultRankDecay as e, defaultRankGrade as t, defaultRankScore as n, defaultRankSeasonReset as r, defineRankLadder as i } from "./ranks.js";
+import { grant as a } from "./reward.js";
+import { defineRankSeason as o, initialRankSeasonState as s } from "./rankSeasons.js";
+import { defaultTutorialStepPolicy as c, defineTutorial as l, initialTutorialState as u, resolveTutorialStep as d } from "./tutorial.js";
+import { defaultPassCatchUp as f, defineSeasonPass as p, passInitialState as m, resolvePassCatchUp as h } from "./pass.js";
+import { defaultQuestProgressResolver as g, defaultQuestSelector as _, defineQuestPool as v, resolveQuestProgress as y, selectQuests as b, staticQuestSource as x } from "./quests.js";
+import { levelCurve as S } from "./curve.js";
+import { defineProgression as C } from "./track.js";
+import { defaultResourceRegen as w, defineRegenResource as T, resolveResourceRegen as E } from "./resources.js";
+// src/declarationFixtures.ts
+var D = () => {
+	let e = S({
+		base: 100,
+		growth: 1.15,
+		maxLevel: 5
+	}), t = C({
+		id: "test.account",
+		xpCurve: e,
+		sources: ["match.finished"],
+		rewards: { 2: [a("test.gold", 5)] }
+	});
+	return Object.freeze({
+		curve: e,
+		track: t,
+		xpCurve: Object.freeze({
+			xp: "100",
+			curve: e
+		}),
+		rewardResolver: Object.freeze({
+			track: t,
+			fromLevel: 1,
+			toLevel: 2
+		})
+	});
+}, O = () => Object.freeze({
+	resource: T({
+		id: "test.energy",
+		max: "10",
+		regenPer: "1 second"
+	}),
+	state: Object.freeze({
+		value: "5",
+		anchorAt: 1e3
+	}),
+	at: 3e3
+}), k = () => {
+	let e = p({
+		id: "test.pass",
+		from: 0,
+		until: 2592e6,
+		tiers: 2,
+		xpPerTier: "100",
+		sources: ["test.match"],
+		tracks: {
+			free: [[a("test.gold", 1)], []],
+			premium: [[], []]
+		},
+		catchUp: {
+			xpBoostAfterDay: 20,
+			multiplier: 2
+		}
+	});
+	return Object.freeze({
+		pass: e,
+		state: m(e),
+		passCatchUp: Object.freeze({
+			pass: e,
+			amount: "100",
+			at: 1728e6
+		})
+	});
+}, A = () => {
+	let e = l({
+		steps: ["move", "shoot"],
+		skippable: !0
+	});
+	return Object.freeze({
+		tutorial: e,
+		state: u(e),
+		stepPolicy: Object.freeze({
+			tutorial: e,
+			before: u(e),
+			step: "move",
+			evidence: Object.freeze({
+				source: "test.room",
+				originId: "test.move",
+				version: "v1",
+				from: 0,
+				until: 1e3
+			}),
+			at: 1
+		})
+	});
+}, j = () => Object.freeze({
+	ladder: i({
+		id: "test.rank",
+		rating: "test.ranked",
+		tiers: ["Bronze", "Gold"],
+		divisions: 2,
+		thresholds: [
+			100,
+			200,
+			300
+		],
+		placements: 10,
+		decay: {
+			afterDays: 14,
+			perDay: 15,
+			floor: 0
+		},
+		softReset: {
+			target: 100,
+			retain: .5
+		}
+	}),
+	rating: Object.freeze({
+		pool: "test.ranked",
+		state: Object.freeze({
+			algorithm: "elo",
+			rating: 250
+		}),
+		games: 10,
+		updatedAt: 1e3
+	}),
+	at: 1e3
+}), M = () => {
+	let { ladder: e, rating: t, at: n } = j(), r = o({
+		id: "test.rank-season",
+		ladderId: e.id,
+		from: n,
+		until: n + 2592e6,
+		rewards: [[], [a("test.gold", 5)]]
+	}, e);
+	return Object.freeze({
+		ladder: e,
+		rating: t,
+		at: n,
+		season: r,
+		state: s(r)
+	});
+};
+export { f as defaultPassCatchUp, g as defaultQuestProgressResolver, _ as defaultQuestSelector, e as defaultRankDecay, t as defaultRankGrade, n as defaultRankScore, r as defaultRankSeasonReset, w as defaultResourceRegen, c as defaultTutorialStepPolicy, v as defineQuestPool, T as defineRegenResource, k as passFixture, D as progressionFixture, j as rankFixture, M as rankSeasonPolicyFixture, h as resolvePassCatchUp, y as resolveQuestProgress, E as resolveResourceRegen, d as resolveTutorialStep, O as resourceFixture, b as selectQuests, x as staticQuestSource, A as tutorialFixture };

package/dist/errors.d.ts

@@ -0,0 +1,13 @@
+import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
+
+export declare class ProgressionError extends ProgressionError_base {
+}
+
+export declare const progressionError: (code: ProgressionError["code"]) => ProgressionError;
+
+declare const ProgressionError_base: Schema.Class<ProgressionError, Schema.TaggedStruct<"ProgressionError", {
+    readonly code: Schema.Literals<readonly ["invalid_input", "invalid_record", "invalid_curve", "invalid_reward", "invalid_track", "invalid_stat", "overflow", "insufficient_resource", "forbidden", "conflict", "erased", "not_found", "limit_exceeded", "unavailable"]>;
+}>, YieldableError>;
+
+export { }

package/dist/errors.js

@@ -0,0 +1,19 @@
+import { Schema as e } from "effect";
+// src/errors.ts
+var t = class extends e.TaggedError()("ProgressionError", { code: e.Literals([
+	"invalid_input",
+	"invalid_record",
+	"invalid_curve",
+	"invalid_reward",
+	"invalid_track",
+	"invalid_stat",
+	"overflow",
+	"insufficient_resource",
+	"forbidden",
+	"conflict",
+	"erased",
+	"not_found",
+	"limit_exceeded",
+	"unavailable"
+]) }) {}, n = (e) => new t({ code: e });
+export { t as ProgressionError, n as progressionError };