@ferscloud/fers-calculation-web 0.2.48 → 0.2.50

package/LICENSE

@@ -0,0 +1,12 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, Jeroen Hermsen
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+3. Neither the name of the Jeroen Hermsen nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/fers-models.d.ts

@@ -130,17 +130,22 @@ export interface components {
              * @description Controls the geometric stiffness matrix formulation for P-Delta analysis.
              *     `Consistent` (default) uses full Przemieniecki K_g; `Simplified` uses
              *     P/L-only diagonal terms matching commercial solvers.
+             *     Only affects second-order (nonlinear) analysis: linear buckling always
+             *     uses the consistent K_g.
              */
             pdelta_formulation?: components["schemas"]["PdeltaFormulation"];
             /**
              * @description High-level P-Delta strategy.  `Full` (default) amplifies all directions.
-             *     `InPlaneOnly` auto-detects the out-of-plane axis from the model's
-             *     bounding box and suppresses it, matching commercial solver behavior.
+             *     `InPlaneOnly` auto-detects the out-of-plane axis by counting unique node
+             *     coordinate layers per axis and suppresses the thin one, matching
+             *     commercial solver behavior.
              *     Overrides `pdelta_suppress_axes` when set to `InPlaneOnly`.
+             *     Only affects second-order (nonlinear) analysis.
              */
             pdelta_mode?: components["schemas"]["PdeltaMode"];
             /**
              * @description Global translational axes to exclude from P-Delta amplification.
+             *     Only affects second-order (nonlinear) analysis.
              *
              *     When a structure is near buckling in an out-of-plane direction,
              *     the consistent P-Delta amplification can produce forces that differ
@@ -152,6 +157,10 @@ export interface components {
              *     all translational directions are amplified.
              *
              *     Maps to global DOFs: "X"→0,7  "Y"→1,8  "Z"→2,9  per element.
+             *
+             *     This is a P-Delta convergence aid, not a physical property: it is
+             *     deliberately ignored by linear buckling, where suppressing an axis would
+             *     erase that axis's modes and inflate α_cr.
              */
             pdelta_suppress_axes?: string[];
             /**
@@ -162,6 +171,20 @@ export interface components {
              * @default false
              */
             render_unity_reports: boolean;
+            /**
+             * @description Whitelist of result blocks to emit. `None`/absent (default) = full output
+             *     (backward compatible). When present, only the listed blocks are emitted:
+             *     scalar force/displacement blocks are omitted from member results; list/map
+             *     blocks (`section_forces`, `internal_force_series`, `displacement_nodes`,
+             *     `reaction_nodes`) are emitted empty. Applies to load cases and load
+             *     combinations alike. Unity checks, `summary`, `solver_diagnostics`,
+             *     `errors_and_warnings`, plate/modal/buckling/seismic results and
+             *     `report_html` are never filtered, and unity checks always evaluate on the
+             *     full results (the filter is applied after them, just before
+             *     serialization). `member_displacements` stays governed solely by
+             *     `include_member_deflected_shape`. An empty list is a maximal strip.
+             */
+            result_filter?: components["schemas"]["ResultBlock"][] | null;
             rigid_strategy: components["schemas"]["RigidStrategy"];
             /**
              * Format: int32
@@ -277,6 +300,12 @@ export interface components {
          */
         BucklingResults: {
             modes: components["schemas"]["BucklingMode"][];
+            /**
+             * @description Advisories that qualify these results — e.g. model content the
+             *     geometric stiffness does not cover. Empty when α_cr is unqualified.
+             * @default []
+             */
+            warnings: components["schemas"]["SolverMessage"][];
         };
         /**
          * @description One line of the transparent hand-calc: a symbolic formula, the same formula
@@ -993,13 +1022,15 @@ export interface components {
          *       `T`, and the interior sections inherit it. Consumers that need a
          *       tension-positive axial value (e.g. code checks classifying compression) must
          *       flip the sign of the series value.
+         *
+         *     All force/displacement blocks except `section_forces` are `Option` so that
+         *     `AnalysisOptions::result_filter` can omit unrequested blocks from the output;
+         *     they are always `Some` during the solve and are only set to `None` by the
+         *     post-unity-check strip pass (`functions::result_filter`). Absent (default =
+         *     no filter) every block is emitted.
          */
         MemberResult: {
-            /**
-             * @description Member-end force at the end node, in the **global** frame (Newton's-3rd-law
-             *     opposite of the start-node internal force).
-             */
-            end_node_forces: components["schemas"]["NodeForces"];
+            end_node_forces?: null | components["schemas"]["NodeForces"];
             /**
              * @description Continuous, ready-to-plot internal force diagram from `x_frac = 0` (start) to
              *     `x_frac = 1` (end), in the local frame: `local_start_forces`, then
@@ -1008,25 +1039,13 @@ export interface components {
              *     is continuous with no sawtooth across shared nodes.
              */
             internal_force_series?: components["schemas"]["SectionForce"][];
-            local_displacement_end_node: components["schemas"]["NodeDisplacement"];
-            local_displacement_start_node: components["schemas"]["NodeDisplacement"];
-            /**
-             * @description Internal force at the end node, in the member **local centroidal** frame.
-             *     This is the nodal-reaction convention, i.e. the Newton's-3rd-law opposite of
-             *     the internal force at the end — negate it to get the continuous internal value.
-             */
-            local_end_forces: components["schemas"]["NodeForces"];
-            /** @description Per-component maxima over the member, in the local frame. */
-            local_maximums: components["schemas"]["NodeForces"];
-            /** @description Per-component minima over the member, in the local frame. */
-            local_minimums: components["schemas"]["NodeForces"];
-            /**
-             * @description Internal force at the start node, in the member **local centroidal** frame
-             *     (corotated frame for nonlinear results). Equals `internal_force_series[0]`.
-             */
-            local_start_forces: components["schemas"]["NodeForces"];
-            /** @description Per-component maxima over the member (global frame). */
-            maximums: components["schemas"]["NodeForces"];
+            local_displacement_end_node?: null | components["schemas"]["NodeDisplacement"];
+            local_displacement_start_node?: null | components["schemas"]["NodeDisplacement"];
+            local_end_forces?: null | components["schemas"]["NodeForces"];
+            local_maximums?: null | components["schemas"]["NodeForces"];
+            local_minimums?: null | components["schemas"]["NodeForces"];
+            local_start_forces?: null | components["schemas"]["NodeForces"];
+            maximums?: null | components["schemas"]["NodeForces"];
             /**
              * @description Optional sampled deflected shape: the member's global displacement at
              *     evenly-spaced stations from `x_frac = 0` to `1`, reconstructed by
@@ -1037,8 +1056,7 @@ export interface components {
              *     is slightly under-rendered (matching client-side Hermite reconstructions).
              */
             member_displacements?: components["schemas"]["MemberDisplacementSample"][];
-            /** @description Per-component minima over the member (global frame). */
-            minimums: components["schemas"]["NodeForces"];
+            minimums?: null | components["schemas"]["NodeForces"];
             /**
              * @description Continuous internal forces at evenly-spaced **interior** fractions
              *     (`0 < x_frac < 1`), in the local frame. These already follow the internal-force
@@ -1046,8 +1064,7 @@ export interface components {
              *     endpoints use [`MemberResult::internal_force_series`].
              */
             section_forces: components["schemas"]["SectionForce"][];
-            /** @description Member-end force at the start node, in the **global** frame. */
-            start_node_forces: components["schemas"]["NodeForces"];
+            start_node_forces?: null | components["schemas"]["NodeForces"];
         };
         /**
          * @description A member set represents one physical beam: the ordered chain of collinear
@@ -1936,6 +1953,24 @@ export interface components {
                 points: number[][];
             };
         };
+        /**
+         * @description Selectable result-block groups for [`AnalysisOptions::result_filter`].
+         *     Wire tokens are snake_case, mirroring the JSON result field names they govern.
+         *
+         *     Python:
+         *     class ResultBlock(Enum):
+         *         LOCAL_ENVELOPES = "local_envelopes"
+         *         GLOBAL_ENVELOPES = "global_envelopes"
+         *         LOCAL_END_FORCES = "local_end_forces"
+         *         GLOBAL_END_FORCES = "global_end_forces"
+         *         SECTION_FORCES = "section_forces"
+         *         INTERNAL_FORCE_SERIES = "internal_force_series"
+         *         LOCAL_DISPLACEMENTS = "local_displacements"
+         *         NODE_DISPLACEMENTS = "node_displacements"
+         *         REACTIONS = "reactions"
+         * @enum {string}
+         */
+        ResultBlock: "local_envelopes" | "global_envelopes" | "local_end_forces" | "global_end_forces" | "section_forces" | "internal_force_series" | "local_displacements" | "node_displacements" | "reactions";
         ResultType: {
             /** Format: int32 */
             Loadcase: number;
@@ -1974,6 +2009,15 @@ export interface components {
         /** @description All analysis results: per load case, per load combination, unity-check results and the optional HTML report. */
         ResultsBundle: {
             buckling?: null | components["schemas"]["BucklingResults"];
+            /**
+             * @description Version of the `fers_calculations` engine that produced these results.
+             *
+             *     The input's `schema_version` says which contract the *caller* wrote to;
+             *     this says which engine answered. Stored results therefore record the
+             *     solver that produced them, and a caller can tell a fixed engine from a
+             *     broken one without inspecting the wheel.
+             */
+            engine_version?: string;
             loadcases: {
                 [key: string]: components["schemas"]["Results"];
             };
@@ -1987,6 +2031,13 @@ export interface components {
              */
             report_html?: string | null;
             seismic?: null | components["schemas"]["SeismicResults"];
+            /**
+             * @description Load combinations that failed to solve and are therefore missing from
+             *     `loadcombinations`. Always inspect before trusting envelopes or
+             *     unity-check verdicts computed over the surviving combinations.
+             * @default []
+             */
+            solve_failures: components["schemas"]["SolveFailure"][];
             /**
              * @description Unity-check results (one entry per check definition), enveloped over the
              *     applicable load combinations.
@@ -2289,6 +2340,24 @@ export interface components {
             name: string;
             shape_commands: components["schemas"]["ShapeCommand"][];
         };
+        /**
+         * @description A load combination that failed to solve (e.g. second-order non-convergence).
+         *     Failed combinations are absent from `ResultsBundle::loadcombinations`, so a
+         *     non-empty failure list means the result set is INCOMPLETE. Consumers must
+         *     surface this: non-convergence is often the physical signature of
+         *     instability — i.e. exactly the governing case.
+         */
+        SolveFailure: {
+            /**
+             * Format: int32
+             * @description Id of the load combination that failed to solve.
+             */
+            combination_id: number;
+            /** @description Human-readable solver error (non-convergence, singular system, …). */
+            error: string;
+            /** @description Name of the load combination that failed to solve. */
+            name: string;
+        };
         /**
          * @description Per-result solver run diagnostics: how the solve for this load case /
          *     combination actually ran. Populated best-effort; fields that are not
@@ -2509,13 +2578,20 @@ export interface components {
             /** @default [] */
             per_entity: components["schemas"]["EntityUnityResult"][];
             status: components["schemas"]["UnityStatus"];
+            /**
+             * @description Applicable load combinations that failed to solve and therefore could
+             *     not be evaluated. Non-empty ⇒ `status` is `Indeterminate` and the
+             *     reported utilizations cover only the combinations that solved.
+             * @default []
+             */
+            unsolved_combination_ids: number[];
         };
         /**
          * @description 4-colour utilization status. Derived from utilization vs the check's
          *     thresholds `[green→yellow, yellow→orange, orange→red]`.
          * @enum {string}
          */
-        UnityStatus: "Green" | "Yellow" | "Orange" | "Red";
+        UnityStatus: "Green" | "Yellow" | "Orange" | "Red" | "Indeterminate";
         /** @description Binds a friendly placeholder name (used in `{{name}}`) to a value source. */
         VarBinding: {
             name: string;

package/fers_calculations.d.ts

@@ -27,3 +27,20 @@ export function load_fers_from_file(path: string): string;
  * `report_html`. Returns the JSON envelope.
  */
 export function render_reports_from_json(json_data: string): string;
+
+/**
+ * The engine version, queryable without solving anything. The npm package
+ * version is set from the same `Cargo.toml` at build time, but a caller
+ * holding only the module needs a way to ask the engine which features it has.
+ */
+export function version(): string;
+
+/**
+ * Route panic messages to the browser console. wasm32-unknown-unknown does
+ * not unwind, so `run_enveloped`'s catch_unwind never fires in the browser —
+ * a panic aborts the instance with an opaque `RuntimeError: unreachable`.
+ * The hook at least makes the panic message + location readable in the
+ * console. Callers must still treat a thrown exception as fatal for the
+ * instance and recycle the worker.
+ */
+export function wasm_init(): void;

package/fers_calculations.js

@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./fers_calculations_bg.js";
 __wbg_set_wasm(wasm);
 wasm.__wbindgen_start();
 export {
-    calculate_from_json, calculate_from_json_with_token, load_fers_from_file, render_reports_from_json
+    calculate_from_json, calculate_from_json_with_token, load_fers_from_file, render_reports_from_json, version, wasm_init
 } from "./fers_calculations_bg.js";

package/fers_calculations_bg.js

@@ -87,13 +87,66 @@ export function render_reports_from_json(json_data) {
         wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
     }
 }
+
+/**
+ * The engine version, queryable without solving anything. The npm package
+ * version is set from the same `Cargo.toml` at build time, but a caller
+ * holding only the module needs a way to ask the engine which features it has.
+ * @returns {string}
+ */
+export function version() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.version();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * Route panic messages to the browser console. wasm32-unknown-unknown does
+ * not unwind, so `run_enveloped`'s catch_unwind never fires in the browser —
+ * a panic aborts the instance with an opaque `RuntimeError: unreachable`.
+ * The hook at least makes the panic message + location readable in the
+ * console. Callers must still treat a thrown exception as fatal for the
+ * instance and recycle the worker.
+ */
+export function wasm_init() {
+    wasm.wasm_init();
+}
 export function __wbg___wbindgen_throw_344f42d3211c4765(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
 }
+export function __wbg_error_a6fa202b58aa1cd3(arg0, arg1) {
+    let deferred0_0;
+    let deferred0_1;
+    try {
+        deferred0_0 = arg0;
+        deferred0_1 = arg1;
+        console.error(getStringFromWasm0(arg0, arg1));
+    } finally {
+        wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+    }
+}
+export function __wbg_new_227d7c05414eb861() {
+    const ret = new Error();
+    return ret;
+}
 export function __wbg_now_86c0d4ba3fa605b8() {
     const ret = Date.now();
     return ret;
 }
+export function __wbg_stack_3b0d974bbf31e44f(arg0, arg1) {
+    const ret = arg1.stack;
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+}
 export function __wbindgen_init_externref_table() {
     const table = wasm.__wbindgen_externrefs;
     const offset = table.grow(4);
@@ -103,6 +156,14 @@ export function __wbindgen_init_externref_table() {
     table.set(offset + 2, true);
     table.set(offset + 3, false);
 }
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
 function getStringFromWasm0(ptr, len) {
     return decodeText(ptr >>> 0, len);
 }

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@ferscloud/fers-calculation-web",
   "type": "module",
-  "version": "0.2.48",
+  "version": "0.2.50",
+  "license": "BSD-3-Clause",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Jeroen124/FERS_calculations.git"