@nowline/lsp 0.8.5 → 0.9.0

package/src/references/ast-utils.ts

@@ -3,21 +3,21 @@ import type {
     EntityProperty,
     FootnoteDeclaration,
     GroupBlock,
-    GroupContent,
     ItemDeclaration,
     LabelDeclaration,
     MilestoneDeclaration,
+    NonWorkingDeclaration,
     NowlineFile,
     ParallelBlock,
-    ParallelContent,
     PersonDeclaration,
     SizeDeclaration,
     StatusDeclaration,
     StyleDeclaration,
-    SwimlaneContent,
     SwimlaneDeclaration,
     SymbolDeclaration,
     TeamDeclaration,
+    WaveDeclaration,
+    WorkingDeclaration,
 } from '@nowline/core';
 import {
     isAnchorDeclaration,
@@ -26,19 +26,22 @@ import {
     isItemDeclaration,
     isLabelDeclaration,
     isMilestoneDeclaration,
+    isNonWorkingDeclaration,
     isNowlineFile,
     isParallelBlock,
     isPersonDeclaration,
-    isPersonMemberRef,
     isSizeDeclaration,
     isStatusDeclaration,
     isStyleDeclaration,
     isSwimlaneDeclaration,
     isSymbolDeclaration,
     isTeamDeclaration,
+    isWaveDeclaration,
+    isWorkingDeclaration,
 } from '@nowline/core';
+import { declarations, propKey, visitProperties } from '@nowline/core/internal';
 import type { AstNode, CstNode, LangiumDocument } from 'langium';
-import { CstUtils } from 'langium';
+import { CstUtils, GrammarUtils } from 'langium';
 import type { Range } from '../lsp-protocol.js';
 
 /**
@@ -49,7 +52,7 @@ import type { Range } from '../lsp-protocol.js';
  * Wider than the validator's `checkReferenceResolution` (which is strict only
  * for sequencing — `after` / `before` / `on`). Categorisation references
  * (`size` / `status` / `style` / `labels`), decoration references
- * (`icon` / `capacity-icon`), and ownership references (`owner` / `team`) are
+ * (`icon` / `capacity-icon`), and the ownership reference (`owner`) are
  * permissive in the validator (an undeclared id is not an error) but still
  * navigable when a declaration exists.
  *
@@ -57,60 +60,44 @@ import type { Range } from '../lsp-protocol.js';
  * form was removed in favor of the spec-mandated reverse direction.
  * Footnote association flows only from the footnote declaration's `on:`,
  * and the validator now rejects `footnote:` as a property on host entities.
+ *
+ * Every key here must be one the validator accepts; `reference-keys.test.ts`
+ * checks that.
  */
 export const REFERENCE_PROP_KEYS = new Set([
     'after',
     'before',
-    'depends',
     'on',
     'owner',
-    'team',
     'size',
     'status',
     'style',
     'labels',
     'icon',
     'capacity-icon',
+    'wave',
 ]);
 
-/** Status value-completion source: built-in statuses ship with the renderer. */
-export const BUILTIN_STATUSES: readonly string[] = [
-    'planned',
-    'in-progress',
-    'done',
-    'at-risk',
-    'blocked',
-];
-
-/**
- * Built-in `capacity-icon:` vocabulary. Mirrors `BUILTIN_CAPACITY_ICONS` in
- * the validator — kept as a literal here so the LSP doesn't have to import a
- * non-public symbol from `@nowline/core`.
- */
-export const BUILTIN_CAPACITY_ICONS: readonly string[] = [
-    'none',
-    'multiplier',
-    'person',
-    'people',
-    'points',
-    'time',
-];
-
 /**
- * Built-in `icon:` vocabulary. Superset of `BUILTIN_CAPACITY_ICONS` plus the
- * entity-decoration glyphs the renderer ships.
+ * Value-completion sources. The vocabularies are core's (`value-tables.ts`):
+ * the validator checks values against the same lists, so the editor offers
+ * exactly what validates. Kept as `@nowline/lsp` exports. `WEEKDAY_NAMES` is
+ * the weekday names `every:` takes, Sunday first.
  */
-export const BUILTIN_ICON_NAMES: readonly string[] = [
-    ...BUILTIN_CAPACITY_ICONS,
-    'shield',
-    'warning',
-    'lock',
-];
+export {
+    BUILTIN_CAPACITY_ICONS,
+    BUILTIN_ICON_NAMES,
+    BUILTIN_STATUSES,
+    CALENDAR_MODES,
+    COLOR_NAMES,
+    INCLUDE_MODES,
+    NON_WORKING_DISPLAYS,
+    STYLE_PROP_ENUMS,
+    WEEKDAYS as WEEKDAY_NAMES,
+} from '@nowline/core/internal';
 
-/** Strip the trailing `:` an `EntityProperty.key` carries from the grammar. */
-export function propKey(prop: { key: string }): string {
-    return prop.key.endsWith(':') ? prop.key.slice(0, -1) : prop.key;
-}
+/** `prop.key` without a trailing `:` (core's, kept as an `@nowline/lsp` export). */
+export { propKey };
 
 /**
  * Named declaration shapes we expose for navigation. All have `name?: string`,
@@ -119,6 +106,11 @@ export function propKey(prop: { key: string }): string {
  * Includes both roadmap-section declarations (item, swimlane, person, …) and
  * config-section declarations (`style`, `symbol`) so cmd+click on
  * `style:enterprise-style` and `icon:my-symbol` resolves to the right place.
+ *
+ * `non-working` and `working` declarations are here so `declarationAt` (hover)
+ * sees them, but `collectNamedEntities` skips them: nothing references a
+ * calendar declaration by id, so they stay out of reference completion,
+ * definition and rename.
  */
 export type NamedEntity =
     | RoadmapEntryNamed
@@ -126,7 +118,9 @@ export type NamedEntity =
     | ParallelBlock
     | GroupBlock
     | StyleDeclaration
-    | SymbolDeclaration;
+    | SymbolDeclaration
+    | NonWorkingDeclaration
+    | WorkingDeclaration;
 
 type RoadmapEntryNamed =
     | SwimlaneDeclaration
@@ -137,64 +131,33 @@ type RoadmapEntryNamed =
     | TeamDeclaration
     | LabelDeclaration
     | SizeDeclaration
-    | StatusDeclaration;
+    | StatusDeclaration
+    | WaveDeclaration;
 
 /**
- * Walk the `NowlineFile` and collect every entity that owns an `id`. Covers
- * roadmap-section entities (mirrors the validator's `collectReferenceableIds`)
- * plus the named config-section declarations (`style`, `symbol`) so style and
- * symbol references navigate correctly. Anonymous config blocks (`scale`,
- * `calendar`, `default <entity>`) are skipped.
+ * True for a `non-working` or `working` declaration. Hover describes them, but
+ * nothing references a calendar declaration by id, so definition, references
+ * and rename leave them alone.
+ */
+export function isCalendarDeclaration(entity: AstNode): boolean {
+    return isNonWorkingDeclaration(entity) || isWorkingDeclaration(entity);
+}
+
+/**
+ * Collect every entity that owns an `id`, in the order of core's declaration
+ * walk (config entries first, then roadmap entries with their track content or
+ * nested teams): the roadmap-section entities `@nowline/core`'s
+ * `referenceableIds` covers, plus the named config-section declarations
+ * (`style`, `symbol`) so style and symbol references navigate correctly.
+ * The LSP skips the roadmap line itself (not walked here) and the calendar
+ * declarations (`isCalendarDeclaration`); anonymous declarations have no id.
  */
 export function collectNamedEntities(file: NowlineFile): NamedEntity[] {
     const out: NamedEntity[] = [];
-
-    for (const entry of file.configEntries) {
-        if (isStyleDeclaration(entry) && entry.name) out.push(entry);
-        else if (isSymbolDeclaration(entry) && entry.name) out.push(entry);
+    for (const node of declarations(file, { config: true })) {
+        if (!(node as { name?: string }).name || isCalendarDeclaration(node)) continue;
+        out.push(node as NamedEntity);
     }
-
-    const visitTeam = (team: TeamDeclaration) => {
-        if (team.name) out.push(team);
-        for (const c of team.content) {
-            if (isTeamDeclaration(c)) visitTeam(c);
-            // `PersonMemberRef` and `DescriptionDirective` are references / prose,
-            // not declarations — skip.
-            else if (isPersonMemberRef(c)) {
-                /* skip */
-            }
-        }
-    };
-
-    const visitTrackChild = (child: SwimlaneContent | GroupContent | ParallelContent) => {
-        if (isItemDeclaration(child) && child.name) out.push(child);
-        else if (isParallelBlock(child)) {
-            if (child.name) out.push(child);
-            for (const sub of child.content) visitTrackChild(sub);
-        } else if (isGroupBlock(child)) {
-            if (child.name) out.push(child);
-            for (const sub of child.content) visitTrackChild(sub);
-        }
-    };
-
-    for (const entry of file.roadmapEntries) {
-        if (isSwimlaneDeclaration(entry)) {
-            if (entry.name) out.push(entry);
-            for (const c of entry.content) visitTrackChild(c);
-        } else if (isTeamDeclaration(entry)) visitTeam(entry);
-        else if (
-            isPersonDeclaration(entry) ||
-            isAnchorDeclaration(entry) ||
-            isMilestoneDeclaration(entry) ||
-            isFootnoteDeclaration(entry) ||
-            isLabelDeclaration(entry) ||
-            isSizeDeclaration(entry) ||
-            isStatusDeclaration(entry)
-        ) {
-            if (entry.name) out.push(entry);
-        }
-    }
-
     return out;
 }
 
@@ -213,27 +176,7 @@ export function buildEntityIndex(file: NowlineFile): Map<string, NamedEntity> {
 }
 
 /** Visit every `EntityProperty` reachable from a roadmap entry, depth-first. */
-export function visitProperties(
-    node: AstNode,
-    visit: (prop: EntityProperty, owner: AstNode) => void,
-): void {
-    const walk = (n: AstNode): void => {
-        const props = (n as { properties?: EntityProperty[] }).properties;
-        if (Array.isArray(props)) {
-            for (const p of props) visit(p, n);
-        }
-        if (isSwimlaneDeclaration(n)) {
-            for (const c of n.content) walk(c);
-        } else if (isParallelBlock(n) || isGroupBlock(n)) {
-            for (const c of n.content) walk(c);
-        } else if (isTeamDeclaration(n)) {
-            for (const c of n.content) {
-                if (isTeamDeclaration(c) || isPersonDeclaration(c)) walk(c);
-            }
-        }
-    };
-    walk(node);
-}
+export { visitProperties };
 
 /**
  * Iterate every `EntityProperty` in the file, including those on the roadmap
@@ -297,13 +240,16 @@ export function propertyValueAt(
 
 /**
  * When `leaf` is the `name=ID` token of a named entity declaration, return the
- * declaring entity. Returns `undefined` for any other position.
+ * declaring entity. Returns `undefined` for any other position, including the
+ * declaration keyword (`wave wave "W"` names its wave after the keyword).
  */
 export function declarationAt(leaf: CstNode | undefined): NamedEntity | undefined {
     if (!leaf) return undefined;
     const owner = leaf.astNode as AstNode & { name?: string };
     if (!owner || typeof owner.name !== 'string') return undefined;
     if (owner.name !== leaf.text) return undefined;
+    const nameNode = nameNodeOf(owner);
+    if (!nameNode || leaf.offset < nameNode.offset || leaf.end > nameNode.end) return undefined;
     if (
         isSwimlaneDeclaration(owner) ||
         isItemDeclaration(owner) ||
@@ -317,8 +263,11 @@ export function declarationAt(leaf: CstNode | undefined): NamedEntity | undefine
         isLabelDeclaration(owner) ||
         isSizeDeclaration(owner) ||
         isStatusDeclaration(owner) ||
+        isWaveDeclaration(owner) ||
         isStyleDeclaration(owner) ||
-        isSymbolDeclaration(owner)
+        isSymbolDeclaration(owner) ||
+        isNonWorkingDeclaration(owner) ||
+        isWorkingDeclaration(owner)
     ) {
         return owner as NamedEntity;
     }
@@ -348,6 +297,8 @@ export function findDeclarationRange(file: NowlineFile, id: string): Range | und
  * Render a one-line "type id" label used by hover and document-symbols.
  */
 export function entityKind(entity: AstNode): string {
+    // `NonWorkingDeclaration` would lowercase to `nonworking`; the keyword is hyphenated.
+    if (entity.$type === 'NonWorkingDeclaration') return 'non-working';
     return entity.$type
         .replace(/Declaration$/, '')
         .replace(/Block$/, '')
@@ -355,18 +306,21 @@ export function entityKind(entity: AstNode): string {
 }
 
 /**
- * Find the CST node that holds the given entity's `name=ID` token. Walks the
- * entity's CST subtree and returns the first leaf whose text equals the
- * entity's resolved name. Returns `undefined` when the entity has no `name`
- * (anonymous declaration), no CST node, or no matching leaf.
+ * Find the range of the given entity's `name=ID` token. Uses the grammar
+ * assignment rather than matching leaf text, so a name that equals the
+ * declaration keyword (`wave wave "W"`) resolves to the name, not the
+ * keyword. Returns `undefined` when the entity has no `name` (anonymous
+ * declaration) or no CST node.
  */
 export function nameRangeOf(entity: AstNode): Range | undefined {
+    return nameNodeOf(entity)?.range;
+}
+
+// The CST node assigned to the entity's `name` property.
+function nameNodeOf(entity: AstNode): CstNode | undefined {
     const name = (entity as { name?: string }).name;
     if (!name || !entity.$cstNode) return undefined;
-    for (const leaf of CstUtils.flattenCst(entity.$cstNode)) {
-        if (leaf.text === name) return leaf.range;
-    }
-    return undefined;
+    return GrammarUtils.findNodeForProperty(entity.$cstNode, 'name');
 }
 
 /**