@px-lsp/server 0.3.0 → 0.3.1

package/src/games/profile.ts

@@ -10,6 +10,7 @@
  */
 import type { CalendarLocSpec } from "@px-lsp/protocol/calendarLoc";
 import type { DefRootKey, RefField, SchemaEntry, StructureSpec } from "../schema/types";
+import type { KindSkeleton } from "../schema/skeletons";
 import type { PlaceholderSpec } from "../data/modifierTemplates";
 import type { GuiLayoutQuirks, GuiTextMetrics } from "../gui/layoutEngine";
 import type { SaveSchema } from "../gui/saveSchema";
@@ -70,8 +71,10 @@ export interface GameMeta {
   engine: "jomini" | "clausewitz-classic";
   /** Mod descriptor convention: Paradox-launcher `.mod` file vs `.metadata/metadata.json`. */
   descriptor: "mod" | "metadata";
-  /** Per-workspace config dir holding schema.json / playset.json overlays. */
+  /** Per-mod config dir holding schema.json / playset.json overlays, workshop.json, the listing folder. */
   configDirName: string;
+  /** The pre-0.4.0 per-game name of that dir, still read as a fallback and renamed on first write. */
+  legacyConfigDirName?: string;
   /** Game folder under `Documents/Paradox Interactive/` (script_docs logs live in its logs/). */
   docsFolderName: string;
   /**
@@ -87,6 +90,12 @@ export interface GameMeta {
    */
   dataTypesCommand?: string;
   steamAppId: number;
+  /**
+   * Folder under the game data dir holding one icon per DLC, named after the
+   * DLC folder's number (`dlc_003.dds` or `dlc003.dds`). Absent = the install
+   * ships no such folder and the DLC's own `thumbnail.png` is used instead.
+   */
+  dlcIconDir?: string;
   /** Whether event files declare `namespace = x` and use `ns.N` event ids. */
   eventNamespaces: boolean;
   /**
@@ -128,6 +137,39 @@ export interface GameMeta {
    * not open for this game.
    */
   flagBuilder?: boolean;
+  /**
+   * The game ships its own in-game Coat of Arms designer, and the files that
+   * drive it (`gfx/coat_of_arms/{patterns,colored_emblems,color_palettes,
+   * emblem_layouts}/50_coa_designer_*.txt` and the `99_coa_designer_templates`
+   * coat-of-arms templates). Present = the toolkit offers the designer
+   * instead of the raw Flag Builder, when those files are actually on disk.
+   * Absent = the Flag Builder, as before.
+   */
+  coaDesigner?: boolean;
+  /**
+   * Visual content creators offered for this game, in Create-group order. A
+   * row is a definition kind the schema knows (the panel's command opens that
+   * creator), except `dynasty_tree`, which is a view over history files rather
+   * than one definition. Absent = no creator has been built against this
+   * game's own files, and the Create group shows only the scaffolds.
+   */
+  creators?: {
+    /** Schema kind, or the id of a bespoke creator that owns no single kind. */
+    kind: string;
+    label: string;
+    /** A Lucide icon name present in the client's webviews/shared/icons.ts. */
+    icon: string;
+    /** One-line hint for the panel row. */
+    tip?: string;
+  }[];
+  /**
+   * Where the game states how a modifier is PRINTED: the folder of format
+   * definitions (one block per modifier), and the `.gui` file whose `texticon`
+   * blocks map an icon name to its sprite. Both paths are relative to the game
+   * data dir. Absent = this game's print rules have not been read out of its
+   * own files, and `paradox/modifierFormats` answers null rather than guessing.
+   */
+  modifierFormats?: { folder: string; textIcons: string };
   /**
    * Database entry-mode prefixes legal on top-level definition keys
    * (EU5's `REPLACE:key`). The indexer strips a leading `<MODE>:` before
@@ -166,6 +208,25 @@ export interface GameMeta {
   cacheSuffix: string;
 }
 
+/**
+ * Where a creator's condition builder gets the values of one trigger
+ * (`DefinitionForm.conditions`). Each source is something the server already
+ * holds, so a game patch changes the list without a release:
+ *
+ *   docList     the trigger's own script_docs entry enumerates them on its
+ *               metadata line ("has_dlc_feature … Traits: Valid Features: a,
+ *               b, and c", CK3 triggers.log 1.19)
+ *   kind        every indexed definition of a definition kind
+ *   innerKeys   the inner block keys of every definition of a kind, minus
+ *               `except` (a CK3 game rule's settings ARE its inner blocks;
+ *               the other two keys are `categories` and `default`, per
+ *               common/game_rules/_game_rules.info)
+ */
+export type ConditionValueSource =
+  | { from: "docList" }
+  | { from: "kind"; kind: string }
+  | { from: "innerKeys"; kind: string; except?: string[] };
+
 /** A game's full knowledge bundle: meta plus the tables the engine consumes. */
 export interface GameProfile extends GameMeta {
   /** Folder→definition-kind table (see schema/types.ts). */
@@ -185,6 +246,14 @@ export interface GameProfile extends GameMeta {
    * those entries always win.
    */
   structures?: Record<string, StructureSpec>;
+  /**
+   * Definition skeletons per kind (data/<id>/skeletons.json, harvested by
+   * scripts/build-skeletons.ts): the shape a new definition of the kind takes,
+   * measured over the game's own files. Absent or empty = nobody has measured
+   * this game's vanilla tree, and completion offers no skeleton for it rather
+   * than a shape written from memory.
+   */
+  skeletons?: Record<string, KindSkeleton>;
   /**
    * Definition kinds that declare their own root scope in their body, keyed by
    * kind (scopes/inference.ts). Absent = every kind's root scope comes from the
@@ -193,6 +262,13 @@ export interface GameProfile extends GameMeta {
   defRootKeys?: Record<string, DefRootKey>;
   /** Templated-modifier placeholder table (data/modifierTemplates.ts). */
   modifierPlaceholders: Record<string, PlaceholderSpec>;
+  /**
+   * Triggers a creator's condition builder may offer a value list for, keyed
+   * by trigger name (`paradox/definitionForm`'s `conditions`). Absent = the
+   * creators offer no picker for this game and fall back to free input, which
+   * is the honest answer for a game whose sources have not been measured.
+   */
+  conditionValues?: Record<string, ConditionValueSource>;
   /**
    * Bundled `[ ... ]` data-function tables (data/<id>/dataTypes.json), when the
    * game ships one. Shape is data/dataTypes.ts's bundled-JSON shape; typed

package/src/games/vic3/index.ts

@@ -5,11 +5,14 @@
  * (markdown format). No wiki fallback and no structures layer, see below.
  */
 import type { GameProfile } from "../profile";
+import type { SkeletonData } from "../../schema/skeletons";
 import { vic3Meta } from "./meta";
 import { VIC3_BLOCK_REF_FIELDS, VIC3_PREFIX_REFS, VIC3_REF_FIELDS, VIC3_SCHEMA } from "./schema";
 import { VIC3_STRUCTURES, VIC3_STRUCTURE_SOURCES } from "./structures";
 import { VIC3_SAVE_SCHEMA } from "./saveSchema";
 import GUI_SCHEMA from "../../../data/vic3/guiSchema.json";
+// Definition skeletons measured over the vanilla tree (scripts/build-skeletons.ts).
+import SKELETONS from "../../../data/vic3/skeletons.json";
 
 export const vic3Profile: GameProfile = {
   ...vic3Meta,
@@ -18,6 +21,7 @@ export const vic3Profile: GameProfile = {
   prefixRefs: VIC3_PREFIX_REFS,
   blockRefFields: VIC3_BLOCK_REF_FIELDS,
   guiSchema: GUI_SCHEMA,
+  skeletons: (SKELETONS as unknown as SkeletonData).kinds,
   // guiTextMetrics live on the meta (the client reads them too, for the GUI
   // editor gate and its canvas line height).
   // Vic3 keeps an authored size on an EMPTY container (px_probe_c C5: the

package/src/games/vic3/meta.ts

@@ -12,13 +12,17 @@ export const vic3Meta: GameMeta = {
   engine: "jomini",
   // Vic3 mods carry .metadata/metadata.json instead of a launcher .mod file.
   descriptor: "metadata",
-  configDirName: ".vic3modding",
+  configDirName: ".px-toolkit",
+  legacyConfigDirName: ".vic3modding",
   docsFolderName: "Victoria 3",
   // Vic3's `script_docs` writes to Documents/.../docs (like EU5), while
   // `dump_data_types` writes to logs/data_types — verified on a live install.
   scriptDocsSubdir: "docs",
   dataTypesCommand: "dump_data_types",
   steamAppId: 529340,
+  // Verified on the live install: a different folder name from CK3's, and only
+  // some DLC have a file there (the rest fall back to their thumbnail.png).
+  dlcIconDir: "gfx/interface/icons/dlc_icons",
   eventNamespaces: true,
   scaffolds: VIC3_SCAFFOLDS,
   // uiFont deliberately absent: this game ships no Gitan (its fonts/ holds

package/src/gui/sourceModel.ts

@@ -57,6 +57,40 @@ export type GuiEntryKind = "widget" | "decl" | "property";
  * block alone.
  */
 
+/**
+ * The three .gui-specific tables the model reads, lifted into a parameter so
+ * the same span model can serve plain jomini script (`common/traits/*.txt`),
+ * which has none of them.
+ *
+ * `propertyBlocks` is NOT a set for script: the gui rule is the INVERSE one (a
+ * block child is a child widget unless its key is a known attribute block), so
+ * an empty set would classify every block in a trait as a widget and the
+ * writer would refuse to rewrite it. `null` says "this dialect has no child
+ * declarations at all", which is what script is.
+ */
+export interface SourceDialect {
+  /** Bare words that label the next assignment as a declaration. */
+  declMarkers: ReadonlySet<string>;
+  /** Keys taking the `key = "name" { ... }` slot spelling. */
+  slotKeys: ReadonlySet<string>;
+  /** Block-valued keys that are attributes; `null` = every block is an attribute. */
+  propertyBlocks: ReadonlySet<string> | null;
+}
+
+/** The default: the .gui tables, so every existing caller is unchanged. */
+export const GUI_DIALECT: SourceDialect = {
+  declMarkers: DECL_MARKERS,
+  slotKeys: SLOT_KEYS,
+  propertyBlocks: PROPERTY_BLOCKS,
+};
+
+/** Plain jomini script: no markers, no slot form, no child declarations. */
+export const SCRIPT_DIALECT: SourceDialect = {
+  declMarkers: new Set(),
+  slotKeys: new Set(),
+  propertyBlocks: null,
+};
+
 /** One `key [op] value` statement, with every raw span the writer addresses it by. */
 export interface GuiEntry {
   kind: GuiEntryKind;
@@ -177,13 +211,14 @@ interface BuildCtx {
   lineKind: Uint8Array;
   commentsByLine: Map<number, CommentNode[]>;
   entries: GuiEntry[];
+  dialect: SourceDialect;
 }
 
 const LINE_BLANK = 0;
 const LINE_COMMENT = 1;
 const LINE_CODE = 2;
 
-export function parseGuiSource(text: string): GuiSourceFile {
+export function parseGuiSource(text: string, dialect: SourceDialect = GUI_DIALECT): GuiSourceFile {
   const parsed = parseScript(text);
   const lines = new LineIndex(text);
   const commentsByLine = new Map<number, CommentNode[]>();
@@ -198,6 +233,7 @@ export function parseGuiSource(text: string): GuiSourceFile {
     lineKind: classifyLines(text, lines, commentsByLine),
     commentsByLine,
     entries: [],
+    dialect,
   };
   const root = buildBody(parsed.root.statements, -1, null, { start: 0, end: text.length }, null, ctx);
   return {
@@ -269,7 +305,7 @@ function buildBody(
       // A bare `template` / `type` / `blockoverride` word labels the next
       // assignment; anything else clears the label.
       marker =
-        stmt.value.kind === "scalar" && DECL_MARKERS.has(stmt.value.text.toLowerCase())
+        stmt.value.kind === "scalar" && ctx.dialect.declMarkers.has(stmt.value.text.toLowerCase())
           ? { text: stmt.value.text.toLowerCase(), span: stmt.value.range }
           : null;
       continue;
@@ -353,7 +389,7 @@ function buildEntry(
 ): GuiEntry {
   const { text, lines } = ctx;
   const opSpan = operatorSpan(text, stmt);
-  const slot = slotForm(stmt, declMarker);
+  const slot = slotForm(stmt, declMarker, ctx.dialect);
   const marker = slot?.marker ?? declMarker;
   const key = slot?.key ?? stmt.key;
   const value = slot?.value ?? stmt.value;
@@ -384,7 +420,7 @@ function buildEntry(
   const ownLine = startsLine && endsLine;
 
   const entry: GuiEntry = {
-    kind: classify(key, marker, block),
+    kind: classify(key, marker, block, ctx.dialect),
     key: key.text,
     keyLower: key.text.toLowerCase(),
     keySpan: key.range,
@@ -444,22 +480,29 @@ function buildEntry(
  * the writer and the preview can never disagree about what is a widget: a
  * block child is a widget unless its key is a known attribute block.
  */
-function classify(key: ScalarNode, marker: { text: string } | null, block: BlockNode | null): GuiEntryKind {
+function classify(
+  key: ScalarNode,
+  marker: { text: string } | null,
+  block: BlockNode | null,
+  dialect: SourceDialect
+): GuiEntryKind {
   if (marker) return "decl";
   if (!block) return "property";
+  if (!dialect.propertyBlocks) return "property";
   const lower = key.text.toLowerCase();
-  if (PROPERTY_BLOCKS.has(lower) || lower.startsWith("@")) return "property";
+  if (dialect.propertyBlocks.has(lower) || lower.startsWith("@")) return "property";
   return "widget";
 }
 
 /** The `blockoverride = "name" { ... }` spelling, re-read as marker + name + body. */
 function slotForm(
   stmt: AssignmentNode,
-  marker: { text: string; span: GuiSpan } | null
+  marker: { text: string; span: GuiSpan } | null,
+  dialect: SourceDialect
 ): { marker: { text: string; span: GuiSpan }; key: ScalarNode; value: BlockNode } | null {
   if (marker || stmt.value?.kind !== "tagged-block") return null;
   const lower = stmt.key.text.toLowerCase();
-  if (!SLOT_KEYS.has(lower)) return null;
+  if (!dialect.slotKeys.has(lower)) return null;
   return {
     marker: { text: lower, span: stmt.key.range },
     key: stmt.value.tag,

package/src/gui/textResolve.ts

@@ -34,7 +34,7 @@ const LOC_KEY = /^[A-Za-z0-9_][A-Za-z0-9_.\-']*$/;
  * Loc formatting the game does not draw: `#bold text#!`, `#R text#!`, `§Ytext§!`,
  * `@icon!` icon references. Removed for measurement; the preview has no glyphs for them.
  */
-function stripFormatting(s: string): string {
+export function stripFormatting(s: string): string {
   return s
     .replace(/#!/g, "")
     .replace(/#[A-Za-z_][A-Za-z0-9_;:]*\s?/g, "")
@@ -45,7 +45,7 @@ function stripFormatting(s: string): string {
 }
 
 /** Split `a [Fn] b [[literal]` into literal and datafunction pieces. */
-function tokenize(s: string): { literal?: string; fn?: string }[] {
+export function tokenize(s: string): { literal?: string; fn?: string }[] {
   const out: { literal?: string; fn?: string }[] = [];
   let lit = "";
   for (let i = 0; i < s.length; i++) {
@@ -87,7 +87,7 @@ function locOfCall(fn: string, loc: TextResolvers["loc"]): string | undefined {
 }
 
 /** `GetPlayer.GetName` -> `GetName`; `Concept('x','y')` -> `Concept`; strips a `Get` prefix and arguments. */
-function chipFor(fn: string): string {
+export function chipFor(fn: string): string {
   // `|0`, `|%`: format specifiers after the chain, not part of the name.
   const chain = fn.split("|")[0];
   const last = chain.split(".").pop() ?? chain;