@rsconcept/domain 1.0.0

package/src/graph/graph.ts

@@ -0,0 +1,433 @@
+/**
+ * Module: Custom graph data structure.
+ */
+
+/** Represents single node of a {@link Graph}, as implemented by storing outgoing and incoming connections. */
+export class GraphNode<NodeID> {
+  /** Unique identifier of the node. */
+  id: NodeID;
+  /** List of outgoing nodes. */
+  outputs: NodeID[];
+  /** List of incoming nodes. */
+  inputs: NodeID[];
+
+  constructor(id: NodeID) {
+    this.id = id;
+    this.outputs = [];
+    this.inputs = [];
+  }
+
+  clone(): GraphNode<NodeID> {
+    const result = new GraphNode(this.id);
+    result.outputs = [...this.outputs];
+    result.inputs = [...this.inputs];
+    return result;
+  }
+
+  addOutput(node: NodeID): void {
+    this.outputs.push(node);
+  }
+
+  addInput(node: NodeID): void {
+    this.inputs.push(node);
+  }
+
+  removeInput(target: NodeID): NodeID | null {
+    const index = this.inputs.findIndex(node => node === target);
+    return index > -1 ? this.inputs.splice(index, 1)[0] : null;
+  }
+
+  removeOutput(target: NodeID): NodeID | null {
+    const index = this.outputs.findIndex(node => node === target);
+    return index > -1 ? this.outputs.splice(index, 1)[0] : null;
+  }
+}
+
+/**
+ * Represents a Graph.
+ *
+ * This class is optimized for TermGraph use case and not supposed to be used as generic graph implementation.
+ */
+export class Graph<NodeID = number> {
+  /** Map of nodes. */
+  nodes = new Map<NodeID, GraphNode<NodeID>>();
+
+  constructor(arr?: NodeID[][]) {
+    if (!arr) {
+      return;
+    }
+    arr.forEach(edge => {
+      if (edge.length === 1) {
+        this.addNode(edge[0]);
+      } else {
+        this.addEdge(edge[0], edge[1]);
+      }
+    });
+  }
+
+  clone(): Graph<NodeID> {
+    const result = new Graph<NodeID>();
+    this.nodes.forEach(node => result.nodes.set(node.id, node.clone()));
+    return result;
+  }
+
+  at(target: NodeID): GraphNode<NodeID> | undefined {
+    return this.nodes.get(target);
+  }
+
+  addNode(target: NodeID): GraphNode<NodeID> {
+    let node = this.nodes.get(target);
+    if (!node) {
+      node = new GraphNode(target);
+      this.nodes.set(target, node);
+    }
+    return node;
+  }
+
+  hasNode(target: NodeID): boolean {
+    return !!this.nodes.get(target);
+  }
+
+  removeNode(target: NodeID): void {
+    this.nodes.forEach(node => {
+      node.removeInput(target);
+      node.removeOutput(target);
+    });
+    this.nodes.delete(target);
+  }
+
+  foldNode(target: NodeID): void {
+    const nodeToRemove = this.nodes.get(target);
+    if (!nodeToRemove) {
+      return;
+    }
+    nodeToRemove.inputs.forEach(input => {
+      nodeToRemove.outputs.forEach(output => {
+        this.addEdge(input, output);
+      });
+    });
+    this.removeNode(target);
+  }
+
+  removeIsolated(): GraphNode<NodeID>[] {
+    const result: GraphNode<NodeID>[] = [];
+    this.nodes.forEach(node => {
+      if (node.outputs.length === 0 && node.inputs.length === 0) {
+        result.push(node);
+        this.nodes.delete(node.id);
+      }
+    });
+    return result;
+  }
+
+  addEdge(source: NodeID, destination: NodeID): void {
+    if (this.hasEdge(source, destination)) {
+      return;
+    }
+    const sourceNode = this.addNode(source);
+    const destinationNode = this.addNode(destination);
+    sourceNode.addOutput(destinationNode.id);
+    destinationNode.addInput(sourceNode.id);
+  }
+
+  removeEdge(source: NodeID, destination: NodeID): void {
+    const sourceNode = this.nodes.get(source);
+    const destinationNode = this.nodes.get(destination);
+    if (sourceNode && destinationNode) {
+      sourceNode.removeOutput(destination);
+      destinationNode.removeInput(source);
+    }
+  }
+
+  hasEdge(source: NodeID, destination: NodeID): boolean {
+    const sourceNode = this.nodes.get(source);
+    if (!sourceNode) {
+      return false;
+    }
+    return !!sourceNode.outputs.find(id => id === destination);
+  }
+
+  isReachable(source: NodeID, destination: NodeID): boolean {
+    return this.expandAllOutputs([source]).includes(destination);
+  }
+
+  rootNodes(): NodeID[] {
+    return [...this.nodes.keys()].filter(id => !this.nodes.get(id)?.inputs.length);
+  }
+
+  expandOutputs(origin: NodeID[]): NodeID[] {
+    const result: NodeID[] = [];
+    origin.forEach(id => {
+      const node = this.nodes.get(id);
+      if (node) {
+        node.outputs.forEach(child => {
+          if (!origin.includes(child) && !result.includes(child)) {
+            result.push(child);
+          }
+        });
+      }
+    });
+    return result;
+  }
+
+  expandInputs(origin: NodeID[]): NodeID[] {
+    const result: NodeID[] = [];
+    origin.forEach(id => {
+      const node = this.nodes.get(id);
+      if (node) {
+        node.inputs.forEach(child => {
+          if (!origin.includes(child) && !result.includes(child)) {
+            result.push(child);
+          }
+        });
+      }
+    });
+    return result;
+  }
+
+  expandAllOutputs(origin: NodeID[]): NodeID[] {
+    const result: NodeID[] = this.expandOutputs(origin);
+    if (result.length === 0) {
+      return [];
+    }
+
+    const marked = new Map<NodeID, boolean>();
+    origin.forEach(id => marked.set(id, true));
+    let position = 0;
+    while (position < result.length) {
+      const node = this.nodes.get(result[position]);
+      if (node && !marked.get(node.id)) {
+        marked.set(node.id, true);
+        node.outputs.forEach(child => {
+          if (!marked.get(child) && !result.find(id => id === child)) {
+            result.push(child);
+          }
+        });
+      }
+      position += 1;
+    }
+    return result;
+  }
+
+  expandAllInputs(origin: NodeID[]): NodeID[] {
+    const result: NodeID[] = this.expandInputs(origin);
+    if (result.length === 0) {
+      return [];
+    }
+
+    const marked = new Map<NodeID, boolean>();
+    origin.forEach(id => marked.set(id, true));
+    let position = 0;
+    while (position < result.length) {
+      const node = this.nodes.get(result[position]);
+      if (node && !marked.get(node.id)) {
+        marked.set(node.id, true);
+        node.inputs.forEach(child => {
+          if (!marked.get(child) && !result.find(id => id === child)) {
+            result.push(child);
+          }
+        });
+      }
+      position += 1;
+    }
+    return result;
+  }
+
+  maximizePart(origin: NodeID[]): NodeID[] {
+    const outputs: NodeID[] = this.expandAllOutputs(origin);
+    const result = [...origin];
+    this.topologicalOrder()
+      .filter(id => outputs.includes(id))
+      .forEach(id => {
+        const node = this.nodes.get(id);
+        if (node?.inputs.every(parent => result.includes(parent))) {
+          result.push(id);
+        }
+      });
+    return result;
+  }
+
+  topologicalOrder(): NodeID[] {
+    const result: NodeID[] = [];
+    const marked = new Set<NodeID>();
+    const nodeStack: NodeID[] = [];
+    this.nodes.forEach(node => {
+      if (marked.has(node.id)) {
+        return;
+      }
+      nodeStack.push(node.id);
+      while (nodeStack.length > 0) {
+        const item = nodeStack[nodeStack.length - 1];
+        if (marked.has(item)) {
+          if (!result.find(id => id === item)) {
+            result.push(item);
+          }
+          nodeStack.pop();
+        } else {
+          marked.add(item);
+          const itemNode = this.nodes.get(item);
+          if (itemNode && itemNode.outputs.length > 0) {
+            itemNode.outputs.forEach(child => {
+              if (!marked.has(child)) {
+                nodeStack.push(child);
+              }
+            });
+          }
+        }
+      }
+    });
+    return result.reverse();
+  }
+
+  /**
+   * Stably reorders the given node ids so that, for this DAG, no node appears before a transitive
+   * successor (edges: source → dependent; {@link GraphNode.outputs} lists dependents).
+   */
+  sortStable(target: NodeID[]): NodeID[] {
+    if (target.length <= 1) {
+      return [...target];
+    }
+
+    const reachable = this.buildTransitiveClosureForSort();
+    const testSet = new Set<NodeID>();
+    const result: NodeID[] = [];
+
+    for (const nodeId of [...target].reverse()) {
+      const nodeReachable = reachable.get(nodeId) ?? new Set<NodeID>();
+      const needMove = testSet.has(nodeId);
+      for (const childId of nodeReachable) {
+        testSet.add(childId);
+      }
+
+      if (!needMove) {
+        result.push(nodeId);
+        continue;
+      }
+
+      let inserted = false;
+      for (let index = 0; index < result.length; index++) {
+        const parent = result[index];
+        const parentReachable = reachable.get(parent) ?? new Set<NodeID>();
+        if (nodeReachable.has(parent)) {
+          if (parentReachable.has(nodeId)) {
+            result.push(nodeId);
+          } else {
+            result.splice(index, 0, nodeId);
+          }
+          inserted = true;
+          break;
+        }
+      }
+      if (!inserted) {
+        result.push(nodeId);
+      }
+    }
+
+    result.reverse();
+    return result;
+  }
+
+  private buildTransitiveClosureForSort(): Map<NodeID, Set<NodeID>> {
+    const closure = new Map<NodeID, Set<NodeID>>();
+    for (const node of this.nodes.values()) {
+      closure.set(node.id, new Set(node.outputs));
+    }
+
+    const order = this.topologicalOrder();
+    for (const nodeId of [...order].reverse()) {
+      const node = this.at(nodeId);
+      if (!node) {
+        continue;
+      }
+      const nodeClosure = closure.get(nodeId) ?? new Set<NodeID>();
+      for (const parentId of node.inputs) {
+        const parentClosure = closure.get(parentId) ?? new Set<NodeID>();
+        for (const childId of nodeClosure) {
+          parentClosure.add(childId);
+        }
+        closure.set(parentId, parentClosure);
+      }
+    }
+
+    return closure;
+  }
+
+  transitiveReduction() {
+    const order = this.topologicalOrder();
+    const marked = new Map<NodeID, boolean>();
+    order.forEach(nodeID => {
+      if (marked.get(nodeID)) {
+        return;
+      }
+      const stack: { id: NodeID; parents: NodeID[] }[] = [];
+      stack.push({ id: nodeID, parents: [] });
+      while (stack.length > 0) {
+        const item = stack.splice(0, 1)[0];
+        const node = this.nodes.get(item.id);
+        if (node) {
+          node.outputs.forEach(child => {
+            item.parents.forEach(parent => this.removeEdge(parent, child));
+            stack.push({ id: child, parents: [item.id, ...item.parents] });
+          });
+        }
+        marked.set(item.id, true);
+      }
+    });
+  }
+
+  /**
+   * Finds a cycle in the graph.
+   *
+   * @returns {NodeID[] | null} The cycle if found, otherwise `null`.
+   * Uses non-recursive DFS.
+   */
+  findCycle(): NodeID[] | null {
+    const visited = new Set<NodeID>();
+    const nodeStack = new Set<NodeID>();
+    const parents = new Map<NodeID, NodeID>();
+
+    for (const nodeId of this.nodes.keys()) {
+      if (visited.has(nodeId)) {
+        continue;
+      }
+
+      const callStack: { nodeId: NodeID; parentId: NodeID | null }[] = [];
+      callStack.push({ nodeId: nodeId, parentId: null });
+      while (callStack.length > 0) {
+        const { nodeId, parentId } = callStack[callStack.length - 1];
+        if (visited.has(nodeId)) {
+          nodeStack.delete(nodeId);
+          callStack.pop();
+          continue;
+        }
+        visited.add(nodeId);
+        nodeStack.add(nodeId);
+        if (parentId !== null) {
+          parents.set(nodeId, parentId);
+        }
+
+        const currentNode = this.nodes.get(nodeId)!;
+        for (const child of currentNode.outputs) {
+          if (!visited.has(child)) {
+            callStack.push({ nodeId: child, parentId: nodeId });
+            continue;
+          }
+          if (!nodeStack.has(child)) {
+            continue;
+          }
+          const cycle: NodeID[] = [];
+          let current = nodeId;
+          cycle.push(child);
+          while (current !== child) {
+            cycle.push(current);
+            current = parents.get(current)!;
+          }
+          cycle.push(child);
+          cycle.reverse();
+          return cycle;
+        }
+      }
+    }
+    return null;
+  }
+}

package/src/graph/index.ts

@@ -0,0 +1 @@
+export { Graph } from './graph';

package/src/index.ts

@@ -0,0 +1,96 @@
+export {
+  type EntityReference,
+  Grammeme,
+  ReferenceType,
+  supportedGrammemes,
+  type SyntacticReference,
+  type TermContext,
+  type WordForm
+} from './cctext/language';
+export { Graph } from './graph/graph';
+export { FolderNode, FolderTree } from './library/folder-tree';
+export {
+  AccessPolicy,
+  type CurrentVersion,
+  type LibraryItem,
+  type LibraryItemReference,
+  LibraryItemType,
+  LocationHead,
+  type VersionInfo
+} from './library/library';
+export type { Block } from './library/oss';
+export {
+  type CstSubstituteInfo,
+  NodeType,
+  type Operation,
+  type OperationInput,
+  type OperationSchema,
+  type OperationSchemaStats,
+  type OperationSynthesis,
+  OperationType,
+  type OssItem,
+  type SubstitutionErrorDescription,
+  SubstitutionErrorType
+} from './library/oss';
+export { type OssLayout, type Position2D } from './library/oss-layout';
+export { RSEngine } from './library/rsengine';
+export {
+  type ArgumentValue,
+  type Attribution,
+  type Constituenta,
+  CstClass,
+  CstStatus,
+  CstType,
+  type RSForm,
+  type RSFormStats,
+  type Substitution,
+  type TypeInfo
+} from './library/rsform';
+export {
+  type BasicBinding,
+  type BasicsContext,
+  DEFAULT_VALUE_TEXT,
+  EvalStatus,
+  type RSModel,
+  type RSModelStats
+} from './library/rsmodel';
+export {
+  type AstNode,
+  type AstNodeBase,
+  buildTree,
+  findByUid,
+  type FlatAST,
+  type FlatAstNode,
+  flattenAst,
+  getNodeIndices,
+  getNodeText,
+  printAst,
+  TOKEN_ERROR,
+  visitAstDFS
+} from './parsing/ast';
+export { type CMSyntaxNode, printTree } from './parsing/lezer-tree';
+export { readErrorAnnotation, readTypeAnnotation } from './rslang/ast-annotations';
+export { RSErrorCode, type RSErrorDescription } from './rslang/error';
+export { type CalculatorEvaluateOptions, type CalculatorResult, RSCalculator } from './rslang/eval/calculator';
+export { makeValuePath, type Value, type ValuePath } from './rslang/eval/value';
+export { printValue } from './rslang/eval/value-api';
+export { parser as rslangParser } from './rslang/parser/parser';
+export { TokenID } from './rslang/parser/token';
+export { type AnalysisBase, type AnalysisFast, type AnalysisFull, RSLangAnalyzer } from './rslang/semantic/analyzer';
+export { type ArgumentsType } from './rslang/semantic/arguments-extractor';
+export {
+  AnyTypificationT,
+  EmptySetT,
+  type ExpressionType,
+  LogicT,
+  makeTypePath,
+  TypeClass,
+  TypeID,
+  type TypePath,
+  type Typification
+} from './rslang/semantic/typification';
+export { applyAsciiTypeSubstitutions, parseTypeText } from './rslang/semantic/typification-parser';
+export { ValueClass } from './rslang/semantic/value-class';
+export { TypificationGraph, type TypificationNodeData } from './rslang/typification-graph';
+export { type Branded } from './shared/branded';
+export { applyHash_fnv1a, generateStub } from './shared/hash';

package/src/library/folder-tree.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from 'vitest';
+
+import { FolderTree } from './folder-tree';
+
+describe('Testing Tree construction', () => {
+  it('empty Tree should be empty', () => {
+    const tree = new FolderTree();
+    expect(tree.roots.size).toBe(0);
+  });
+
+  it('constructing from paths', () => {
+    const tree = new FolderTree(['/S', '/S/project1/123', '/U']);
+    expect(tree.roots.size).toBe(2);
+    expect(tree.roots.get('S')?.children.size).toBe(1);
+  });
+});
+
+describe('Testing Tree editing', () => {
+  it('add invalid path', () => {
+    const tree = new FolderTree();
+    expect(() => tree.addPath('invalid')).toThrow(Error);
+  });
+
+  it('add valid path', () => {
+    const tree = new FolderTree();
+    const node = tree.addPath('/S/test');
+    expect(node.getPath()).toBe('/S/test');
+    expect(node.filesInside).toBe(1);
+    expect(node.filesTotal).toBe(1);
+
+    expect(node.parent?.getPath()).toBe('/S');
+    expect(node.parent?.filesInside).toBe(0);
+    expect(node.parent?.filesTotal).toBe(1);
+  });
+
+  it('incrementing counter', () => {
+    const tree = new FolderTree();
+    const node1 = tree.addPath('/S/test', 0);
+    expect(node1.filesInside).toBe(0);
+    expect(node1.filesTotal).toBe(0);
+
+    const node2 = tree.addPath('/S/test', 2);
+    expect(node1).toBe(node2);
+    expect(node2.filesInside).toBe(2);
+    expect(node2.filesTotal).toBe(2);
+  });
+});