modwright 0.1.0

package/dist/surfaces/nivalisnights/index/queries.js

@@ -0,0 +1,231 @@
+import { isBuilt, SKIPPED_FOLDERS } from "./build.js";
+const DEFAULT_LIMIT = 50;
+function str(v) {
+    if (v === undefined)
+        return undefined;
+    const s = String(v).trim();
+    return s.length > 0 ? s : undefined;
+}
+function limitOf(params) {
+    const n = Number(params.limit);
+    return Number.isFinite(n) && n > 0 ? Math.floor(n) : DEFAULT_LIMIT;
+}
+function likeEscape(text) {
+    return text.replace(/[\\%_]/g, (c) => `\\${c}`);
+}
+export function queryKinds() {
+    return [
+        { kind: "folders", description: "What the index holds: definitions per folder and script class, plus the folders deliberately not decoded and why.", params: [] },
+        { kind: "item", description: "An ItemType (ingredients, meals, furniture, fish, plants, rods: one class, told apart by flags) by exact `name`, `contains` substring or `guid`: price, stock range, flags, tags.", params: ["name", "contains", "guid", "limit"] },
+        { kind: "recipe", description: "A meal recipe by `name`, `contains` or `guid`, or every recipe whose `output` is an item name, or that `uses` an item name as an input: output and inputs resolved to item names.", params: ["name", "contains", "guid", "output", "uses", "limit"] },
+        { kind: "person", description: "An NPC (Person) by `name`, `contains` or `guid`: home scene, demographic group, hireable, vendor, Articy names.", params: ["name", "contains", "guid", "limit"] },
+        { kind: "definition", description: "Any indexed definition, optionally narrowed to a `folder` (itemtypes, recipes, vendors, locations, venues, objecttags, apartments, greenhouses, processors, achievementseries, variables, actions, worldobjs, sosingletons, people, people-links) or `script` class, by `name`, `contains` or `guid`; the whole decoded record comes back.", params: ["folder", "script", "name", "contains", "guid", "limit"] },
+        { kind: "guid", description: "Whatever definition carries a GUID (the key saves and mods use), whole record.", params: ["guid"] },
+        { kind: "references", description: "What references a definition, given its `guid`, or its `name` (optionally with `folder`): each referencing definition and the field that points at it.", params: ["guid", "name", "folder", "limit"] },
+    ];
+}
+function toDef(r) {
+    return {
+        key: String(r.key),
+        folder: String(r.folder),
+        path: String(r.path),
+        script: String(r.script),
+        name: r.name === null || r.name === undefined ? null : String(r.name),
+        guid: r.guid === null || r.guid === undefined ? null : String(r.guid),
+        data: JSON.parse(String(r.data_json)),
+    };
+}
+const DEF_COLUMNS = "key, folder, path, script, name, guid, data_json";
+function findDefs(store, params, filters, limit) {
+    const where = [];
+    const args = [];
+    if (filters.folder) {
+        where.push("folder = ?");
+        args.push(filters.folder);
+    }
+    if (filters.script) {
+        where.push("script = ?");
+        args.push(filters.script);
+    }
+    const name = str(params.name);
+    const contains = str(params.contains);
+    const guid = str(params.guid);
+    let what = "every definition";
+    if (guid) {
+        where.push("guid = ? COLLATE NOCASE");
+        args.push(guid);
+        what = `guid ${guid}`;
+    }
+    else if (name) {
+        where.push("name = ? COLLATE NOCASE");
+        args.push(name);
+        what = `named "${name}" (exact, case-insensitive)`;
+    }
+    else if (contains) {
+        where.push("name LIKE ? ESCAPE '\\'");
+        args.push(`%${likeEscape(contains)}%`);
+        what = `whose name contains "${contains}"`;
+    }
+    const rows = store.all(`SELECT ${DEF_COLUMNS} FROM definition${where.length ? ` WHERE ${where.join(" AND ")}` : ""} ORDER BY name, key LIMIT ?`, [...args, limit + 1]);
+    return { defs: rows.slice(0, limit).map(toDef), truncated: rows.length > limit, what };
+}
+function refName(v) {
+    if (!v || typeof v !== "object")
+        return null;
+    const r = v;
+    return r.name ?? (r.$ref ? `(${r.$ref})` : null);
+}
+function num(v) {
+    return typeof v === "number" ? v : undefined;
+}
+function flag(v) {
+    return v === 1 || v === true;
+}
+function itemSummary(d) {
+    const x = d.data;
+    const flags = ["isIngredient", "isFurniture", "isFish", "_isPlant", "_isFarmingModule", "_isFishingRod", "isUseable", "isEquippable", "_isCamera", "isPlayerStorable", "requiresRefrigeration"]
+        .filter((k) => flag(x[k]))
+        .map((k) => k.replace(/^_/, ""));
+    return {
+        name: d.name,
+        guid: d.guid,
+        script: d.script,
+        path: d.path,
+        basePrice: num(x.basePrice),
+        stockPerVendor: [num(x.minStockPerVendor), num(x.maxStockPerVendor)],
+        allowBuying: flag(x.allowBuying),
+        allowSelling: flag(x.allowSelling),
+        decayTimeInDays: num(x.decayTimeInDays),
+        flags,
+        tags: Array.isArray(x.tags) ? x.tags.map(refName).filter((t) => t !== null) : [],
+        locObjGuid: x.locObjRef?.locObjGuid,
+    };
+}
+function recipeSummary(d) {
+    const x = d.data;
+    const output = x.output;
+    const inputs = Array.isArray(x.inputsNew) ? x.inputsNew : [];
+    return {
+        name: d.name,
+        guid: d.guid,
+        path: d.path,
+        disabled: flag(x.disabled),
+        recipeType: num(x.recipeType),
+        output: { item: refName(output?.type), amount: num(output?.amount) },
+        inputs: inputs.map((i) => ({
+            item: refName(i.DefaultItem),
+            slot: num(i.Slot),
+            processingType: num(i.ProcessingType),
+            allowedTags: Array.isArray(i.AllowedTags) ? i.AllowedTags.map(refName).filter((t) => t !== null) : [],
+        })),
+        unlockCost: num(x.unlockCost),
+        playerOnly: flag(x.playerOnly),
+    };
+}
+function personSummary(d) {
+    const x = d.data;
+    return {
+        name: d.name,
+        guid: d.guid,
+        homeScene: x.homeScene?.scenePath,
+        demographicGroup: refName(x.demographicGroup),
+        vendor: refName(x.vendorDefinition),
+        hireable: flag(x.IsHireable),
+        questHireable: flag(x.QuestHireable),
+        staffBot: flag(x.staffBot),
+        hasStory: flag(x.hasStory),
+        articyTechnicalName: typeof x.articyTechnicalName === "string" && x.articyTechnicalName ? x.articyTechnicalName : undefined,
+        articyVariableName: typeof x.articyVariableName === "string" && x.articyVariableName ? x.articyVariableName : undefined,
+        locObjGuid: x.locObjRef?.locObjGuid,
+    };
+}
+function needsKey(params) {
+    return !str(params.name) && !str(params.contains) && !str(params.guid);
+}
+function itemKeys(store, itemName) {
+    return store.all("SELECT key FROM definition WHERE folder = 'itemtypes' AND name = ? COLLATE NOCASE", [itemName]).map((r) => String(r.key));
+}
+function recipesLinkedTo(store, keys, fieldLike, limit) {
+    if (keys.length === 0)
+        return { defs: [], truncated: false };
+    const marks = keys.map(() => "?").join(", ");
+    const rows = store.all(`SELECT DISTINCT d.key, d.folder, d.path, d.script, d.name, d.guid, d.data_json FROM link l JOIN definition d ON d.key = l.from_key
+     WHERE d.folder = 'recipes' AND l.to_key IN (${marks}) AND l.field LIKE ? ORDER BY d.name LIMIT ?`, [...keys, fieldLike, limit + 1]);
+    return { defs: rows.slice(0, limit).map(toDef), truncated: rows.length > limit };
+}
+export async function query(store, kind, params) {
+    if (!isBuilt(store)) {
+        return { kind, params, count: 0, rows: [], note: "No Nivalis Nights index has been built: run build_index for nivalisnights (it needs Cpp2IL and a Python with UnityPy; check_toolchain shows both)." };
+    }
+    const limit = limitOf(params);
+    const truncatedFlag = (t) => (t ? { truncated: true } : {});
+    switch (kind) {
+        case "folders": {
+            const rows = store.all("SELECT folder, script, COUNT(*) AS definitions FROM definition GROUP BY folder, script ORDER BY folder, script");
+            const skipped = Object.entries(SKIPPED_FOLDERS).map(([folder, reason]) => ({ folder, definitions: 0, notIndexed: reason }));
+            const version = store.get("SELECT value FROM meta WHERE key = 'gameVersion'")?.value;
+            return { kind, params, count: rows.length, rows: [...rows, ...skipped], note: `Definitions per folder and class, from Steam build ${String(version ?? "unknown")}. Rows with notIndexed are folders the decoder skips; a definition missing from them is not evidence it does not exist.` };
+        }
+        case "item": {
+            if (needsKey(params))
+                return { kind, params, count: 0, rows: [], note: "item needs `name`, `contains` or `guid`." };
+            const { defs, truncated, what } = findDefs(store, params, { folder: "itemtypes" }, limit);
+            return { kind, params, count: defs.length, ...truncatedFlag(truncated), rows: defs.map(itemSummary), note: `items ${what}. Prices are the asset's base values before vendor, location and skill bonuses.` };
+        }
+        case "recipe": {
+            const output = str(params.output);
+            const uses = str(params.uses);
+            if (output || uses) {
+                const keys = itemKeys(store, (output ?? uses));
+                const { defs, truncated } = recipesLinkedTo(store, keys, output ? "output.type" : "inputsNew[%].DefaultItem", limit);
+                const note = keys.length === 0 ? `no item is named "${output ?? uses}" (exact, case-insensitive); try kind item with contains.` : output ? `recipes whose output is "${output}".` : `recipes that take "${uses}" as a default input (recipes accepting it only by tag are not listed).`;
+                return { kind, params, count: defs.length, ...truncatedFlag(truncated), rows: defs.map(recipeSummary), note };
+            }
+            if (needsKey(params))
+                return { kind, params, count: 0, rows: [], note: "recipe needs `name`, `contains`, `guid`, `output` or `uses`." };
+            const { defs, truncated, what } = findDefs(store, params, { folder: "recipes" }, limit);
+            return { kind, params, count: defs.length, ...truncatedFlag(truncated), rows: defs.map(recipeSummary), note: `recipes ${what}.` };
+        }
+        case "person": {
+            if (needsKey(params))
+                return { kind, params, count: 0, rows: [], note: "person needs `name`, `contains` or `guid`." };
+            const { defs, truncated, what } = findDefs(store, params, { folder: "people" }, limit);
+            return { kind, params, count: defs.length, ...truncatedFlag(truncated), rows: defs.map(personSummary), note: `NPCs ${what}.` };
+        }
+        case "definition": {
+            const folder = str(params.folder)?.toLowerCase();
+            const script = str(params.script);
+            const { defs, truncated, what } = findDefs(store, params, { ...(folder ? { folder } : {}), ...(script ? { script } : {}) }, limit);
+            const note = folder && folder in SKIPPED_FOLDERS ? `${folder} is not indexed: ${SKIPPED_FOLDERS[folder]}.` : `definitions${folder ? ` in ${folder}` : ""}${script ? ` of ${script}` : ""} ${what}.`;
+            return { kind, params, count: defs.length, ...truncatedFlag(truncated), rows: defs, note };
+        }
+        case "guid": {
+            const guid = str(params.guid);
+            if (!guid)
+                return { kind, params, count: 0, rows: [], note: "guid needs `guid`." };
+            const { defs } = findDefs(store, { guid }, {}, limit);
+            return { kind, params, count: defs.length, rows: defs, note: defs.length === 0 ? `no indexed definition carries guid ${guid}; it may belong to a folder that is not indexed (see kind folders), or to a mod.` : `the definition carrying guid ${guid}.` };
+        }
+        case "references": {
+            const guid = str(params.guid);
+            const name = str(params.name);
+            if (!guid && !name)
+                return { kind, params, count: 0, rows: [], note: "references needs `guid`, or `name` (with an optional `folder`)." };
+            const folder = str(params.folder)?.toLowerCase();
+            const targets = guid
+                ? store.all("SELECT key, folder, name FROM definition WHERE guid = ? COLLATE NOCASE", [guid])
+                : store.all(`SELECT key, folder, name FROM definition WHERE name = ? COLLATE NOCASE${folder ? " AND folder = ?" : ""}`, folder ? [name, folder] : [name]);
+            if (targets.length === 0)
+                return { kind, params, count: 0, rows: [], note: `no indexed definition matches ${guid ? `guid ${guid}` : `name "${name}"`}.` };
+            const keys = targets.map((t) => String(t.key));
+            const marks = keys.map(() => "?").join(", ");
+            const rows = store.all(`SELECT d.folder, d.name, d.guid, l.field, t.folder AS targetFolder, t.name AS targetName FROM link l
+         JOIN definition d ON d.key = l.from_key JOIN definition t ON t.key = l.to_key
+         WHERE l.to_key IN (${marks}) ORDER BY d.folder, d.name, l.field LIMIT ?`, [...keys, limit + 1]);
+            const truncated = rows.length > limit;
+            return { kind, params, count: Math.min(rows.length, limit), ...truncatedFlag(truncated), rows: rows.slice(0, limit), note: `definitions whose fields point at ${targets.length === 1 ? `${String(targets[0].folder)} "${String(targets[0].name)}"` : `${targets.length} definitions named "${name}"`}; references from folders that are not indexed (quests, skills) are not counted.` };
+        }
+        default:
+            return { kind, params, count: 0, rows: [], note: `Unknown kind "${kind}"; call kind "kinds" for the list.` };
+    }
+}

package/dist/surfaces/nivalisnights/index.js

@@ -0,0 +1,4 @@
+export { nivalisnights, isInstall, diskLoggingDisabled } from "./surface.js";
+export { nivalisCompat, detectComponents, parseAppManifestBuildId, readSteamBuildId, findBleedingEdgeBuild, GAME_EXE, STEAM_APP_ID } from "./compat.js";
+export { SIGNATURES } from "./logs.js";
+export { nivalisIndex, buildIndex as buildNivalisIndex, importExtraction, DEFAULT_FOLDERS, SKIPPED_FOLDERS } from "./index/index.js";