@rsconcept/domain 1.0.0 → 1.2.0

package/README.md

@@ -36,7 +36,7 @@ The root entry (`@rsconcept/domain`) re-exports the most common names. Subpath i
 
 ```bash
 npm run generate    # regenerates Lezer parser from rslang.grammar
-npm run build       # produces ./dist via tsup
+npm run build       # produces ./dist via tsdown
 npm test            # vitest run
 npm run typecheck   # tsc --noEmit
 npm run lint        # ESLint (TypeScript; same core rules as frontend, no React)
@@ -46,9 +46,9 @@ npm run format:check
 
 After editing `src/rslang/parser/rslang.grammar`, always run `npm run generate` before committing.
 
-## Server-side mirrors
+## Publishing
 
-Some helpers in this package are duplicated in the Concept Portal Django backend (`api_RSLanguage.py`, `graph.py`, `SemanticInfo.py`). Those Python mirrors implement a narrow subset for ORM-level operations and are maintained separately. Parsing and evaluation only run in TypeScript.
+Maintainers: see [PUBLISHING.md](./PUBLISHING.md) for npm release steps.
 
 ## License
 

package/dist/analyzer-DlSq3Y3r.d.ts

@@ -0,0 +1,39 @@
+import { t as AstNode } from "./ast-C8sIpKdL.js";
+import { f as ExpressionType, g as TypeClass } from "./typification-Dk-fisgO.js";
+import { i as RSErrorDescription } from "./error-E1LVq_3w.js";
+import { t as ValueClass } from "./value-class-CNI-lqXJ.js";
+
+//#region src/rslang/semantic/analyzer.d.ts
+interface AnalysisBase {
+  success: boolean;
+  type: ExpressionType | null;
+  valueClass: ValueClass | null;
+}
+interface AnalysisFast extends AnalysisBase {
+  ast: AstNode | null;
+}
+interface AnalysisFull extends AnalysisBase {
+  ast: AstNode | null;
+  errors: RSErrorDescription[];
+}
+interface AnalysisOptions {
+  expected?: TypeClass;
+  isDomain?: boolean;
+  annotateTypes?: boolean;
+  annotateErrors?: boolean;
+}
+declare class RSLangAnalyzer {
+  private typeContext;
+  private valueContext;
+  private typeAuditor;
+  private valueAuditor;
+  addBase(alias: string, isNumeric?: boolean, valueClass?: ValueClass): void;
+  setGlobal(alias: string, type: ExpressionType | null, value: ValueClass | null): void;
+  getType(alias: string): ExpressionType | null;
+  checkFast(expression: string, options?: AnalysisOptions): AnalysisFast;
+  checkFull(expression: string, options?: AnalysisOptions): AnalysisFull;
+  private parse;
+}
+//#endregion
+export { RSLangAnalyzer as a, AnalysisOptions as i, AnalysisFast as n, AnalysisFull as r, AnalysisBase as t };
+//# sourceMappingURL=analyzer-DlSq3Y3r.d.ts.map

package/dist/arguments-extractor-1acwjQNc.d.ts

@@ -0,0 +1,38 @@
+import { t as AstNode } from "./ast-C8sIpKdL.js";
+import { f as ExpressionType } from "./typification-Dk-fisgO.js";
+
+//#region src/rslang/semantic/arguments-extractor.d.ts
+/** Represents function argument definition. */
+interface ArgumentsType {
+  alias: string;
+  type: ExpressionType | null;
+}
+/** Type auditor for AST type checking.
+ * Warning! Assumes that the AST is well-formed and annotated with types.
+ */
+declare class ArgumentsExtractor {
+  private locals;
+  private result;
+  run(ast: AstNode): ArgumentsType[];
+  private dispatchDeclare;
+  private processDeclare;
+  private declareLocal;
+  private declareTuple;
+  private declareEnumeration;
+  private dispatchVisit;
+  private processVisit;
+  private visitChild;
+  private visitChildDeclaration;
+  private visitAllAndReturn;
+  private visitLocal;
+  private visitFunctionDefinition;
+  private visitFunctionCall;
+  private visitArgument;
+  private visitQuantifier;
+  private visitImperative;
+  private visitIterate;
+  private visitRecursion;
+}
+//#endregion
+export { ArgumentsType as n, ArgumentsExtractor as t };
+//# sourceMappingURL=arguments-extractor-1acwjQNc.d.ts.map

package/dist/ast-C8sIpKdL.d.ts

@@ -0,0 +1,51 @@
+import { n as TreeCursor } from "./lezer-tree-iS7LpLBJ.js";
+
+//#region src/parsing/ast.d.ts
+declare const TOKEN_ERROR = 0;
+/** Represents AST node data. */
+interface AstNodeData extends Record<string, unknown> {
+  dataType: string;
+  value: unknown;
+}
+/** Represents AST structured node base. */
+interface AstNodeBase {
+  typeID: number;
+  data: AstNodeData;
+  annotation?: Record<string, unknown>;
+}
+/** Represents AST structured node. */
+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. */
+interface FlatAstNode extends Record<string, unknown>, AstNodeBase {
+  uid: number;
+  parent: number | null;
+  from: number;
+  to: number;
+}
+/** Represents Syntax tree flat representation. */
+type FlatAST = FlatAstNode[];
+/** Builds AST tree from a given tree cursor, generating unique uids for each node. */
+declare function buildTree(cursor: TreeCursor): AstNode;
+/** Flattens AST tree to a array form. */
+declare function flattenAst(node: AstNode, parent?: number | null, out?: FlatAST): FlatAST;
+/** Visits AST tree in depth-first order. */
+declare function visitAstDFS(node: AstNode, callback: (node: AstNode) => void): void;
+/** Finds and returns the AstNode with the given ui. */
+declare function findByUid(root: AstNode, uid: number): AstNode | null;
+/** Prints AST tree. */
+declare function printAst(node: AstNode, printNode: (node: AstNode) => string): string;
+/** Extracts node text. */
+declare function getNodeText(node: AstNode): string;
+/** Extracts node indices. */
+declare function getNodeIndices(node: AstNode): number[];
+//#endregion
+export { TOKEN_ERROR as a, flattenAst as c, printAst as d, visitAstDFS as f, FlatAstNode as i, getNodeIndices as l, AstNodeBase as n, buildTree as o, FlatAST as r, findByUid as s, AstNode as t, getNodeText as u };
+//# sourceMappingURL=ast-C8sIpKdL.d.ts.map

package/dist/ast-annotations-BiMjkKvz.d.ts

@@ -0,0 +1,16 @@
+import { t as AstNode } from "./ast-C8sIpKdL.js";
+import { f as ExpressionType } from "./typification-Dk-fisgO.js";
+import { a as RSErrorInfo, r as RSErrorCode } from "./error-E1LVq_3w.js";
+
+//#region src/rslang/ast-annotations.d.ts
+/** Appends {@link ExpressionType} onto the node's `annotation.rsType`. */
+declare function annotateType(node: AstNode, type: ExpressionType): void;
+/** Reads {@link ExpressionType} from node's `annotation`. */
+declare function readTypeAnnotation(node: AstNode): ExpressionType | null;
+/** Appends {@link RSErrorInfo} onto the node's `annotation.rsErrors` if not already set. */
+declare function annotateError(node: AstNode, code: RSErrorCode, params?: readonly string[]): void;
+/** Reads validated {@link RSErrorInfo} entry from node's `annotation`. */
+declare function readErrorAnnotation(node: AstNode): RSErrorInfo | null;
+//#endregion
+export { readTypeAnnotation as i, annotateType as n, readErrorAnnotation as r, annotateError as t };
+//# sourceMappingURL=ast-annotations-BiMjkKvz.d.ts.map

package/dist/branded-ZlzIcxzu.d.ts

@@ -0,0 +1,9 @@
+//#region src/shared/branded.d.ts
+declare const brand: unique symbol;
+/** Branded strict type. No runtime consequences. */
+type Branded<T, BrandT> = T & {
+  readonly [brand]: BrandT;
+};
+//#endregion
+export { Branded as t };
+//# sourceMappingURL=branded-ZlzIcxzu.d.ts.map

package/dist/calculator-C9W2jkSx.d.ts

@@ -0,0 +1,39 @@
+import { t as AstNode } from "./ast-C8sIpKdL.js";
+import { f as ExpressionType } from "./typification-Dk-fisgO.js";
+import { i as RSErrorDescription } from "./error-E1LVq_3w.js";
+import { c as Value } from "./value-CTjX6825.js";
+
+//#region src/rslang/eval/calculator.d.ts
+/** Result of calculator evaluation. */
+interface CalculatorResult {
+  value: Value | null;
+  iterations: number;
+  cacheHits: number;
+  errors: RSErrorDescription[];
+}
+/** Options for {@link RSCalculator.evaluateFull}. */
+interface CalculatorEvaluateOptions {
+  annotateErrors?: boolean;
+  disableCache?: boolean;
+}
+type Listener = () => void;
+/** AST calculator - evaluates RS expressions via visitor pattern and provides updates via listeners. */
+declare class RSCalculator {
+  private context;
+  private treeContext;
+  private evaluator;
+  private listeners;
+  subscribe: (alias: string, listener: Listener) => () => void;
+  setValue(alias: string, value: Value): void;
+  resetValue(alias: string): void;
+  clearAllAst(): void;
+  getValue(alias: string): Value | null;
+  setAST(alias: string, ast: AstNode): void;
+  validate(value: Value, type: ExpressionType): boolean;
+  evaluateFast(ast: AstNode): Value | null;
+  evaluateFull(ast: AstNode, options?: CalculatorEvaluateOptions): CalculatorResult;
+  private notify;
+}
+//#endregion
+export { CalculatorResult as n, RSCalculator as r, CalculatorEvaluateOptions as t };
+//# sourceMappingURL=calculator-C9W2jkSx.d.ts.map

package/dist/cctext/index.d.ts

@@ -1 +1,2 @@
-export { EntityReference, Grammeme, ReferenceType, SyntacticReference, TermContext, WordForm, supportedGrammemes } from './language.js';
+import { EntityReference, Grammeme, ReferenceType, SyntacticReference, TermContext, WordForm, supportedGrammemes } from "./language.js";
+export { type EntityReference, Grammeme, ReferenceType, type SyntacticReference, type TermContext, type WordForm, supportedGrammemes };

package/dist/cctext/index.js

@@ -1,42 +1,2 @@
-// src/cctext/language.ts
-var Grammeme = {
-  // Число
-  sing: "sing",
-  plur: "plur",
-  // Падеж
-  nomn: "nomn",
-  gent: "gent",
-  datv: "datv",
-  accs: "accs",
-  ablt: "ablt",
-  loct: "loct"
-};
-var Case = [
-  Grammeme.nomn,
-  Grammeme.gent,
-  Grammeme.datv,
-  Grammeme.accs,
-  Grammeme.ablt,
-  Grammeme.loct
-];
-var Plurality = [Grammeme.sing, Grammeme.plur];
-var supportedGrammemes = [
-  Grammeme.sing,
-  Grammeme.plur,
-  Grammeme.nomn,
-  Grammeme.gent,
-  Grammeme.datv,
-  Grammeme.accs,
-  Grammeme.ablt,
-  Grammeme.loct
-];
-var ReferenceType = {
-  ENTITY: "entity",
-  SYNTACTIC: "syntax"
-};
-export {
-  Grammeme,
-  ReferenceType,
-  supportedGrammemes
-};
-//# sourceMappingURL=index.js.map
+import { Grammeme, ReferenceType, supportedGrammemes } from "./language.js";
+export { Grammeme, ReferenceType, supportedGrammemes };

package/dist/cctext/language-api.d.ts

@@ -1,15 +1,12 @@
-import { EntityReference, Grammeme, IReference, SyntacticReference, TermContext, WordForm } from './language.js';
-
-/**
- * Module: Natural language model API.
- */
+import { EntityReference, Grammeme, IReference, SyntacticReference, TermContext, WordForm } from "./language.js";
 
+//#region src/cctext/language-api.d.ts
 /** Represents generated lexeme forms. */
 interface Lexeme {
-    items: {
-        text: string;
-        grams: string;
-    }[];
+  items: {
+    text: string;
+    grams: string;
+  }[];
 }
 /** Equality comparator for {@link WordForm}. Compares a set of Grammemes attached to wordforms. */
 declare function wordFormEquals(left: WordForm, right: WordForm): boolean;
@@ -17,7 +14,7 @@ declare function wordFormEquals(left: WordForm, right: WordForm): boolean;
 declare function parseGrammemes(termForm: string): Grammeme[];
 /** Generates all supported noun forms using nominal text for every form. */
 declare function generateNominalLexeme(data: {
-    text: string;
+  text: string;
 }): Lexeme;
 /**
  * Extracts {@link EntityReference} from string representation.
@@ -39,5 +36,6 @@ declare function extractEntities(text: string): string[];
 declare function resolveTextReferences(text: string, context: TermContext): string;
 /** Transforms {@link IReference} to string representation. */
 declare function referenceToString(ref: IReference): string;
-
-export { type Lexeme, extractEntities, generateNominalLexeme, parseEntityReference, parseGrammemes, parseReference, parseSyntacticReference, referenceToString, resolveTextReferences, wordFormEquals };
+//#endregion
+export { Lexeme, extractEntities, generateNominalLexeme, parseEntityReference, parseGrammemes, parseReference, parseSyntacticReference, referenceToString, resolveTextReferences, wordFormEquals };
+//# sourceMappingURL=language-api.d.ts.map