@sciexpr/core 0.1.0

package/dist/index.js

@@ -0,0 +1,517 @@
+// src/types/ast.ts
+var ExpressionKind = /* @__PURE__ */ ((ExpressionKind2) => {
+  ExpressionKind2["Math"] = "math";
+  ExpressionKind2["Molecule"] = "molecule";
+  ExpressionKind2["ChemicalEquation"] = "chemical-equation";
+  ExpressionKind2["Matrix"] = "matrix";
+  ExpressionKind2["Text"] = "text";
+  ExpressionKind2["Mixed"] = "mixed";
+  return ExpressionKind2;
+})(ExpressionKind || {});
+var SymbolType = /* @__PURE__ */ ((SymbolType2) => {
+  SymbolType2["Greek"] = "greek";
+  SymbolType2["Operator"] = "operator";
+  SymbolType2["Relation"] = "relation";
+  SymbolType2["Arrow"] = "arrow";
+  SymbolType2["Accent"] = "accent";
+  SymbolType2["Ordinary"] = "ordinary";
+  SymbolType2["Variable"] = "variable";
+  SymbolType2["Number"] = "number";
+  return SymbolType2;
+})(SymbolType || {});
+
+// src/types/validator.ts
+var ValidationErrorCode = /* @__PURE__ */ ((ValidationErrorCode2) => {
+  ValidationErrorCode2["UNEXPECTED_NODE"] = "UNEXPECTED_NODE";
+  ValidationErrorCode2["EMPTY_EXPRESSION"] = "EMPTY_EXPRESSION";
+  ValidationErrorCode2["UNBALANCED_BRACE"] = "UNBALANCED_BRACE";
+  ValidationErrorCode2["UNBALANCED_BRACKET"] = "UNBALANCED_BRACKET";
+  ValidationErrorCode2["INVALID_SCRIPT"] = "INVALID_SCRIPT";
+  ValidationErrorCode2["DIVISION_BY_ZERO"] = "DIVISION_BY_ZERO";
+  ValidationErrorCode2["MATRIX_DIMENSION_MISMATCH"] = "MATRIX_DIMENSION_MISMATCH";
+  ValidationErrorCode2["NEGATIVE_RADICAL"] = "NEGATIVE_RADICAL";
+  ValidationErrorCode2["INVALID_ELEMENT_SYMBOL"] = "INVALID_ELEMENT_SYMBOL";
+  ValidationErrorCode2["INVALID_CHEMICAL_FORMULA"] = "INVALID_CHEMICAL_FORMULA";
+  ValidationErrorCode2["CHARGE_IMBALANCE"] = "CHARGE_IMBALANCE";
+  ValidationErrorCode2["ELEMENT_IMBALANCE"] = "ELEMENT_IMBALANCE";
+  ValidationErrorCode2["INVALID_BOND"] = "INVALID_BOND";
+  return ValidationErrorCode2;
+})(ValidationErrorCode || {});
+
+// src/node-factory.ts
+var _nodeIdCounter = 0;
+function generateNodeId() {
+  return `n${++_nodeIdCounter}`;
+}
+function resetNodeIdCounter() {
+  _nodeIdCounter = 0;
+}
+function createRoot(type, children, metadata) {
+  return {
+    kind: "root",
+    id: generateNodeId(),
+    type,
+    children,
+    metadata
+  };
+}
+function createSymbol(value, symbolType) {
+  return {
+    kind: "symbol",
+    id: generateNodeId(),
+    value,
+    symbolType
+  };
+}
+function createFraction(numerator, denominator) {
+  return {
+    kind: "frac",
+    id: generateNodeId(),
+    numerator,
+    denominator
+  };
+}
+function createScript(base, options) {
+  return {
+    kind: "script",
+    id: generateNodeId(),
+    base,
+    ...options
+  };
+}
+function createRadical(radicand, index) {
+  return {
+    kind: "radical",
+    id: generateNodeId(),
+    radicand,
+    index
+  };
+}
+function createDelimiter(left, right, body) {
+  return {
+    kind: "delimiter",
+    id: generateNodeId(),
+    left,
+    right,
+    body
+  };
+}
+function createMatrix(rows, options) {
+  return {
+    kind: "matrix",
+    id: generateNodeId(),
+    rows,
+    ...options
+  };
+}
+function createText(content) {
+  return {
+    kind: "text",
+    id: generateNodeId(),
+    content
+  };
+}
+function createSpace(width) {
+  return {
+    kind: "space",
+    id: generateNodeId(),
+    width
+  };
+}
+function createAccent(accentType, base) {
+  return {
+    kind: "accent",
+    id: generateNodeId(),
+    accentType,
+    base
+  };
+}
+function createLargeOp(opType, body, options) {
+  return {
+    kind: "largeop",
+    id: generateNodeId(),
+    opType,
+    body,
+    ...options
+  };
+}
+function createColor(color, body) {
+  return {
+    kind: "color",
+    id: generateNodeId(),
+    color,
+    body
+  };
+}
+function createGroup(children) {
+  return {
+    kind: "group",
+    id: generateNodeId(),
+    children
+  };
+}
+function createChemElement(symbol, options) {
+  return {
+    kind: "chem-element",
+    id: generateNodeId(),
+    symbol,
+    ...options
+  };
+}
+function createChemBond(bondType, left, right) {
+  return {
+    kind: "chem-bond",
+    id: generateNodeId(),
+    bondType,
+    left,
+    right
+  };
+}
+function createChemReaction(reactants, products, arrowType, conditions) {
+  return {
+    kind: "chem-reaction",
+    id: generateNodeId(),
+    reactants,
+    products,
+    arrowType,
+    conditions
+  };
+}
+function createChemGroup(atoms, name) {
+  return {
+    kind: "chem-group",
+    id: generateNodeId(),
+    name,
+    atoms
+  };
+}
+function cloneNode(node) {
+  const cloned = JSON.parse(JSON.stringify(node));
+  cloned.id = generateNodeId();
+  return cloned;
+}
+function isNodeType(node, kind) {
+  return node.kind === kind;
+}
+function flattenNode(node) {
+  const result = [node];
+  const children = getNodeChildren(node);
+  for (const child of children) {
+    result.push(...flattenNode(child));
+  }
+  return result;
+}
+function getNodeChildren(node) {
+  const n = node;
+  switch (n.kind) {
+    case "root":
+    case "group":
+      return n.children;
+    case "frac":
+      return [n.numerator, n.denominator];
+    case "script":
+      return [n.base, n.sub, n.super].filter(Boolean);
+    case "radical":
+      return [n.radicand, n.index].filter(Boolean);
+    case "delimiter":
+      return [n.body];
+    case "matrix":
+      return n.rows.flat();
+    case "color":
+      return [n.body];
+    case "accent":
+      return [n.base];
+    case "largeop":
+      return [n.body, n.lower, n.upper].filter(Boolean);
+    case "chem-bond":
+      return [n.left, n.right];
+    case "chem-reaction":
+      return [...n.reactants, ...n.products, n.conditions].filter(Boolean);
+    case "chem-group":
+      return n.atoms;
+    case "symbol":
+    case "text":
+    case "space":
+    case "chem-element":
+      return [];
+    default:
+      return [];
+  }
+}
+
+// src/ast-utils.ts
+function traverseAST(node, visitor, options = {}) {
+  const { order = "pre" } = options;
+  let result;
+  if (order === "pre") {
+    result = visitNode(node, visitor);
+  }
+  const children = getChildren(node);
+  for (const child of children) {
+    traverseAST(child, visitor, options);
+  }
+  if (order === "post") {
+    result = visitNode(node, visitor);
+  }
+  return result;
+}
+function visitNode(node, visitor) {
+  let result;
+  const n = node;
+  switch (n.kind) {
+    case "root":
+      result = visitor.visitRoot?.(n);
+      break;
+    case "symbol":
+      result = visitor.visitSymbol?.(n);
+      break;
+    case "frac":
+      result = visitor.visitFraction?.(n);
+      break;
+    case "script":
+      result = visitor.visitScript?.(n);
+      break;
+    case "radical":
+      result = visitor.visitRadical?.(n);
+      break;
+    case "delimiter":
+      result = visitor.visitDelimiter?.(n);
+      break;
+    case "matrix":
+      result = visitor.visitMatrix?.(n);
+      break;
+    case "text":
+      result = visitor.visitText?.(n);
+      break;
+    case "space":
+      result = visitor.visitSpace?.(n);
+      break;
+    case "accent":
+      result = visitor.visitAccent?.(n);
+      break;
+    case "largeop":
+      result = visitor.visitLargeOp?.(n);
+      break;
+    case "color":
+      result = visitor.visitColor?.(n);
+      break;
+    case "group":
+      result = visitor.visitGroup?.(n);
+      break;
+    case "chem-element":
+      result = visitor.visitChemElement?.(n);
+      break;
+    case "chem-bond":
+      result = visitor.visitChemBond?.(n);
+      break;
+    case "chem-reaction":
+      result = visitor.visitChemReaction?.(n);
+      break;
+    case "chem-group":
+      result = visitor.visitChemGroup?.(n);
+      break;
+    default:
+      result = visitor.visitDefault?.(n);
+      break;
+  }
+  if (result === void 0 && visitor.visitDefault) {
+    result = visitor.visitDefault(node);
+  }
+  return result;
+}
+function getChildren(node) {
+  const n = node;
+  switch (n.kind) {
+    case "root":
+    case "group":
+      return n.children;
+    case "frac":
+      return [n.numerator, n.denominator];
+    case "script": {
+      const children = [n.base];
+      if (n.sub) children.push(n.sub);
+      if (n.super) children.push(n.super);
+      return children;
+    }
+    case "radical": {
+      const children = [n.radicand];
+      if (n.index) children.push(n.index);
+      return children;
+    }
+    case "delimiter":
+      return [n.body];
+    case "matrix":
+      return n.rows.flat();
+    case "color":
+      return [n.body];
+    case "accent":
+      return [n.base];
+    case "largeop": {
+      const children = [];
+      if (n.body) children.push(n.body);
+      if (n.lower) children.push(n.lower);
+      if (n.upper) children.push(n.upper);
+      return children;
+    }
+    case "chem-bond":
+      return [n.left, n.right];
+    case "chem-reaction": {
+      const children = [...n.reactants, ...n.products];
+      if (n.conditions) children.push(n.conditions);
+      return children;
+    }
+    case "chem-group":
+      return n.atoms;
+    case "symbol":
+    case "text":
+    case "space":
+    case "chem-element":
+      return [];
+    default:
+      return [];
+  }
+}
+function collectNodes(root, predicate) {
+  const results = [];
+  traverseAST(root, {
+    visitDefault(node) {
+      if (predicate(node)) {
+        results.push(node);
+      }
+    }
+  });
+  return results;
+}
+function findNode(root, predicate) {
+  return collectNodes(root, predicate)[0];
+}
+function countNodes(root) {
+  let count = 0;
+  traverseAST(root, {
+    visitDefault() {
+      count++;
+    }
+  });
+  return count;
+}
+
+// src/serializer.ts
+function serializeAST(root) {
+  return JSON.stringify(root);
+}
+function deserializeAST(json) {
+  const parsed = JSON.parse(json);
+  if (!parsed || parsed.kind !== "root") {
+    throw new Error('Invalid AST JSON: root node must have kind "root"');
+  }
+  return parsed;
+}
+function safeDeserializeAST(json) {
+  try {
+    return deserializeAST(json);
+  } catch {
+    return null;
+  }
+}
+function serializeASTCompact(root) {
+  return JSON.stringify(root, (key, value) => {
+    if (key === "id" && typeof value === "string" && value.startsWith("n")) {
+      return void 0;
+    }
+    if (key === "source" && value === void 0) {
+      return void 0;
+    }
+    return value;
+  });
+}
+function serializeASTPretty(root) {
+  return JSON.stringify(root, null, 2);
+}
+
+// src/classifier.ts
+var ExpressionClassifier = class {
+  /**
+   * 分类表达式
+   */
+  classify(root) {
+    if (root.type !== "mixed" /* Mixed */) {
+      return root.type;
+    }
+    const hasChemistryNodes = this.hasChemistryNodes(root);
+    const hasMathNodes = this.hasMathNodes(root);
+    if (hasChemistryNodes && !hasMathNodes) {
+      const hasReaction = collectNodes(root, (n) => n.kind === "chem-reaction").length > 0;
+      return hasReaction ? "chemical-equation" /* ChemicalEquation */ : "molecule" /* Molecule */;
+    }
+    if (hasMathNodes && hasChemistryNodes) {
+      return "mixed" /* Mixed */;
+    }
+    if (hasMathNodes) {
+      const hasMatrix = collectNodes(root, (n) => n.kind === "matrix").length > 0;
+      return hasMatrix ? "matrix" /* Matrix */ : "math" /* Math */;
+    }
+    return "text" /* Text */;
+  }
+  /**
+   * 检测是否包含化学相关节点
+   */
+  hasChemistryNodes(root) {
+    return collectNodes(
+      root,
+      (n) => ["chem-element", "chem-bond", "chem-reaction", "chem-group"].includes(n.kind)
+    ).length > 0;
+  }
+  /**
+   * 检测是否包含数学相关节点
+   */
+  hasMathNodes(root) {
+    return collectNodes(
+      root,
+      (n) => ["frac", "script", "radical", "delimiter", "matrix", "accent", "largeop"].includes(n.kind)
+    ).length > 0;
+  }
+  /**
+   * 检测是否为 display 模式（块级公式）
+   */
+  isDisplayMode(root) {
+    return root.metadata?.displayMode ?? false;
+  }
+};
+export {
+  ExpressionClassifier,
+  ExpressionKind,
+  SymbolType,
+  ValidationErrorCode,
+  cloneNode,
+  collectNodes,
+  countNodes,
+  createAccent,
+  createChemBond,
+  createChemElement,
+  createChemGroup,
+  createChemReaction,
+  createColor,
+  createDelimiter,
+  createFraction,
+  createGroup,
+  createLargeOp,
+  createMatrix,
+  createRadical,
+  createRoot,
+  createScript,
+  createSpace,
+  createSymbol,
+  createText,
+  deserializeAST,
+  findNode,
+  flattenNode,
+  generateNodeId,
+  getNodeChildren,
+  isNodeType,
+  resetNodeIdCounter,
+  safeDeserializeAST,
+  serializeAST,
+  serializeASTCompact,
+  serializeASTPretty,
+  traverseAST
+};

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@sciexpr/core",
+  "version": "0.1.0",
+  "description": "Scientific Expression Engine - Core types, AST, schema and validators",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "scientific",
+    "expression",
+    "math",
+    "chemistry",
+    "latex",
+    "ast"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "haoguodong09-svg",
+    "email": "haoguodong09@gmail.com"
+  },
+  "homepage": "https://github.com/haoguodong09-svg/scientific-expression-engine#readme",
+  "bugs": {
+    "url": "https://github.com/haoguodong09-svg/scientific-expression-engine/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/haoguodong09-svg/scientific-expression-engine",
+    "directory": "packages/core"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.0",
+    "rimraf": "^5.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "tsc --noEmit",
+    "clean": "rimraf dist",
+    "test": "vitest run"
+  }
+}