@rsconcept/domain 1.0.0

package/src/library/structure-planner.ts

@@ -0,0 +1,143 @@
+import { makeTypePath, TypeID, type TypePath, type Typification } from '../rslang';
+import { splitTemplateDefinition } from '../rslang/api';
+import { labelType } from '../rslang/labels';
+import { bool, type EchelonFunctional, isTypification } from '../rslang/semantic/typification';
+
+import { type Constituenta, CstType, type RSForm } from './rsform';
+import { findCstByStructure } from './rsform-api';
+
+/** Represents a node in the structure planner. */
+export interface SPNode {
+  key: string;
+  path: TypePath;
+  type: Typification;
+  parent: number | null;
+  definition: string;
+  existing: Constituenta | null;
+}
+
+/** Structure planner for {@link Constituenta}. */
+export class StructurePlanner {
+  private items: SPNode[] = [];
+  private schema: RSForm;
+  private target: Constituenta;
+  private rootType: Typification;
+
+  constructor(schema: RSForm, target: Constituenta) {
+    const eff = target.effectiveType;
+    if (eff == null) {
+      throw new Error('Invalid typification for target');
+    }
+    this.schema = schema;
+    this.target = target;
+    if (target.cst_type === CstType.FUNCTION && !isTypification(eff)) {
+      this.rootType = (eff as EchelonFunctional).result;
+    } else if (isTypification(eff)) {
+      this.rootType = eff as Typification;
+    } else {
+      throw new Error('Invalid typification for target');
+    }
+  }
+
+  public build(): SPNode[] {
+    this.items.push({
+      key: 'root',
+      path: makeTypePath([]),
+      type: this.rootType,
+      parent: null,
+      definition: labelType(this.target.effectiveType),
+      existing: this.target
+    });
+    this.visit(this.rootType, this.rootType.typeID === TypeID.collection ? [0] : [], 0);
+    return this.items;
+  }
+
+  private visit(type: Typification, path: number[], parent: number) {
+    switch (type.typeID) {
+      case TypeID.collection:
+        if (type.base.typeID === TypeID.tuple) {
+          type.base.factors.forEach((factor, index) => {
+            const nextPath = [...path, index + 1];
+            const nextType = bool(factor);
+            const nextNode = this.pushNode(nextPath, nextType, parent);
+            this.visit(nextType, nextPath, nextNode);
+          });
+        } else if (type.base.typeID === TypeID.collection) {
+          const nextPath = [...path, 0];
+          const nextNode = this.pushNode(nextPath, type.base, parent);
+          this.visit(type.base, nextPath, nextNode);
+        }
+        return;
+      case TypeID.tuple:
+        type.factors.forEach((factor, index) => {
+          const nextPath = [...path, index + 1];
+          const nextNode = this.pushNode(nextPath, factor, parent);
+          this.visit(factor, nextPath, nextNode);
+        });
+        return;
+      default:
+        return;
+    }
+  }
+
+  private pushNode(path: number[], type: Typification, parent: number) {
+    const typePath = makeTypePath(path);
+    this.items.push({
+      key: formatPathText(typePath),
+      path: typePath,
+      type: type,
+      parent: parent,
+      definition: produceDefinition(this.target, this.rootType, typePath),
+      existing: findCstByStructure(this.schema, this.target, typePath)
+    });
+    return this.items.length - 1;
+  }
+}
+
+// ======= Internals =======
+function produceDefinition(target: Constituenta, rootType: Typification, path: TypePath): string {
+  let current = rootType;
+  let expression = target.alias;
+  let index = rootType.typeID === TypeID.collection ? 1 : 0;
+  let prefix = '';
+  if (target.cst_type === CstType.FUNCTION) {
+    prefix = `[${splitTemplateDefinition(target.definition_formal).head}] `;
+    const funcType =
+      target.effectiveType && !isTypification(target.effectiveType)
+        ? (target.effectiveType as EchelonFunctional)
+        : null;
+    if (funcType) {
+      expression = `${expression}[${funcType.args.map(arg => arg.alias).join(', ')}]`;
+    }
+  }
+
+  while (index < path.length) {
+    const step = path[index];
+    switch (current.typeID) {
+      case TypeID.collection:
+        if (current.base.typeID === TypeID.tuple) {
+          expression = `Pr${step}(${expression})`;
+          current = bool(current.base.factors[step - 1]);
+          index += 1;
+        } else {
+          expression = `red(${expression})`;
+          current = current.base;
+          index += 1;
+        }
+        break;
+      case TypeID.tuple:
+        expression = `pr${step}(${expression})`;
+        current = current.factors[step - 1];
+        index += 1;
+        break;
+      default:
+        return prefix + expression;
+    }
+  }
+
+  return prefix + expression;
+}
+
+function formatPathText(path: TypePath): string {
+  return path.map(step => String(step)).join('.');
+}

package/src/parsing/ast.ts

@@ -0,0 +1,136 @@
+import { type TreeCursor } from './lezer-tree';
+
+export const TOKEN_ERROR = 0;
+
+/** Represents AST node data. */
+interface AstNodeData extends Record<string, unknown> {
+  dataType: string;
+  value: unknown;
+}
+
+/** Represents AST structured node base. */
+export interface AstNodeBase {
+  typeID: number;
+  data: AstNodeData;
+  annotation?: Record<string, unknown>;
+}
+
+/** Represents AST structured node. */
+export interface AstNode extends Record<string, unknown>, AstNodeBase {
+  uid: number;
+  from: number;
+  to: number;
+  hasError: boolean;
+  parenthesis?: boolean;
+  parent: AstNode | null;
+  children: AstNode[];
+}
+
+/** Represents AST node. */
+export interface FlatAstNode extends Record<string, unknown>, AstNodeBase {
+  uid: number;
+  parent: number | null;
+  from: number;
+  to: number;
+}
+
+/** Represents Syntax tree flat representation. */
+export type FlatAST = FlatAstNode[];
+
+/** Builds AST tree from a given tree cursor, generating unique uids for each node. */
+export function buildTree(cursor: TreeCursor): AstNode {
+  let nextUid = 1;
+  function genUid() {
+    return nextUid++;
+  }
+  return buildTreeInternal(cursor, null, genUid);
+}
+
+/** Flattens AST tree to a array form. */
+export function flattenAst(node: AstNode, parent: number | null = null, out: FlatAST = []): FlatAST {
+  out.push({
+    uid: node.uid,
+    parent: parent,
+    typeID: node.typeID,
+    from: node.from,
+    to: node.to,
+    data: node.data,
+    annotation: node.annotation
+  });
+  for (const child of node.children) {
+    flattenAst(child, node.uid, out);
+  }
+  return out;
+}
+
+/** Visits AST tree in depth-first order. */
+export function visitAstDFS(node: AstNode, callback: (node: AstNode) => void) {
+  for (const child of node.children) {
+    visitAstDFS(child, callback);
+  }
+  callback(node);
+}
+
+/** Finds and returns the AstNode with the given ui. */
+export function findByUid(root: AstNode, uid: number): AstNode | null {
+  let found: AstNode | null = null;
+  visitAstDFS(root, node => {
+    if (node.uid === uid && !found) {
+      found = node;
+    }
+  });
+  return found;
+}
+
+/** Prints AST tree. */
+export function printAst(node: AstNode, printNode: (node: AstNode) => string): string {
+  let children: string = '';
+  for (const child of node.children) {
+    children += `${printAst(child, printNode)}`;
+  }
+  return `[${printNode(node)}${children}]`;
+}
+
+/** Extracts node text. */
+export function getNodeText(node: AstNode): string {
+  if (node.data.dataType === 'string' && typeof node.data.value === 'string') {
+    return node.data.value;
+  }
+  return `NO DATA NODE: ${node.typeID}`;
+}
+
+/** Extracts node indices. */
+export function getNodeIndices(node: AstNode): number[] {
+  if (node.data.dataType === 'string[]' && Array.isArray(node.data.value)) {
+    return (node.data.value as string[]).map(s => parseInt(s, 10)).filter(n => !isNaN(n));
+  }
+  return [];
+}
+
+// ======== Internals ========
+function buildTreeInternal(cursor: TreeCursor, parent: AstNode | null = null, genUid: () => number): AstNode {
+  const node = cursor.node;
+
+  const result: AstNode = {
+    uid: genUid(),
+    typeID: node.type.isError ? 0 : node.type.id,
+    from: node.from,
+    to: node.to,
+    hasError: node.type.isError,
+    data: node.type.isError ? { dataType: 'null', value: null } : { dataType: 'string', value: node.type.name },
+    parent,
+    children: []
+  };
+
+  if (cursor.firstChild()) {
+    do {
+      const child = buildTreeInternal(cursor, result, genUid);
+      if (child.hasError) {
+        result.hasError = true;
+      }
+      result.children.push(child);
+    } while (cursor.nextSibling());
+    cursor.parent();
+  }
+  return result;
+}

package/src/parsing/index.ts

@@ -0,0 +1,15 @@
+export {
+  type AstNode,
+  type AstNodeBase,
+  buildTree,
+  findByUid,
+  type FlatAST,
+  type FlatAstNode,
+  flattenAst,
+  getNodeIndices,
+  getNodeText,
+  printAst,
+  TOKEN_ERROR,
+  visitAstDFS
+} from './ast';
+export { type CMSyntaxNode, printTree } from './lezer-tree';

package/src/parsing/lezer-tree.ts

@@ -0,0 +1,69 @@
+import { type NodeType, type Tree, type TreeCursor } from '@lezer/common';
+export { type TreeCursor } from '@lezer/common';
+
+/** Represents syntax tree node data. */
+export interface CMSyntaxNode {
+  type: NodeType;
+  from: number;
+  to: number;
+}
+
+/** Prints tree to compact string. */
+export function printTree(tree: Tree): string {
+  const state = {
+    output: '',
+    prefixes: [] as string[]
+  };
+  traverseTree(tree, {
+    onEnter: node => {
+      state.output += '[';
+      state.output += node.type.name;
+    },
+    onLeave: () => {
+      state.output += ']';
+    }
+  });
+  return state.output;
+}
+
+// ======== Internals ========
+
+interface CursorNode extends CMSyntaxNode {
+  isLeaf: boolean;
+}
+
+function cursorNode({ type, from, to }: TreeCursor, isLeaf = false): CursorNode {
+  return { type, from, to, isLeaf };
+}
+
+interface TreeTraversalOptions {
+  beforeEnter?: (cursor: TreeCursor) => void;
+  onEnter: (node: CursorNode) => false | void;
+  onLeave?: (node: CursorNode) => false | void;
+}
+
+/** Implements depth-first traversal. */
+function traverseTree(tree: Tree, { beforeEnter, onEnter, onLeave }: TreeTraversalOptions) {
+  const cursor = tree.cursor();
+  for (;;) {
+    let node = cursorNode(cursor);
+    let leave = false;
+    const enter = !node.type.isAnonymous;
+    if (enter && beforeEnter) beforeEnter(cursor);
+    node.isLeaf = !cursor.firstChild();
+    if (enter) {
+      leave = true;
+      if (onEnter(node) === false) return;
+    }
+    if (!node.isLeaf) continue;
+    for (;;) {
+      node = cursorNode(cursor, node.isLeaf);
+      if (leave && onLeave) if (onLeave(node) === false) return;
+      leave = cursor.type.isAnonymous;
+      node.isLeaf = false;
+      if (cursor.nextSibling()) break;
+      if (!cursor.parent()) return;
+      leave = true;
+    }
+  }
+}

package/src/rslang/api.test.ts

@@ -0,0 +1,116 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  applyTypificationMapping,
+  extractGlobals,
+  isSetTypification,
+  isSimpleExpression,
+  splitTemplateDefinition
+} from './api';
+
+const globalsData: [string, string][] = [
+  ['', ''],
+  ['X1', 'X1'],
+  ['X11 X1 X11', 'X11 X1'],
+  ['∀α∈S1 ∀β∈F1[α] Pr1,1(β)∩β=∅', 'S1 F1']
+];
+
+describe('Testing extract globals', () => {
+  globalsData.forEach(([input, expected]) => {
+    it(`Extract globals "${input}"`, () => {
+      const result = extractGlobals(input);
+      expect([...result].join(' ')).toBe(expected);
+    });
+  });
+});
+
+const simpleExpressionData: [string, string][] = [
+  ['', 'true'],
+  ['Pr1(S1)', 'true'],
+  ['pr1(S1)', 'true'],
+  ['red(S1)', 'true'],
+  ['red(Pr1(F1[α,σ]))', 'true'],
+  ['ℬℬ(X1)', 'false'],
+  ['ℬ(X1)', 'false'],
+  ['D{(α,β)∈D6×D6 | α≠β & α∩β≠∅}', 'false'],
+  ['D{ξ ∈ X1 | (ξ,ξ)∈S1 }', 'false'],
+  ['I{(β,α) | α:∈D2; σ:=F5[α]; β:∈σ}', 'false'],
+  ['∀σ∈S1 (F1[σ]×F1[σ])∩D11=∅', 'false']
+];
+
+describe('Testing simple expression', () => {
+  simpleExpressionData.forEach(([input, expected]) => {
+    it(`isSimpleExpression "${input}"`, () => {
+      const result = isSimpleExpression(input);
+      expect(String(result)).toBe(expected);
+    });
+  });
+});
+
+const splitData: [string, string][] = [
+  ['', '||'],
+  ['[α∈ℬ(R1)] α⊆red(σ)', 'α∈ℬ(R1)||α⊆red(σ)'],
+  ['[α∈ℬ(R1)] α⊆red(σ) ', 'α∈ℬ(R1)||α⊆red(σ)'],
+  [' [α∈ℬ(R1)] α⊆red(σ)', 'α∈ℬ(R1)||α⊆red(σ)'],
+  ['[α∈ℬ(R1)]α⊆red(σ)', 'α∈ℬ(R1)||α⊆red(σ)'],
+  ['[α∈ℬ(R1), σ∈ℬℬ(R1)] α⊆red(σ)', 'α∈ℬ(R1), σ∈ℬℬ(R1)||α⊆red(σ)']
+];
+
+describe('Testing split template', () => {
+  splitData.forEach(([input, expected]) => {
+    it(`Split "${input}"`, () => {
+      const result = splitTemplateDefinition(input);
+      expect(`${result.head}||${result.body}`).toBe(expected);
+    });
+  });
+});
+
+const typificationMappingData: [string, string, string, string][] = [
+  ['', '', '', ''],
+  ['X1', 'X2', 'X1', 'X2'],
+  ['X1', 'X2', 'ℬ(X1)', 'ℬ(X2)'],
+  ['X1', 'X2', 'X1×X3', 'X2×X3'],
+  ['X1', '(X1×X1)', 'X1', 'X1×X1'],
+  ['X1', '(X1×X1)', 'ℬ(X1)', 'ℬ(X1×X1)'],
+  ['X1', '(X1×X1)', 'ℬ(X1×X2)', 'ℬ((X1×X1)×X2)'],
+  ['X1', 'ℬ(X3)', 'ℬ(X1)', 'ℬℬ(X3)'],
+  ['X1', 'ℬ(X3)', 'ℬ(X1×X1)', 'ℬ(ℬ(X3)×ℬ(X3))']
+];
+
+describe('Testing typification mapping', () => {
+  typificationMappingData.forEach(([original, replacement, input, expected]) => {
+    it(`Apply typification mapping: ${original} -> ${replacement} in "${input}"`, () => {
+      const result = applyTypificationMapping(input, { [original]: replacement });
+      expect(result).toBe(expected);
+    });
+  });
+});
+describe('Testing isSetTypification', () => {
+  const isSetTypificationData: [string, boolean][] = [
+    ['ℬ(X1)', true],
+    ['ℬ(C1)', true],
+    ['ℬ(Z)', true],
+    ['ℬ(ℬ(X1))', true],
+    ['ℬ(X1×X2)', true],
+    ['ℬ(X1×Z)', true],
+    ['ℬ(X1×C1)', true],
+    ['ℬℬ(X1×X2)', true],
+    ['ℬℬ(ℬ(X1×X2)×ℬ(X2))', true],
+    ['ℬ(ℬ(X1×X2)×ℬ(X2))', true],
+    ['ℬ(ℬℬ(X1×X2)×ℬ(X2))', true],
+    ['Z', false],
+    ['С1', false],
+    ['X1', false],
+    ['X1×X2', false],
+    ['ℬ(', false],
+    ['ℬX1', false],
+    ['', false],
+    ['ℬ(ℬ(X1×X2)×ℬ(X2)×X42)', true]
+  ];
+
+  isSetTypificationData.forEach(([input, expected]) => {
+    it(`isSetTypification("${input}") should be ${expected}`, () => {
+      expect(isSetTypification(input)).toBe(expected);
+    });
+  });
+});

package/src/rslang/api.ts

@@ -0,0 +1,183 @@
+/**
+ * Module: API for RSLanguage.
+ */
+import { type AstNode } from '../parsing';
+
+import { ArgumentsExtractor, type ArgumentsType } from './semantic/arguments-extractor';
+export { generateExpressionFromAst } from './parser/expression-generator';
+
+/** Represents alias mapping. */
+export type AliasMapping = Record<string, string>;
+
+// cspell:disable
+const LOCALS_REGEXP = /[_a-zα-ω][a-zα-ω]*\d*/g;
+const GLOBALS_REGEXP = /[XCSADFPTN]\d+/g;
+const COMPLEX_SYMBOLS_REGEXP = /[∀∃×ℬ;|:]/g;
+const TYPIFICATION_SET = /^ℬ+\([ℬ\(((X|C)\d+|Z)\)×]*\)$/g;
+// cspell:enable
+
+/** Extract arguments from AST. */
+export function extractArguments(ast: AstNode): ArgumentsType[] {
+  return new ArgumentsExtractor().run(ast);
+}
+
+/** Extracts global variable names from a given expression. */
+export function extractGlobals(expression: string): Set<string> {
+  return new Set(expression.match(GLOBALS_REGEXP) ?? []);
+}
+
+/** Check if expression is simple derivation. */
+export function isSimpleExpression(text: string): boolean {
+  return !text.match(COMPLEX_SYMBOLS_REGEXP);
+}
+
+/** Check if expression is set typification. */
+export function isSetTypification(text: string): boolean {
+  return !!text.match(TYPIFICATION_SET);
+}
+
+/**
+ * Splits a string containing a template definition into its head and body parts.
+ *
+ * A template definition is expected to have the following format: `[head] body`.
+ * If the input string does not contain the opening square bracket '[', the entire
+ * string is treated as the body, and an empty string is assigned to the head.
+ * If the opening bracket is present, the function attempts to find the matching
+ * closing bracket ']' to determine the head and body parts.
+ *
+ * @example
+ * const template = '[header] body content';
+ * const result = splitTemplateDefinition(template);
+ * // result: `{ head: 'header', body: 'body content' }`
+ */
+export function splitTemplateDefinition(target: string) {
+  let start = 0;
+  for (; start < target.length && target[start] !== '['; ++start);
+  if (start < target.length) {
+    for (let counter = 0, end = start + 1; end < target.length; ++end) {
+      if (target[end] === '[') {
+        ++counter;
+      } else if (target[end] === ']') {
+        if (counter !== 0) {
+          --counter;
+        } else {
+          return {
+            head: target.substring(start + 1, end).trim(),
+            body: target.substring(end + 1).trim()
+          };
+        }
+      }
+    }
+  }
+  return {
+    head: '',
+    body: target
+  };
+}
+
+/**
+ * Substitutes values for template arguments in a given expression.
+ *
+ * This function takes an input mathematical expression and a list of argument values.
+ * It replaces template argument placeholders in the expression with their corresponding values
+ * from the provided arguments.
+ */
+export function substituteTemplateArgs(expression: string, mapping: AliasMapping): string {
+  if (Object.keys(mapping).length === 0) {
+    return expression;
+  }
+  let { head, body } = splitTemplateDefinition(expression);
+  body = applyPattern(body, mapping, LOCALS_REGEXP);
+  const argTexts = head.split(',').map(text => text.trim());
+  head = argTexts
+    .filter(arg => [...arg.matchAll(LOCALS_REGEXP)].every(local => local.every(match => !(match in mapping))))
+    .join(', ');
+
+  if (!head) {
+    return body;
+  } else {
+    return `[${head}] ${body}`;
+  }
+}
+
+/** Apply alias mapping. */
+export function applyAliasMapping(target: string, mapping: AliasMapping): string {
+  return applyPattern(target, mapping, GLOBALS_REGEXP);
+}
+
+/** Apply alias typification mapping. */
+export function applyTypificationMapping(target: string, mapping: AliasMapping): string {
+  const modified = applyAliasMapping(target, mapping);
+  if (modified === target) {
+    return target;
+  }
+
+  const deleteBrackets: number[] = [];
+  const positions: number[] = [];
+  const booleans: number[] = [];
+  let boolCount: number = 0;
+  let stackSize: number = 0;
+
+  for (let i = 0; i < modified.length; i++) {
+    const char = modified[i];
+    if (char === 'ℬ') {
+      boolCount++;
+      continue;
+    }
+    if (char === '(') {
+      stackSize++;
+      positions.push(i);
+      booleans.push(boolCount);
+    }
+    boolCount = 0;
+    if (char === ')') {
+      if (
+        i < modified.length - 1 &&
+        modified[i + 1] === ')' &&
+        stackSize > 1 &&
+        positions[stackSize - 2] + booleans[stackSize - 1] + 1 === positions[stackSize - 1]
+      ) {
+        deleteBrackets.push(i);
+        deleteBrackets.push(positions[stackSize - 2]);
+      }
+      if (i === modified.length - 1 && stackSize === 1 && positions[0] === 0) {
+        deleteBrackets.push(i);
+        deleteBrackets.push(positions[0]);
+      }
+      stackSize--;
+      positions.pop();
+      booleans.pop();
+    }
+  }
+
+  let result = '';
+  for (let i = 0; i < modified.length; i++) {
+    if (!deleteBrackets.includes(i)) {
+      result += modified[i];
+    }
+  }
+
+  return result;
+}
+
+// ====== Internals =========
+/** Text substitution guided by mapping and regular expression. */
+function applyPattern(text: string, mapping: AliasMapping, pattern: RegExp): string {
+  if (text === '' || pattern === null) {
+    return text;
+  }
+  let posInput = 0;
+  let output = '';
+  const patternMatches = text.matchAll(pattern);
+  for (const segment of patternMatches) {
+    const entity = segment[0];
+    const start = segment.index ?? 0;
+    if (entity in mapping) {
+      output += text.substring(posInput, start);
+      output += mapping[entity];
+      posInput = start + segment[0].length;
+    }
+  }
+  output += text.substring(posInput);
+  return output;
+}