@rsconcept/domain 2.1.2 → 2.3.0

package/src/library/rsform-api/transforms.ts

@@ -0,0 +1,42 @@
+/**
+ * Pure constituenta list transforms: reorder, move, insert position.
+ */
+
+/** Rebuild an item list following {@link orderedIds}. Throws if an id is missing. */
+export function reorderItemsByIds<T extends { id: number }>(items: readonly T[], orderedIds: readonly number[]): T[] {
+  const byId = new Map(items.map(item => [item.id, item]));
+  return orderedIds.map(id => {
+    const item = byId.get(id);
+    if (!item) {
+      throw new Error(`reorderItemsByIds: missing id ${id}`);
+    }
+    return item;
+  });
+}
+
+/**
+ * Move a subset of ids within an ordered id list.
+ * {@link moveTo} is clamped to `[0, rest.length]` (index among non-moving items).
+ */
+export function moveIdsInOrder(ids: readonly number[], moving: readonly number[], moveTo: number): number[] {
+  const movingSet = new Set(moving);
+  const rest = ids.filter(id => !movingSet.has(id));
+  const movingItems = ids.filter(id => movingSet.has(id));
+  const clamped = Math.max(0, Math.min(moveTo, rest.length));
+  return [...rest.slice(0, clamped), ...movingItems, ...rest.slice(clamped)];
+}
+
+/** Insert {@link item} after {@link insertAfter}, or append when null/undefined/missing. Mutates {@link items}. */
+export function insertItemAfter<T extends { id: number }>(
+  items: T[],
+  item: T,
+  insertAfter: number | null | undefined
+): void {
+  if (insertAfter === null || insertAfter === undefined) {
+    items.push(item);
+    return;
+  }
+  const idx = items.findIndex(row => row.id === insertAfter);
+  const insertAt = idx === -1 ? items.length : idx + 1;
+  items.splice(insertAt, 0, item);
+}

package/src/library/rsform-api/types.ts

@@ -0,0 +1,38 @@
+/**
+ * Minimal constituenta shapes for schema transforms.
+ */
+
+import { type CstType, type TermForm } from '../rsform';
+
+/** Minimal constituent fields required to restore order. */
+export interface OrderableConstituenta {
+  id: number;
+  alias: string;
+  cst_type: CstType;
+  definition_formal: string;
+}
+
+/** Semantic parent/children derived from formal definitions (backend SemanticInfo). */
+export interface SemanticRelations {
+  /** Parent id for each constituenta (self when none). */
+  parentOf: Map<number, number>;
+  /** Semantic children ids for each constituenta. */
+  childrenOf: Map<number, number[]>;
+}
+
+/** Constituent fields needed to resolve term/definition entity references. */
+export interface ResolvableConstituenta {
+  id: number;
+  alias: string;
+  term_raw: string;
+  term_resolved: string;
+  term_forms: TermForm[];
+  definition_raw: string;
+  definition_resolved: string;
+}
+
+/** Constituent fields needed to allocate or reset aliases by type. */
+export interface AliasTypedConstituenta {
+  alias: string;
+  cst_type: CstType;
+}

package/src/library/rsform.ts

@@ -68,7 +68,7 @@ export interface Substitution {
 }
 
 /** Represents word form for natural language. */
-interface TermForm {
+export interface TermForm {
   text: string;
   tags: string;
 }
@@ -159,8 +159,8 @@ export interface RSFormStats {
   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;
+  /** Non-logical basic constituents missing convention and/or resolved term. */
+  count_missing_basic_text: number;
   /** Constituents with non-empty manual typification that disagrees with inferred typification. */
   count_type_mismatch: number;
 

package/src/library/rsmodel-api.ts

@@ -292,11 +292,17 @@ export function deleteValueElement(
   type: Typification,
   target: number
 ): Value | null {
+  if (value === null) {
+    return null;
+  }
   if (path.length === 0 && type.typeID !== TypeID.collection) {
     return null;
   }
 
-  const arrayValue = extractValue(value!, path)! as Value[];
+  const arrayValue = extractValue(value, path);
+  if (!Array.isArray(arrayValue)) {
+    return null;
+  }
   const updatedArray = [...arrayValue.slice(0, target), ...arrayValue.slice(target + 1)];
   return setNestedValue(value, path, updatedArray);
 }