@rsconcept/domain 1.8.0 → 2.0.1

package/dist/{analyzer-DpE0qknt.d.ts → analyzer-iqAXyROE.d.ts}

@@ -1,5 +1,5 @@
 import { t as AstNode } from "./ast-C8sIpKdL.js";
-import { f as ExpressionType, g as TypeClass } from "./typification-DDuv88ir.js";
+import { f as ExpressionType, g as TypeClass } from "./typification-9lNu9R4k.js";
 import { i as RSErrorDescription } from "./error-CzIbnP-N.js";
 import { t as ValueClass } from "./value-class-CNI-lqXJ.js";
 
@@ -35,4 +35,4 @@ declare class RSLangAnalyzer {
 }
 //#endregion
 export { RSLangAnalyzer as a, AnalysisOptions as i, AnalysisFast as n, AnalysisFull as r, AnalysisBase as t };
-//# sourceMappingURL=analyzer-DpE0qknt.d.ts.map
+//# sourceMappingURL=analyzer-iqAXyROE.d.ts.map

package/dist/{arguments-extractor-Dd1lFom9.d.ts → arguments-extractor-ngatANBI.d.ts}

@@ -1,5 +1,5 @@
 import { t as AstNode } from "./ast-C8sIpKdL.js";
-import { f as ExpressionType } from "./typification-DDuv88ir.js";
+import { f as ExpressionType } from "./typification-9lNu9R4k.js";
 
 //#region src/rslang/semantic/arguments-extractor.d.ts
 /** Represents function argument definition. */
@@ -35,4 +35,4 @@ declare class ArgumentsExtractor {
 }
 //#endregion
 export { ArgumentsType as n, ArgumentsExtractor as t };
-//# sourceMappingURL=arguments-extractor-Dd1lFom9.d.ts.map
+//# sourceMappingURL=arguments-extractor-ngatANBI.d.ts.map

package/dist/{ast-annotations-CZCzs9Uk.d.ts → ast-annotations-D6KZDu12.d.ts}

@@ -1,5 +1,5 @@
 import { t as AstNode } from "./ast-C8sIpKdL.js";
-import { f as ExpressionType } from "./typification-DDuv88ir.js";
+import { f as ExpressionType } from "./typification-9lNu9R4k.js";
 import { a as RSErrorInfo, r as RSErrorCode } from "./error-CzIbnP-N.js";
 
 //#region src/rslang/ast-annotations.d.ts
@@ -13,4 +13,4 @@ declare function annotateError(node: AstNode, code: RSErrorCode, params?: readon
 declare function readErrorAnnotation(node: AstNode): RSErrorInfo | null;
 //#endregion
 export { readTypeAnnotation as i, annotateType as n, readErrorAnnotation as r, annotateError as t };
-//# sourceMappingURL=ast-annotations-CZCzs9Uk.d.ts.map
+//# sourceMappingURL=ast-annotations-D6KZDu12.d.ts.map

package/dist/{calculator-Dt03dsnd.d.ts → calculator-k8BGIKmj.d.ts}

@@ -1,5 +1,5 @@
 import { t as AstNode } from "./ast-C8sIpKdL.js";
-import { f as ExpressionType } from "./typification-DDuv88ir.js";
+import { f as ExpressionType } from "./typification-9lNu9R4k.js";
 import { i as RSErrorDescription } from "./error-CzIbnP-N.js";
 import { l as Value } from "./value-BduA_ZGp.js";
 
@@ -36,4 +36,4 @@ declare class RSCalculator {
 }
 //#endregion
 export { CalculatorResult as n, RSCalculator as r, CalculatorEvaluateOptions as t };
-//# sourceMappingURL=calculator-Dt03dsnd.d.ts.map
+//# sourceMappingURL=calculator-k8BGIKmj.d.ts.map

package/dist/diagnostics-Clo3mkba.d.ts

@@ -0,0 +1,279 @@
+import { t as Graph } from "./graph-DR8rL2o3.js";
+import { f as ExpressionType, y as TypePath } from "./typification-9lNu9R4k.js";
+import { l as Value } from "./value-BduA_ZGp.js";
+import { a as RSLangAnalyzer, t as AnalysisBase } from "./analyzer-iqAXyROE.js";
+import { i as LibraryItemReference, n as CurrentVersion, r as LibraryItem, s as VersionInfo } from "./library-CYun28Xz.js";
+
+//#region src/library/rsform.d.ts
+/** Represents {@link Constituenta} type. */
+declare const CstType: {
+  readonly NOMINAL: "nominal";
+  readonly BASE: "basic";
+  readonly STRUCTURED: "structure";
+  readonly TERM: "term";
+  readonly AXIOM: "axiom";
+  readonly FUNCTION: "function";
+  readonly PREDICATE: "predicate";
+  readonly CONSTANT: "constant";
+  readonly STATEMENT: "statement";
+};
+type CstType = (typeof CstType)[keyof typeof CstType];
+/** Represents attribution of a {@link Constituenta} to another {@link Constituenta}. */
+interface Attribution {
+  container: number;
+  attribute: number;
+}
+/** Represents global identifier type info. */
+interface TypeInfo {
+  alias: string;
+  type: ExpressionType;
+}
+/** Represents function argument value. */
+interface ArgumentValue {
+  alias: string;
+  typification: string;
+  value?: string;
+}
+/** Represents Constituenta classification in terms of system of concepts. */
+declare const CstClass: {
+  readonly NOMINAL: "nominal";
+  readonly BASIC: "basic";
+  readonly DERIVED: "derived";
+  readonly STATEMENT: "statement";
+  readonly TEMPLATE: "template";
+};
+type CstClass = (typeof CstClass)[keyof typeof CstClass];
+/** Represents formal expression Status. */
+declare const CstStatus: {
+  readonly VERIFIED: "verified";
+  readonly INCORRECT: "incorrect";
+  readonly INCALCULABLE: "incalculable";
+  readonly PROPERTY: "property";
+  readonly UNKNOWN: "unknown";
+};
+type CstStatus = (typeof CstStatus)[keyof typeof CstStatus];
+/** Represents substitution of {@link Constituenta}. */
+interface Substitution {
+  original: number;
+  substitution: number;
+}
+/** Represents word form for natural language. */
+interface TermForm {
+  text: string;
+  tags: string;
+}
+/** Represents Constituenta. */
+interface Constituenta {
+  id: number;
+  crucial: boolean;
+  alias: string;
+  convention: string;
+  cst_type: CstType;
+  definition_formal: string;
+  definition_raw: string;
+  definition_resolved: string;
+  term_raw: string;
+  term_resolved: string;
+  term_forms: TermForm[];
+  attributes: number[];
+  /** Manual typification of the constituent */
+  typification_manual: string;
+  /** Controls whether base concepts expose property values or full values */
+  value_is_property: boolean;
+  analysis: AnalysisBase;
+  /** Schema-kind {@link CstDiagnostic} list, populated during schema loading. */
+  diagnostics: CstDiagnostic[];
+  /** Typification used for dependents, model values, and display (manual when it overrides computed). */
+  effectiveType: ExpressionType | null;
+  /**
+   * True when manual typification is non-empty, parses to a type, and its label differs from the
+   * typification inferred from the formal definition ({@link Constituenta.analysis}.type).
+   */
+  is_type_mismatch: boolean;
+  /** Identifier of {@link LibraryItem} containing this {@link Constituenta}. */
+  schema: number;
+  /** {@link CstClass} of this {@link Constituenta}. */
+  cst_class: CstClass;
+  /** {@link CstStatus} of this {@link Constituenta}. */
+  status: CstStatus;
+  /** Indicates if this {@link Constituenta} is a template. */
+  is_template: boolean;
+  /** Indicates if this {@link Constituenta} has a simple expression. */
+  is_simple_expression: boolean;
+  /** Index of {@link LibraryItem} that contains this cst (or inheritance parent).
+   *  0 - not inherited, 1 - inherited by 1st schema, 2 - inherited by 2nd schema, etc.
+   */
+  parent_schema_index: number;
+  /** {@link LibraryItem} that contains parent of this inherited {@link Constituenta}. */
+  parent_schema: number | null;
+  /** Indicates if this {@link Constituenta} is inherited. */
+  is_inherited: boolean;
+  /** Indicates if this {@link Constituenta} has children that are inherited. */
+  has_inherited_children: boolean;
+  /** {@link Constituenta} that spawned this one. */
+  spawner?: number;
+  /** Alias of {@link Constituenta} that spawned this one. */
+  spawner_alias?: string;
+  /** Structure path that spawned this one. */
+  spawner_path?: TypePath;
+  /** List of {@link Constituenta} that are spawned by this one. */
+  spawn: number[];
+  /** List of aliases of {@link Constituenta} that are spawned by this one. */
+  spawn_alias: string[];
+}
+/** Represents {@link RSForm} statistics. */
+interface RSFormStats {
+  step_complexity: number;
+  /** Total number of constituents in the RSForm. */
+  count_all: number;
+  /** Number of crucial constituents in the RSForm. */
+  count_crucial: number;
+  count_problematic: number;
+  /** Constituents that have same term. */
+  count_homonyms: number;
+  /** Constituents that have same formal definition and term. */
+  count_formal_duplicates: number;
+  /** Base constituents with no convention and alias. */
+  count_missing_convention: number;
+  /** Constituents with non-empty manual typification that disagrees with inferred typification. */
+  count_type_mismatch: number;
+  count_incorrect: number;
+  count_property: number;
+  count_incalculable: number;
+  count_inherited: number;
+  count_text_term: number;
+  count_definition: number;
+  count_convention: number;
+  count_comment: number;
+  count_base: number;
+  count_constant: number;
+  count_structured: number;
+  count_axiom: number;
+  count_term: number;
+  count_function: number;
+  count_predicate: number;
+  count_statement: number;
+  count_nominal: number;
+}
+/** Represents inheritance data for {@link RSForm}. */
+interface InheritanceInfo {
+  child: number;
+  child_source: number;
+  parent: number;
+  parent_source: number;
+}
+/** Represents formal explication for set of concepts. */
+interface RSForm extends LibraryItem {
+  /** Whether this RSForm was produced (vs imported or inherited) */
+  is_produced: boolean;
+  /** Whether this RSForm has attribution feature */
+  is_attributive: boolean;
+  /** List of user IDs who can edit this RSForm */
+  editors: number[];
+  /** Information about the current version of this RSForm */
+  version: CurrentVersion;
+  /** Full version history of this RSForm */
+  versions: VersionInfo[];
+  /** Full list of constituents in the RSForm */
+  items: Constituenta[];
+  /** List of inheritance relationships between constituents */
+  inheritance: InheritanceInfo[];
+  /** List of constituent attribution relationships */
+  attribution: Attribution[];
+  /** References to Operational Schemes/Systems associated with the RSForm */
+  oss: LibraryItemReference[];
+  /** References to conceptual models associated with the RSForm */
+  models: LibraryItemReference[];
+  /** Analyzer instance for RS language features and validation */
+  analyzer: RSLangAnalyzer;
+  /** Graph structure representing formal dependencies between constituents */
+  graph: Graph;
+  /** Graph structure representing attribution relationships */
+  attribution_graph: Graph;
+  /** Map for quick lookup of constituents by alias */
+  cstByAlias: Map<string, Constituenta>;
+  /** Map for quick lookup of constituents by ID */
+  cstByID: Map<number, Constituenta>;
+}
+//#endregion
+//#region src/library/rsmodel.d.ts
+declare const TYPE_BASIC = "basic";
+/** Evaluation status enumeration. */
+declare const EvalStatus: {
+  readonly NO_EVAL: 1;
+  readonly NOT_PROCESSED: 2;
+  readonly INVALID_DATA: 3;
+  readonly EVAL_FAIL: 4;
+  readonly AXIOM_FALSE: 5;
+  readonly EMPTY: 6;
+  readonly HAS_DATA: 7;
+};
+type EvalStatus = (typeof EvalStatus)[keyof typeof EvalStatus];
+/** Represents basic element binding. */
+type BasicBinding = Record<number, string>;
+/** Represents {@link RSModel} basic sets binding. */
+type BasicsContext = Map<number, BasicBinding>;
+/** Default value for structured data. */
+declare const DEFAULT_VALUE_TEXT = "N/A";
+interface RSModelData extends LibraryItem {
+  editors: number[];
+  schema: number;
+  items: {
+    id: number;
+    type: string;
+    value: Value | BasicBinding;
+  }[];
+}
+/** Represents {@link RSModel} structured data. */
+type RSModel = RSModelData;
+/** Represents {@link RSModel} statistics. */
+interface RSModelStats extends RSFormStats {
+  count_missing_base: number;
+  count_false_axioms: number;
+  count_invalid_data: number;
+  count_invalid_calculations: number;
+  count_empty_terms: number;
+  base_elements: number;
+}
+//#endregion
+//#region src/library/diagnostics.d.ts
+/** Origin of a diagnostic. */
+declare const DiagnosticKind: {
+  readonly EXPRESSION: "expression";
+  readonly SCHEMA: "schema";
+  readonly MODEL: "model";
+};
+type DiagnosticKind = (typeof DiagnosticKind)[keyof typeof DiagnosticKind];
+/** Schema and model diagnostic codes (same numeric format as {@link RSErrorCode}). */
+declare const RSDiagnosticCode: {
+  readonly schemaHomonym: 35073;
+  readonly schemaFormalDuplicate: 35074;
+  readonly schemaMissingConvention: 35075;
+  readonly schemaMissingTerm: 35076;
+  readonly schemaTypeMismatch: 35077;
+  readonly modelEmpty: 35088;
+  readonly modelAxiomFalse: 35089;
+  readonly modelInvalidData: 35090;
+  readonly modelEvalFail: 35091;
+};
+type RSDiagnosticCode = (typeof RSDiagnosticCode)[keyof typeof RSDiagnosticCode];
+/** Compact diagnostic stored on {@link Constituenta} after schema loading. */
+interface CstDiagnostic {
+  kind: DiagnosticKind;
+  code: number;
+  /** Positional message arguments (per-code; homonyms/duplicates use `[aliases]`). */
+  params?: readonly string[];
+}
+/** Whether a constituent has a schema/model diagnostic with the given code. */
+declare function hasCstDiagnostic(cst: Constituenta, code: RSDiagnosticCode): boolean;
+/**
+ * Populate `diagnostics` on each constituent (homonyms, duplicates, metadata, type mismatch).
+ *
+ * Requires normalized formal definitions for duplicate detection (same as Portal loader).
+ */
+declare function assignSchemaDiagnostics(items: Constituenta[], resolveAlias: (id: number) => string, normalizedDefinitions: ReadonlyMap<number, string>): void;
+/** Map a model evaluation status to a compact diagnostic, or `null` when not an issue. */
+declare function modelStatusCstDiagnostic(status: EvalStatus, cstType: CstType): CstDiagnostic | null;
+//#endregion
+export { TypeInfo as C, Substitution as S, CstClass as _, hasCstDiagnostic as a, RSForm as b, BasicsContext as c, RSModel as d, RSModelStats as f, Constituenta as g, Attribution as h, assignSchemaDiagnostics as i, DEFAULT_VALUE_TEXT as l, ArgumentValue as m, DiagnosticKind as n, modelStatusCstDiagnostic as o, TYPE_BASIC as p, RSDiagnosticCode as r, BasicBinding as s, CstDiagnostic as t, EvalStatus as u, CstStatus as v, RSFormStats as x, CstType as y };
+//# sourceMappingURL=diagnostics-Clo3mkba.d.ts.map