openseesjs 0.2.1 → 0.2.2

package/dist/native-index.cjs

@@ -0,0 +1,712 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/native-index.ts
+var native_index_exports = {};
+__export(native_index_exports, {
+  OPEN_SEES_PY_COMMANDS: () => OPEN_SEES_PY_COMMANDS,
+  OPEN_SEES_PY_VERSION: () => OPEN_SEES_PY_VERSION,
+  OpenSeesCommandError: () => OpenSeesCommandError,
+  OpenSeesNativeCommands: () => OpenSeesNativeCommands,
+  OpenSeesNativeQueries: () => OpenSeesNativeQueries,
+  OpenSeesNativeSession: () => OpenSeesNativeSession,
+  createOpenSeesOps: () => createOpenSeesOps,
+  defaultNativeBindingPath: () => defaultNativeBindingPath,
+  inspectNativeBackend: () => inspectNativeBackend,
+  loadNativeBinding: () => loadNativeBinding,
+  ops: () => ops
+});
+module.exports = __toCommonJS(native_index_exports);
+
+// src/openseespy/generated/OpenSeesPyApi.generated.ts
+var OPEN_SEES_PY_VERSION = "3.8.0.0";
+var OPEN_SEES_PY_COMMANDS = [
+  "Bcast",
+  "IGA",
+  "InitialStateAnalysis",
+  "NDTest",
+  "ShallowFoundationGen",
+  "accelCPU",
+  "addToParameter",
+  "algorithm",
+  "analysis",
+  "analyze",
+  "barrier",
+  "basicDeformation",
+  "basicForce",
+  "basicStiffness",
+  "beamIntegration",
+  "block2D",
+  "block3D",
+  "build",
+  "cbdiDisplacement",
+  "classType",
+  "computeGradients",
+  "constraints",
+  "convertBinaryToText",
+  "convertTextToBinary",
+  "correlate",
+  "damping",
+  "database",
+  "defaultUnits",
+  "domainChange",
+  "domainCommitTag",
+  "eigen",
+  "eleDynamicalForce",
+  "eleForce",
+  "eleLoad",
+  "eleNodes",
+  "eleResponse",
+  "eleType",
+  "element",
+  "equalDOF",
+  "equalDOF_Mixed",
+  "equationConstraint",
+  "fiber",
+  "filter",
+  "findCurvatures",
+  "findDesignPoint",
+  "fix",
+  "fixX",
+  "fixY",
+  "fixZ",
+  "frictionModel",
+  "functionEvaluator",
+  "geomTransf",
+  "getCDF",
+  "getConstrainedDOFs",
+  "getConstrainedNodes",
+  "getCrdTransfTags",
+  "getDampTangent",
+  "getEleClassTags",
+  "getEleLoadClassTags",
+  "getEleLoadData",
+  "getEleLoadTags",
+  "getEleTags",
+  "getFixedDOFs",
+  "getFixedNodes",
+  "getInverseCDF",
+  "getLSFTags",
+  "getLoadFactor",
+  "getMean",
+  "getNDF",
+  "getNDM",
+  "getNP",
+  "getNodeLoadData",
+  "getNodeLoadTags",
+  "getNodeTags",
+  "getNodeTemperature",
+  "getNumElements",
+  "getNumThreads",
+  "getPDF",
+  "getPID",
+  "getParamTags",
+  "getParamValue",
+  "getPatterns",
+  "getRVParamTag",
+  "getRVTags",
+  "getRVValue",
+  "getRetainedDOFs",
+  "getRetainedNodes",
+  "getStdv",
+  "getStrain",
+  "getStress",
+  "getTangent",
+  "getTime",
+  "gradPerformanceFunction",
+  "gradientEvaluator",
+  "groundMotion",
+  "hystereticBackbone",
+  "imposedMotion",
+  "imposedSupportMotion",
+  "initialize",
+  "integrator",
+  "layer",
+  "limitCurve",
+  "load",
+  "loadConst",
+  "logFile",
+  "mass",
+  "meritFunctionCheck",
+  "mesh",
+  "metaData",
+  "modalDamping",
+  "modalDampingQ",
+  "modalProperties",
+  "model",
+  "modulatingFunction",
+  "nDMaterial",
+  "node",
+  "nodeAccel",
+  "nodeBounds",
+  "nodeCoord",
+  "nodeDOFs",
+  "nodeDisp",
+  "nodeEigenvector",
+  "nodeMass",
+  "nodePressure",
+  "nodeReaction",
+  "nodeResponse",
+  "nodeUnbalance",
+  "nodeVel",
+  "numFact",
+  "numIter",
+  "numberer",
+  "parameter",
+  "partition",
+  "patch",
+  "pattern",
+  "performanceFunction",
+  "pressureConstraint",
+  "printA",
+  "printB",
+  "printGID",
+  "printModel",
+  "printX",
+  "probabilityTransformation",
+  "pyversion",
+  "randomNumberGenerator",
+  "randomVariable",
+  "rayleigh",
+  "reactions",
+  "record",
+  "recorder",
+  "recv",
+  "region",
+  "reliabilityConvergenceCheck",
+  "remesh",
+  "remove",
+  "reset",
+  "responseSpectrumAnalysis",
+  "restore",
+  "rigidDiaphragm",
+  "rigidLink",
+  "rootFinding",
+  "runFORMAnalysis",
+  "runFOSMAnalysis",
+  "runImportanceSamplingAnalysis",
+  "runSORMAnalysis",
+  "save",
+  "sdfResponse",
+  "searchDirection",
+  "searchPeerNGA",
+  "section",
+  "sectionDeformation",
+  "sectionDisplacement",
+  "sectionFlexibility",
+  "sectionForce",
+  "sectionLocation",
+  "sectionResponseType",
+  "sectionStiffness",
+  "sectionTag",
+  "sectionWeight",
+  "send",
+  "sensLambda",
+  "sensNodeAccel",
+  "sensNodeDisp",
+  "sensNodePressure",
+  "sensNodeVel",
+  "sensSectionForce",
+  "sensitivityAlgorithm",
+  "setCreep",
+  "setElementRayleighDampingFactors",
+  "setElementRayleighFactors",
+  "setMaxOpenFiles",
+  "setNodeAccel",
+  "setNodeCoord",
+  "setNodeDisp",
+  "setNodePressure",
+  "setNodeTemperature",
+  "setNodeVel",
+  "setNumThreads",
+  "setParameter",
+  "setPrecision",
+  "setStartNodeTag",
+  "setStrain",
+  "setTime",
+  "solveCPU",
+  "sp",
+  "spectrum",
+  "start",
+  "startPoint",
+  "stepSizeRule",
+  "stiffnessDegradation",
+  "stop",
+  "strengthControl",
+  "strengthDegradation",
+  "stripXML",
+  "system",
+  "systemSize",
+  "test",
+  "testIter",
+  "testNorm",
+  "testNorms",
+  "testUniaxialMaterial",
+  "timeSeries",
+  "totalCPU",
+  "transformUtoX",
+  "uniaxialMaterial",
+  "unloadingRule",
+  "updateElementDomain",
+  "updateMaterialStage",
+  "updateParameter",
+  "version",
+  "wipe",
+  "wipeAnalysis",
+  "wipeReliability"
+];
+
+// src/native/flattenArguments.ts
+function flattenNativeArguments(values) {
+  const result = [];
+  for (const value of values) {
+    if (value === void 0) continue;
+    if (isArgumentArray(value)) {
+      result.push(...flattenNativeArguments(value));
+    } else if (isExpression(value)) {
+      throw new Error("Tcl expressions cannot be passed to the native backend. Invoke the query directly instead.");
+    } else if (isFlagOptions(value)) {
+      for (const [flag, flagValue] of Object.entries(value)) {
+        if (flagValue === void 0 || flagValue === false) continue;
+        result.push(flag.startsWith("-") ? flag : `-${flag}`);
+        if (flagValue !== true) result.push(...flattenNativeArguments([flagValue]));
+      }
+    } else {
+      result.push(value);
+    }
+  }
+  return result;
+}
+function isExpression(value) {
+  return typeof value === "object" && value !== null && "tcl" in value;
+}
+function isArgumentArray(value) {
+  return Array.isArray(value);
+}
+function isFlagOptions(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/native/OpenSeesCommandError.ts
+var OpenSeesCommandError = class extends Error {
+  constructor(command, arguments_, message, options) {
+    super(message, { cause: options?.cause });
+    this.command = command;
+    this.arguments_ = arguments_;
+    this.rowIndex = options?.rowIndex;
+  }
+  name = "OpenSeesCommandError";
+  rowIndex;
+};
+function invokeNative(invoke, command, args, rowIndex) {
+  try {
+    return invoke();
+  } catch (cause) {
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    const row = rowIndex === void 0 ? "" : ` at batch row ${rowIndex}`;
+    throw new OpenSeesCommandError(
+      command,
+      args,
+      `OpenSees command "${command}" failed${row}: ${detail}`,
+      { cause, ...rowIndex === void 0 ? {} : { rowIndex } }
+    );
+  }
+}
+
+// src/native/OpenSeesNativeBindingLoader.ts
+var import_node_fs = require("node:fs");
+var import_node_module = require("node:module");
+var import_node_path = require("node:path");
+var import_node_url = require("node:url");
+var modulePath = typeof __filename === "string" ? __filename : (0, import_node_url.fileURLToPath)(__filename);
+var moduleDirectory = typeof __dirname === "string" ? __dirname : (0, import_node_path.dirname)(modulePath);
+var require2 = (0, import_node_module.createRequire)(modulePath);
+function platformPackageName() {
+  return `@openseesjs/native-${process.platform}-${process.arch}`;
+}
+function resolveBinding() {
+  const override = process.env.OPEN_SEES_NODE_BINDING;
+  if (override) return { path: (0, import_node_path.resolve)(override), distribution: "environment" };
+  try {
+    return {
+      path: require2.resolve(`${platformPackageName()}/opensees.node`),
+      distribution: "platform-package"
+    };
+  } catch {
+    const packageRoots = [
+      (0, import_node_path.resolve)(moduleDirectory, "..", ".."),
+      (0, import_node_path.resolve)(moduleDirectory, "..")
+    ];
+    const bundledCandidates = packageRoots.map((packageRoot) => (0, import_node_path.resolve)(packageRoot, "native", "prebuilds", `${process.platform}-${process.arch}`, "opensees.node"));
+    return {
+      path: bundledCandidates.find(import_node_fs.existsSync) ?? bundledCandidates[0],
+      distribution: "bundled"
+    };
+  }
+}
+function defaultNativeBindingPath() {
+  return resolveBinding().path;
+}
+function inspectNativeBackend(bindingPath = defaultNativeBindingPath()) {
+  const resolved = (0, import_node_path.resolve)(bindingPath);
+  const automatic = resolveBinding();
+  const distribution = resolved === automatic.path ? automatic.distribution : "explicit";
+  const base = { bindingPath: resolved, platform: process.platform, arch: process.arch, distribution };
+  if (!(0, import_node_fs.existsSync)(resolved)) {
+    return {
+      available: false,
+      ...base,
+      reason: `No native OpenSees runtime is available for ${process.platform}-${process.arch}. Install ${platformPackageName()} or set OPEN_SEES_NODE_BINDING.`
+    };
+  }
+  try {
+    const loaded = require2(resolved);
+    if (typeof loaded.createSession !== "function") {
+      return { available: false, ...base, reason: "The native addon does not export createSession()." };
+    }
+    return { available: true, ...base, ...readBuildInfo(resolved) };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      available: false,
+      ...base,
+      reason: `The native addon or one of its runtime libraries could not be loaded: ${message}`
+    };
+  }
+}
+function readBuildInfo(bindingPath) {
+  const candidates = [
+    (0, import_node_path.resolve)((0, import_node_path.dirname)(bindingPath), "BUILD_INFO.json"),
+    (0, import_node_path.resolve)((0, import_node_path.dirname)(bindingPath), "..", "..", "BUILD_INFO.json")
+  ];
+  for (const candidate of candidates) {
+    if (!(0, import_node_fs.existsSync)(candidate)) continue;
+    try {
+      const info = JSON.parse((0, import_node_fs.readFileSync)(candidate, "utf8"));
+      return {
+        ...info.openSeesVersion === void 0 ? {} : { openSeesVersion: info.openSeesVersion },
+        ...info.openSeesSourceRevision === void 0 ? {} : { sourceRevision: info.openSeesSourceRevision },
+        ...info.nodeApi === void 0 ? {} : { nodeApi: info.nodeApi }
+      };
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+function loadNativeBinding(bindingPath = defaultNativeBindingPath()) {
+  const availability = inspectNativeBackend(bindingPath);
+  if (!availability.available) {
+    throw new Error(`${availability.reason} Expected: ${availability.bindingPath}`);
+  }
+  const loaded = require2(availability.bindingPath);
+  if (typeof loaded.createSession !== "function") {
+    throw new Error(`Invalid OpenSees native addon at ${availability.bindingPath}: createSession() is missing.`);
+  }
+  return loaded;
+}
+
+// src/native/OpenSeesNativeQueries.ts
+var OpenSeesNativeQueries = class {
+  constructor(session) {
+    this.session = session;
+  }
+  analyze(numIncr = 1, dt, dtMin, dtMax, jd) {
+    return this.number("analyze", numIncr, dt, dtMin, dtMax, jd);
+  }
+  getTime() {
+    return this.number("getTime");
+  }
+  getLoadFactor(patternTag) {
+    return this.number("getLoadFactor", patternTag);
+  }
+  getNodeTags(meshTag) {
+    return this.numbers("getNodeTags", meshTag === void 0 ? void 0 : { mesh: meshTag });
+  }
+  getEleTags(meshTag) {
+    return this.numbers("getEleTags", meshTag === void 0 ? void 0 : { mesh: meshTag });
+  }
+  nodeCoord(nodeTag, dimension) {
+    return dimension === void 0 ? this.numbers("nodeCoord", nodeTag) : this.number("nodeCoord", nodeTag, dimension);
+  }
+  nodeDisp(nodeTag, dof) {
+    return dof === void 0 ? this.numbers("nodeDisp", nodeTag) : this.number("nodeDisp", nodeTag, dof);
+  }
+  nodeVel(nodeTag, dof) {
+    return dof === void 0 ? this.numbers("nodeVel", nodeTag) : this.number("nodeVel", nodeTag, dof);
+  }
+  nodeAccel(nodeTag, dof) {
+    return dof === void 0 ? this.numbers("nodeAccel", nodeTag) : this.number("nodeAccel", nodeTag, dof);
+  }
+  nodeReaction(nodeTag, dof) {
+    return dof === void 0 ? this.numbers("nodeReaction", nodeTag) : this.number("nodeReaction", nodeTag, dof);
+  }
+  nodeDisplacements(nodeTags) {
+    return this.vectorRecord("nodeDisp", nodeTags);
+  }
+  nodeReactions(nodeTags) {
+    return this.vectorRecord("nodeReaction", nodeTags);
+  }
+  eleResponse(eleTag, response) {
+    return this.numbers("eleResponse", eleTag, response);
+  }
+  eleForce(eleTag, dof) {
+    return dof === void 0 ? this.numbers("eleForce", eleTag) : this.number("eleForce", eleTag, dof);
+  }
+  elementForces(elementTags) {
+    return this.vectorRecord("eleForce", elementTags);
+  }
+  printA(...args) {
+    return args.some((argument) => argument === "-ret") ? this.numbers("printA", ...args) : this.number("printA", ...args);
+  }
+  printB(...args) {
+    return args.some((argument) => argument === "-ret") ? this.numbers("printB", ...args) : this.number("printB", ...args);
+  }
+  elementLocalForces2D(eleTag) {
+    const raw = this.eleResponse(eleTag, ["localForce"]);
+    if (raw.length < 6) throw resultTypeError("eleResponse localForce", "at least six values", raw);
+    return {
+      i: { axial: raw[0], shear: raw[1], moment: raw[2] },
+      j: { axial: raw[3], shear: raw[4], moment: raw[5] },
+      raw
+    };
+  }
+  eigen(solverOrModes, numModes) {
+    return typeof solverOrModes === "number" ? this.numbers("eigen", solverOrModes) : this.numbers("eigen", solverOrModes, numModes);
+  }
+  modalResults(numModes, solver = "-genBandArpack") {
+    return this.eigen(solver, numModes).map((eigenvalue, index) => {
+      const omega = Math.sqrt(eigenvalue);
+      const frequency = omega / (2 * Math.PI);
+      return {
+        mode: index + 1,
+        eigenvalue,
+        omega,
+        frequency,
+        period: frequency === 0 ? Number.POSITIVE_INFINITY : 1 / frequency
+      };
+    });
+  }
+  nodeEigenvector(nodeTag, mode, dof) {
+    return dof === void 0 ? this.numbers("nodeEigenvector", nodeTag, mode) : this.number("nodeEigenvector", nodeTag, mode, dof);
+  }
+  modalProperties(...flags) {
+    const value = this.call("modalProperties", [...flags, "-return"]);
+    if (!Array.isArray(value) || value.length % 2 !== 0) {
+      throw resultTypeError("modalProperties", "Tcl dictionary", value);
+    }
+    const properties = {};
+    for (let index = 0; index < value.length; index += 2) {
+      const key = value[index];
+      const entry = value[index + 1];
+      if (typeof key !== "string" || !isNumericValue(entry)) {
+        throw resultTypeError("modalProperties", "numeric Tcl dictionary", value);
+      }
+      properties[key] = entry;
+    }
+    return properties;
+  }
+  version() {
+    const value = this.call("version");
+    if (typeof value !== "string") throw resultTypeError("version", "string", value);
+    return value;
+  }
+  /** Escape hatch tipado para resultados todavía no especializados. */
+  call(command, args = []) {
+    const flattened = flattenNativeArguments(args);
+    return invokeNative(() => this.session.invoke(command, flattened), command, flattened);
+  }
+  number(command, ...args) {
+    const value = this.call(command, args);
+    if (typeof value !== "number") throw resultTypeError(command, "number", value);
+    return value;
+  }
+  numbers(command, ...args) {
+    const value = this.call(command, args);
+    if (!Array.isArray(value) || !value.every((item) => typeof item === "number")) {
+      throw resultTypeError(command, "number[]", value);
+    }
+    return value;
+  }
+  vectorRecord(command, tags) {
+    const rows = tags.map((tag) => [tag]);
+    const values = this.session.invokeMany === void 0 ? rows.map((row, index) => invokeNative(() => this.session.invoke(command, row), command, row, index)) : invokeNative(() => this.session.invokeMany(command, rows), command, []);
+    const record = {};
+    for (let index = 0; index < tags.length; index++) {
+      const value = values[index];
+      if (!Array.isArray(value) || !value.every((item) => typeof item === "number")) {
+        throw resultTypeError(command, "number[]", value);
+      }
+      record[tags[index]] = value;
+    }
+    return record;
+  }
+};
+function isNumericValue(value) {
+  return typeof value === "number" || Array.isArray(value) && value.every((item) => typeof item === "number");
+}
+function resultTypeError(command, expected, actual) {
+  return new TypeError(`${command} returned ${JSON.stringify(actual)}; expected ${expected}.`);
+}
+
+// src/native/OpenSeesNativeSession.ts
+var commandNames = new Set(OPEN_SEES_PY_COMMANDS);
+var OpenSeesNativeCommands = class {
+  constructor(session) {
+    this.session = session;
+    return new Proxy(this, {
+      get: (target, property, receiver) => {
+        if (typeof property === "string" && commandNames.has(property) && !(property in target)) {
+          const cached = target.methods.get(property);
+          if (cached !== void 0) return cached;
+          const method = (...args) => {
+            target.command(property, args);
+            return receiver;
+          };
+          target.methods.set(property, method);
+          return method;
+        }
+        return Reflect.get(target, property, receiver);
+      }
+    });
+  }
+  methods = /* @__PURE__ */ new Map();
+  command(name, args = []) {
+    const flattened = flattenNativeArguments(args);
+    invokeNative(() => this.session.invoke(name, flattened), name, flattened);
+    return this;
+  }
+  many(name, argumentRows) {
+    const rows = argumentRows.map((row) => flattenNativeArguments(row));
+    if (this.session.invokeMany) {
+      invokeNative(() => this.session.invokeMany(name, rows), name, [], void 0);
+    } else {
+      rows.forEach((row, index) => invokeNative(() => this.session.invoke(name, row), name, row, index));
+    }
+    return this;
+  }
+  nodes(rows) {
+    return this.many("node", rows);
+  }
+  elements(rows) {
+    return this.many("element", rows);
+  }
+  loads(rows) {
+    return this.many("load", rows);
+  }
+};
+var OpenSeesNativeSession = class {
+  bindingSession;
+  closed = false;
+  ops;
+  query;
+  constructor(options = {}) {
+    const binding = options.binding ?? loadNativeBinding(options.bindingPath);
+    this.bindingSession = binding.createSession();
+    this.ops = new OpenSeesNativeCommands(this.bindingSession);
+    this.query = new OpenSeesNativeQueries(this.bindingSession);
+  }
+  invoke(command, args = []) {
+    this.assertOpen();
+    const flattened = flattenNativeArguments(args);
+    return invokeNative(
+      () => this.bindingSession.invoke(command, flattened),
+      command,
+      flattened
+    );
+  }
+  invokeMany(command, argumentRows) {
+    this.assertOpen();
+    const rows = argumentRows.map((row) => flattenNativeArguments(row));
+    if (this.bindingSession.invokeMany) {
+      return invokeNative(
+        () => this.bindingSession.invokeMany(command, rows),
+        command,
+        []
+      );
+    }
+    return rows.map((row, index) => invokeNative(
+      () => this.bindingSession.invoke(command, row),
+      command,
+      row,
+      index
+    ));
+  }
+  close() {
+    if (this.closed) return;
+    this.bindingSession.close();
+    this.closed = true;
+  }
+  [Symbol.dispose]() {
+    this.close();
+  }
+  assertOpen() {
+    if (this.closed) throw new Error("The OpenSees native session is closed.");
+  }
+};
+
+// src/native/OpenSeesOps.ts
+function createOpenSeesOps(options = {}) {
+  let session;
+  const getSession = () => session ??= new OpenSeesNativeSession(options);
+  const methods = /* @__PURE__ */ new Map();
+  let facade;
+  facade = new Proxy({}, {
+    get(_target, property) {
+      if (property === "dispose") {
+        return () => {
+          session?.close();
+          session = void 0;
+        };
+      }
+      if (typeof property !== "string") return void 0;
+      const cached = methods.get(property);
+      if (cached !== void 0) return cached;
+      const method = (...args) => {
+        const current = getSession();
+        const isQuery = property in OpenSeesNativeQueries.prototype;
+        const owner = isQuery ? current.query : current.ops;
+        const value = Reflect.get(owner, property);
+        if (typeof value !== "function") return value;
+        const result = Reflect.apply(value, owner, args);
+        return result === current.ops ? facade : result;
+      };
+      methods.set(property, method);
+      return method;
+    }
+  });
+  return facade;
+}
+var ops = createOpenSeesOps();
+process.once("exit", () => ops.dispose());
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OPEN_SEES_PY_COMMANDS,
+  OPEN_SEES_PY_VERSION,
+  OpenSeesCommandError,
+  OpenSeesNativeCommands,
+  OpenSeesNativeQueries,
+  OpenSeesNativeSession,
+  createOpenSeesOps,
+  defaultNativeBindingPath,
+  inspectNativeBackend,
+  loadNativeBinding,
+  ops
+});
+//# sourceMappingURL=native-index.cjs.map