@ferscloud/fers-calculation-web 0.2.47 → 0.2.49

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

@@ -162,6 +162,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
@@ -993,13 +1007,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 +1024,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 +1041,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 +1049,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 +1938,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;
@@ -1987,6 +2007,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 +2316,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
@@ -2322,6 +2367,17 @@ export interface components {
              *     that shares one factorization across many load cases).
              */
             solve_time_ms?: number | null;
+            /**
+             * @description Unilateral (tension-only / compression-only) members whose converged
+             *     engagement (active vs slack) differs from the first-order starting
+             *     state of this second-order solve. Advisory — engagement may
+             *     legitimately evolve during the nonlinear iteration — but on braced
+             *     frames with tension-only diagonals a flip is the signature of
+             *     converging onto a different equilibrium branch than the starting state
+             *     suggested; cross-check those members' axial forces. Absent when no
+             *     unilateral member flipped (and for first-order solves).
+             */
+            unilateral_engagement_flips?: number[] | null;
         };
         /**
          * @description A single solver diagnostic: a stable machine-readable `code` plus a
@@ -2498,13 +2554,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,13 @@ 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;
+
+/**
+ * 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, wasm_init
 } from "./fers_calculations_bg.js";

package/fers_calculations_bg.js

@@ -87,13 +87,47 @@ export function render_reports_from_json(json_data) {
         wasm.__wbindgen_free(deferred2_0, deferred2_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 +137,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.47",
+  "version": "0.2.49",
+  "license": "BSD-3-Clause",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Jeroen124/FERS_calculations.git"