@f1studio/form-spec 5.0.0-alpha.140 → 5.0.0-alpha.142

package/src/plugins/vitals/src/VitalsLogic.ts

@@ -0,0 +1,399 @@
+import { FSharpRef, Record } from "@fable-org/fable-library-js/Types.js";
+import { bind, value as value_2, map, defaultArg, Option } from "@fable-org/fable-library-js/Option.js";
+import { float64 } from "@fable-org/fable-library-js/Int32.js";
+import { IComparable, IEquatable } from "@fable-org/fable-library-js/Util.js";
+import { lambda_type, array_type, string_type, bool_type, record_type, option_type, float64_type, TypeInfo } from "@fable-org/fable-library-js/Reflection.js";
+import { join, split, isNullOrWhiteSpace } from "@fable-org/fable-library-js/String.js";
+import { tryParse } from "@fable-org/fable-library-js/Double.js";
+import { zip, map as map_1, tryFind, item } from "@fable-org/fable-library-js/Array.js";
+import { Shared_PluginDataProperty } from "../../../FormSpec.FS/FormSpec.js";
+import { FSharpList, tryFind as tryFind_1 } from "@fable-org/fable-library-js/List.js";
+
+export class VitalsData extends Record implements IEquatable<VitalsData>, IComparable<VitalsData> {
+    readonly Temperature: Option<float64>;
+    readonly SystolicBP: Option<float64>;
+    readonly DiastolicBP: Option<float64>;
+    readonly Pulse: Option<float64>;
+    readonly Respiration: Option<float64>;
+    readonly OxygenSaturation: Option<float64>;
+    readonly PainScale: Option<float64>;
+    constructor(Temperature: Option<float64>, SystolicBP: Option<float64>, DiastolicBP: Option<float64>, Pulse: Option<float64>, Respiration: Option<float64>, OxygenSaturation: Option<float64>, PainScale: Option<float64>) {
+        super();
+        this.Temperature = Temperature;
+        this.SystolicBP = SystolicBP;
+        this.DiastolicBP = DiastolicBP;
+        this.Pulse = Pulse;
+        this.Respiration = Respiration;
+        this.OxygenSaturation = OxygenSaturation;
+        this.PainScale = PainScale;
+    }
+}
+
+export function VitalsData_$reflection(): TypeInfo {
+    return record_type("Fable.Form.Simple.Bulma.Fields.VitalsField.VitalsLogic.VitalsData", [], VitalsData, () => [["Temperature", option_type(float64_type)], ["SystolicBP", option_type(float64_type)], ["DiastolicBP", option_type(float64_type)], ["Pulse", option_type(float64_type)], ["Respiration", option_type(float64_type)], ["OxygenSaturation", option_type(float64_type)], ["PainScale", option_type(float64_type)]]);
+}
+
+export class VitalsConfig extends Record implements IEquatable<VitalsConfig>, IComparable<VitalsConfig> {
+    readonly IncludeTemperature: boolean;
+    readonly IncludeBP: boolean;
+    readonly IncludePulse: boolean;
+    readonly IncludeRespiration: boolean;
+    readonly IncludeOxygenSat: boolean;
+    readonly IncludePainScale: boolean;
+    constructor(IncludeTemperature: boolean, IncludeBP: boolean, IncludePulse: boolean, IncludeRespiration: boolean, IncludeOxygenSat: boolean, IncludePainScale: boolean) {
+        super();
+        this.IncludeTemperature = IncludeTemperature;
+        this.IncludeBP = IncludeBP;
+        this.IncludePulse = IncludePulse;
+        this.IncludeRespiration = IncludeRespiration;
+        this.IncludeOxygenSat = IncludeOxygenSat;
+        this.IncludePainScale = IncludePainScale;
+    }
+}
+
+export function VitalsConfig_$reflection(): TypeInfo {
+    return record_type("Fable.Form.Simple.Bulma.Fields.VitalsField.VitalsLogic.VitalsConfig", [], VitalsConfig, () => [["IncludeTemperature", bool_type], ["IncludeBP", bool_type], ["IncludePulse", bool_type], ["IncludeRespiration", bool_type], ["IncludeOxygenSat", bool_type], ["IncludePainScale", bool_type]]);
+}
+
+export function isValidTemperature(temp: float64): boolean {
+    if (temp >= 95) {
+        return temp <= 108;
+    }
+    else {
+        return false;
+    }
+}
+
+export function isValidSystolicBP(sys: float64): boolean {
+    if (sys >= 60) {
+        return sys <= 200;
+    }
+    else {
+        return false;
+    }
+}
+
+export function isValidDiastolicBP(dia: float64): boolean {
+    if (dia >= 40) {
+        return dia <= 120;
+    }
+    else {
+        return false;
+    }
+}
+
+export function isValidPulse(pulse: float64): boolean {
+    if (pulse >= 40) {
+        return pulse <= 180;
+    }
+    else {
+        return false;
+    }
+}
+
+export function isValidRespiration(resp: float64): boolean {
+    if (resp >= 8) {
+        return resp <= 35;
+    }
+    else {
+        return false;
+    }
+}
+
+export function isValidOxygenSat(sat: float64): boolean {
+    if (sat >= 70) {
+        return sat <= 100;
+    }
+    else {
+        return false;
+    }
+}
+
+export function isValidPainScale(pain: float64): boolean {
+    if (pain >= 0) {
+        return pain <= 10;
+    }
+    else {
+        return false;
+    }
+}
+
+export function isCriticalTemperature(temp: float64): boolean {
+    if (temp < 96) {
+        return true;
+    }
+    else {
+        return temp > 104;
+    }
+}
+
+export function isCriticalSystolicBP(sys: float64): boolean {
+    if (sys < 90) {
+        return true;
+    }
+    else {
+        return sys > 180;
+    }
+}
+
+export function isCriticalDiastolicBP(dia: float64): boolean {
+    if (dia < 60) {
+        return true;
+    }
+    else {
+        return dia > 110;
+    }
+}
+
+export function isCriticalPulse(pulse: float64): boolean {
+    if (pulse < 50) {
+        return true;
+    }
+    else {
+        return pulse > 120;
+    }
+}
+
+export function isCriticalRespiration(resp: float64): boolean {
+    if (resp < 12) {
+        return true;
+    }
+    else {
+        return resp > 25;
+    }
+}
+
+export function isCriticalOxygenSat(sat: float64): boolean {
+    return sat < 95;
+}
+
+export function isNormalTemperature(temp: float64): boolean {
+    if (temp >= 97) {
+        return temp <= 99;
+    }
+    else {
+        return false;
+    }
+}
+
+export function parseVitalsData(value: string): VitalsData {
+    try {
+        if (isNullOrWhiteSpace(value)) {
+            return new VitalsData(undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+        }
+        else {
+            const parts: string[] = split(value, ["|"], undefined, 0);
+            const tryParseFloat = (s: string): Option<float64> => {
+                if (isNullOrWhiteSpace(s)) {
+                    return undefined;
+                }
+                else {
+                    let matchValue: [boolean, float64];
+                    let outArg = 0;
+                    matchValue = ([tryParse(s, new FSharpRef<float64>((): float64 => outArg, (v: float64): void => {
+                        outArg = v;
+                    })), outArg] as [boolean, float64]);
+                    if (matchValue[0]) {
+                        return matchValue[1];
+                    }
+                    else {
+                        return undefined;
+                    }
+                }
+            };
+            return new VitalsData((parts.length > 0) ? tryParseFloat(item(0, parts)) : undefined, (parts.length > 1) ? tryParseFloat(item(1, parts)) : undefined, (parts.length > 2) ? tryParseFloat(item(2, parts)) : undefined, (parts.length > 3) ? tryParseFloat(item(3, parts)) : undefined, (parts.length > 4) ? tryParseFloat(item(4, parts)) : undefined, (parts.length > 5) ? tryParseFloat(item(5, parts)) : undefined, (parts.length > 6) ? tryParseFloat(item(6, parts)) : undefined);
+        }
+    }
+    catch (matchValue_1: any) {
+        return new VitalsData(undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    }
+}
+
+export function serializeVitalsData(vitalsData: VitalsData): string {
+    const optToString = (opt: Option<float64>): string => defaultArg(map<float64, string>((value: float64): string => value.toString(), opt), "");
+    return join("|", [optToString(vitalsData.Temperature), optToString(vitalsData.SystolicBP), optToString(vitalsData.DiastolicBP), optToString(vitalsData.Pulse), optToString(vitalsData.Respiration), optToString(vitalsData.OxygenSaturation), optToString(vitalsData.PainScale)]);
+}
+
+export function getVitalStatus(value: Option<float64>, isValid: ((arg0: float64) => boolean), isCritical: ((arg0: float64) => boolean), isNormal: Option<((arg0: float64) => boolean)>): string {
+    let v_2: float64;
+    if (value == null) {
+        return "empty";
+    }
+    else if (isCritical(value_2(value))) {
+        const v_3: float64 = value_2(value);
+        return "critical";
+    }
+    else if (!isValid(value_2(value))) {
+        const v_4: float64 = value_2(value);
+        return "abnormal";
+    }
+    else if ((v_2 = value_2(value), (isNormal != null) && !value_2(isNormal)(v_2))) {
+        const v_5: float64 = value_2(value);
+        return "abnormal";
+    }
+    else {
+        return "normal";
+    }
+}
+
+export class VitalPropertyValidation extends Record implements IEquatable<VitalPropertyValidation>, IComparable<VitalPropertyValidation> {
+    readonly PropertyName: string;
+    readonly DisplayName: string;
+    readonly Unit: string;
+    readonly Value: string;
+    readonly IsValid: boolean;
+    readonly ClinicalStatus: string;
+    readonly Message: string;
+    constructor(PropertyName: string, DisplayName: string, Unit: string, Value: string, IsValid: boolean, ClinicalStatus: string, Message: string) {
+        super();
+        this.PropertyName = PropertyName;
+        this.DisplayName = DisplayName;
+        this.Unit = Unit;
+        this.Value = Value;
+        this.IsValid = IsValid;
+        this.ClinicalStatus = ClinicalStatus;
+        this.Message = Message;
+    }
+}
+
+export function VitalPropertyValidation_$reflection(): TypeInfo {
+    return record_type("Fable.Form.Simple.Bulma.Fields.VitalsField.VitalsLogic.VitalPropertyValidation", [], VitalPropertyValidation, () => [["PropertyName", string_type], ["DisplayName", string_type], ["Unit", string_type], ["Value", string_type], ["IsValid", bool_type], ["ClinicalStatus", string_type], ["Message", string_type]]);
+}
+
+export class VitalsValidationResult extends Record implements IEquatable<VitalsValidationResult>, IComparable<VitalsValidationResult> {
+    readonly IsValid: boolean;
+    readonly HasCriticalValues: boolean;
+    readonly Properties: VitalPropertyValidation[];
+    constructor(IsValid: boolean, HasCriticalValues: boolean, Properties: VitalPropertyValidation[]) {
+        super();
+        this.IsValid = IsValid;
+        this.HasCriticalValues = HasCriticalValues;
+        this.Properties = Properties;
+    }
+}
+
+export function VitalsValidationResult_$reflection(): TypeInfo {
+    return record_type("Fable.Form.Simple.Bulma.Fields.VitalsField.VitalsLogic.VitalsValidationResult", [], VitalsValidationResult, () => [["IsValid", bool_type], ["HasCriticalValues", bool_type], ["Properties", array_type(VitalPropertyValidation_$reflection())]]);
+}
+
+class VitalPropertyDef extends Record {
+    readonly Name: string;
+    readonly DisplayName: string;
+    readonly Unit: string;
+    readonly IsValid: ((arg0: float64) => boolean);
+    readonly IsCritical: ((arg0: float64) => boolean);
+    readonly IsNormal: Option<((arg0: float64) => boolean)>;
+    readonly ValidRangeDescription: string;
+    constructor(Name: string, DisplayName: string, Unit: string, IsValid: ((arg0: float64) => boolean), IsCritical: ((arg0: float64) => boolean), IsNormal: Option<((arg0: float64) => boolean)>, ValidRangeDescription: string) {
+        super();
+        this.Name = Name;
+        this.DisplayName = DisplayName;
+        this.Unit = Unit;
+        this.IsValid = IsValid;
+        this.IsCritical = IsCritical;
+        this.IsNormal = IsNormal;
+        this.ValidRangeDescription = ValidRangeDescription;
+    }
+}
+
+function VitalPropertyDef_$reflection(): TypeInfo {
+    return record_type("Fable.Form.Simple.Bulma.Fields.VitalsField.VitalsLogic.VitalPropertyDef", [], VitalPropertyDef, () => [["Name", string_type], ["DisplayName", string_type], ["Unit", string_type], ["IsValid", lambda_type(float64_type, bool_type)], ["IsCritical", lambda_type(float64_type, bool_type)], ["IsNormal", option_type(lambda_type(float64_type, bool_type))], ["ValidRangeDescription", string_type]]);
+}
+
+const vitalPropertyDefs: VitalPropertyDef[] = [new VitalPropertyDef("temperature", "Temperature", "°F", isValidTemperature, isCriticalTemperature, isNormalTemperature, "95–108°F"), new VitalPropertyDef("systolic_bp", "Systolic BP", "mmHg", isValidSystolicBP, isCriticalSystolicBP, undefined, "60–200 mmHg"), new VitalPropertyDef("diastolic_bp", "Diastolic BP", "mmHg", isValidDiastolicBP, isCriticalDiastolicBP, undefined, "40–120 mmHg"), new VitalPropertyDef("pulse", "Pulse", "BPM", isValidPulse, isCriticalPulse, undefined, "40–180 BPM"), new VitalPropertyDef("respiration", "Respiration", "RPM", isValidRespiration, isCriticalRespiration, undefined, "8–35 RPM"), new VitalPropertyDef("oxygen_saturation", "O₂ Sat", "%", isValidOxygenSat, isCriticalOxygenSat, undefined, "70–100%"), new VitalPropertyDef("pain_scale", "Pain", "/10", isValidPainScale, (_arg: float64): boolean => false, undefined, "0–10")];
+
+/**
+ * Validate a single vital property by name and raw string value.
+ */
+export function validateVitalsProperty(propertyName: string, rawValue: string): VitalPropertyValidation {
+    const defOpt: Option<VitalPropertyDef> = tryFind<VitalPropertyDef>((d: VitalPropertyDef): boolean => (d.Name === propertyName), vitalPropertyDefs);
+    if (defOpt != null) {
+        const def: VitalPropertyDef = value_2(defOpt);
+        if (isNullOrWhiteSpace(rawValue)) {
+            return new VitalPropertyValidation(def.Name, def.DisplayName, def.Unit, "", true, "empty", "");
+        }
+        else {
+            let matchValue: [boolean, float64];
+            let outArg = 0;
+            matchValue = ([tryParse(rawValue, new FSharpRef<float64>((): float64 => outArg, (v: float64): void => {
+                outArg = v;
+            })), outArg] as [boolean, float64]);
+            if (matchValue[0]) {
+                const v_1: float64 = matchValue[1];
+                if (!def.IsValid(v_1)) {
+                    return new VitalPropertyValidation(def.Name, def.DisplayName, def.Unit, rawValue, false, "invalid", ((((def.DisplayName + " must be ") + def.ValidRangeDescription) + ", got ") + rawValue) + def.Unit);
+                }
+                else if (def.IsCritical(v_1)) {
+                    return new VitalPropertyValidation(def.Name, def.DisplayName, def.Unit, rawValue, true, "critical", (((def.DisplayName + " ") + rawValue) + def.Unit) + " — CRITICAL");
+                }
+                else {
+                    const status: string = getVitalStatus(v_1, def.IsValid, def.IsCritical, def.IsNormal);
+                    return new VitalPropertyValidation(def.Name, def.DisplayName, def.Unit, rawValue, true, status, (status === "abnormal") ? ((((def.DisplayName + " ") + rawValue) + def.Unit) + " — above normal") : "");
+                }
+            }
+            else {
+                return new VitalPropertyValidation(def.Name, def.DisplayName, def.Unit, rawValue, false, "invalid", def.DisplayName + " must be a valid number");
+            }
+        }
+    }
+    else {
+        return new VitalPropertyValidation(propertyName, propertyName, "", rawValue, false, "invalid", "Unknown vital sign property: " + propertyName);
+    }
+}
+
+function validateTypedValue(def: VitalPropertyDef, value: Option<float64>): VitalPropertyValidation {
+    if (value != null) {
+        const v: float64 = value_2(value);
+        const rawValue: string = v.toString();
+        if (!def.IsValid(v)) {
+            return new VitalPropertyValidation(def.Name, def.DisplayName, def.Unit, rawValue, false, "invalid", ((((def.DisplayName + " must be ") + def.ValidRangeDescription) + ", got ") + rawValue) + def.Unit);
+        }
+        else if (def.IsCritical(v)) {
+            return new VitalPropertyValidation(def.Name, def.DisplayName, def.Unit, rawValue, true, "critical", (((def.DisplayName + " ") + rawValue) + def.Unit) + " — CRITICAL");
+        }
+        else {
+            const status: string = getVitalStatus(v, def.IsValid, def.IsCritical, def.IsNormal);
+            return new VitalPropertyValidation(def.Name, def.DisplayName, def.Unit, rawValue, true, status, (status === "abnormal") ? ((((def.DisplayName + " ") + rawValue) + def.Unit) + " — above normal") : "");
+        }
+    }
+    else {
+        return new VitalPropertyValidation(def.Name, def.DisplayName, def.Unit, "", true, "empty", "");
+    }
+}
+
+/**
+ * Core validator — operates on the typed domain object. Single source of medical truth.
+ * Studio calls this via parseVitalsData → validateVitalsData.
+ * HealixAI calls this via PluginDataProperty list → converter → validateVitalsData.
+ */
+export function validateVitalsData(data: VitalsData): VitalsValidationResult {
+    const results: VitalPropertyValidation[] = map_1<[VitalPropertyDef, Option<float64>], VitalPropertyValidation>((tupledArg: [VitalPropertyDef, Option<float64>]): VitalPropertyValidation => validateTypedValue(tupledArg[0], tupledArg[1]), zip<VitalPropertyDef, Option<float64>>(vitalPropertyDefs, [data.Temperature, data.SystolicBP, data.DiastolicBP, data.Pulse, data.Respiration, data.OxygenSaturation, data.PainScale]));
+    return new VitalsValidationResult(results.every((r: VitalPropertyValidation): boolean => r.IsValid), results.some((r_1: VitalPropertyValidation): boolean => (r_1.ClinicalStatus === "critical")), results);
+}
+
+/**
+ * Validate plugin data from the wire format. Parses to VitalsData, then delegates to validateVitalsData.
+ */
+export function validateVitalsPluginData(properties: FSharpList<Shared_PluginDataProperty>): VitalsValidationResult {
+    const getPropertyValue = (name: string): Option<float64> => bind<Shared_PluginDataProperty, float64>((p_1: Shared_PluginDataProperty): Option<float64> => {
+        if (isNullOrWhiteSpace(p_1.Value)) {
+            return undefined;
+        }
+        else {
+            let matchValue: [boolean, float64];
+            let outArg = 0;
+            matchValue = ([tryParse(p_1.Value, new FSharpRef<float64>((): float64 => outArg, (v: float64): void => {
+                outArg = v;
+            })), outArg] as [boolean, float64]);
+            if (matchValue[0]) {
+                return matchValue[1];
+            }
+            else {
+                return undefined;
+            }
+        }
+    }, tryFind_1<Shared_PluginDataProperty>((p: Shared_PluginDataProperty): boolean => (p.Name === name), properties));
+    return validateVitalsData(new VitalsData(getPropertyValue("temperature"), getPropertyValue("systolic_bp"), getPropertyValue("diastolic_bp"), getPropertyValue("pulse"), getPropertyValue("respiration"), getPropertyValue("oxygen_saturation"), getPropertyValue("pain_scale")));
+}
+
+//# sourceMappingURL=VitalsLogic.ts.map