@f1studio/form-spec 5.0.0-alpha.139 → 5.0.0-alpha.141

package/src/FormSpec.FS/Integrations/OpenFda/OpenFdaTypes.ts

@@ -0,0 +1,160 @@
+import { Record, Union } from "@fable-org/fable-library-js/Types.js";
+import { list_type, record_type, int32_type, option_type, string_type, union_type, TypeInfo } from "@fable-org/fable-library-js/Reflection.js";
+import { Option } from "@fable-org/fable-library-js/Option.js";
+import { int32 } from "@fable-org/fable-library-js/Int32.js";
+import { IComparable, IEquatable } from "@fable-org/fable-library-js/Util.js";
+import { FSharpList } from "@fable-org/fable-library-js/List.js";
+
+export type AllergyCategory_$union = 
+    | AllergyCategory<0>
+    | AllergyCategory<1>
+    | AllergyCategory<2>
+    | AllergyCategory<3>
+
+export type AllergyCategory_$cases = {
+    0: ["Drug", []],
+    1: ["Food", []],
+    2: ["Environmental", []],
+    3: ["Custom", []]
+}
+
+export function AllergyCategory_Drug() {
+    return new AllergyCategory<0>(0, []);
+}
+
+export function AllergyCategory_Food() {
+    return new AllergyCategory<1>(1, []);
+}
+
+export function AllergyCategory_Environmental() {
+    return new AllergyCategory<2>(2, []);
+}
+
+export function AllergyCategory_Custom() {
+    return new AllergyCategory<3>(3, []);
+}
+
+export class AllergyCategory<Tag extends keyof AllergyCategory_$cases> extends Union<Tag, AllergyCategory_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: AllergyCategory_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Drug", "Food", "Environmental", "Custom"];
+    }
+}
+
+export function AllergyCategory_$reflection(): TypeInfo {
+    return union_type("F1.Studio.Integrations.OpenFda.AllergyCategory", [], AllergyCategory, () => [[], [], [], []]);
+}
+
+export class OpenFdaSearchResult extends Record implements IEquatable<OpenFdaSearchResult>, IComparable<OpenFdaSearchResult> {
+    readonly Name: string;
+    readonly GenericName: Option<string>;
+    readonly SubstanceName: string;
+    readonly Category: AllergyCategory_$union;
+    readonly Source: string;
+    readonly NdcCode: Option<string>;
+    readonly Manufacturer: Option<string>;
+    readonly Route: Option<string>;
+    readonly DosageForm: Option<string>;
+    readonly Strength: Option<string>;
+    readonly ReportCount: Option<int32>;
+    constructor(Name: string, GenericName: Option<string>, SubstanceName: string, Category: AllergyCategory_$union, Source: string, NdcCode: Option<string>, Manufacturer: Option<string>, Route: Option<string>, DosageForm: Option<string>, Strength: Option<string>, ReportCount: Option<int32>) {
+        super();
+        this.Name = Name;
+        this.GenericName = GenericName;
+        this.SubstanceName = SubstanceName;
+        this.Category = Category;
+        this.Source = Source;
+        this.NdcCode = NdcCode;
+        this.Manufacturer = Manufacturer;
+        this.Route = Route;
+        this.DosageForm = DosageForm;
+        this.Strength = Strength;
+        this.ReportCount = ReportCount;
+    }
+}
+
+export function OpenFdaSearchResult_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Integrations.OpenFda.OpenFdaSearchResult", [], OpenFdaSearchResult, () => [["Name", string_type], ["GenericName", option_type(string_type)], ["SubstanceName", string_type], ["Category", AllergyCategory_$reflection()], ["Source", string_type], ["NdcCode", option_type(string_type)], ["Manufacturer", option_type(string_type)], ["Route", option_type(string_type)], ["DosageForm", option_type(string_type)], ["Strength", option_type(string_type)], ["ReportCount", option_type(int32_type)]]);
+}
+
+export class CountResult extends Record implements IEquatable<CountResult>, IComparable<CountResult> {
+    readonly Term: string;
+    readonly Count: int32;
+    constructor(Term: string, Count: int32) {
+        super();
+        this.Term = Term;
+        this.Count = (Count | 0);
+    }
+}
+
+export function CountResult_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Integrations.OpenFda.CountResult", [], CountResult, () => [["Term", string_type], ["Count", int32_type]]);
+}
+
+export class LabelWarnings extends Record implements IEquatable<LabelWarnings>, IComparable<LabelWarnings> {
+    readonly Contraindications: Option<string>;
+    readonly Warnings: Option<string>;
+    readonly AdverseReactions: Option<string>;
+    constructor(Contraindications: Option<string>, Warnings: Option<string>, AdverseReactions: Option<string>) {
+        super();
+        this.Contraindications = Contraindications;
+        this.Warnings = Warnings;
+        this.AdverseReactions = AdverseReactions;
+    }
+}
+
+export function LabelWarnings_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Integrations.OpenFda.LabelWarnings", [], LabelWarnings, () => [["Contraindications", option_type(string_type)], ["Warnings", option_type(string_type)], ["AdverseReactions", option_type(string_type)]]);
+}
+
+export class AllergenInsights extends Record implements IEquatable<AllergenInsights>, IComparable<AllergenInsights> {
+    readonly Reactions: FSharpList<CountResult>;
+    readonly TotalEvents: int32;
+    readonly LabelWarnings: Option<LabelWarnings>;
+    constructor(Reactions: FSharpList<CountResult>, TotalEvents: int32, LabelWarnings: Option<LabelWarnings>) {
+        super();
+        this.Reactions = Reactions;
+        this.TotalEvents = (TotalEvents | 0);
+        this.LabelWarnings = LabelWarnings;
+    }
+}
+
+export function AllergenInsights_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Integrations.OpenFda.AllergenInsights", [], AllergenInsights, () => [["Reactions", list_type(CountResult_$reflection())], ["TotalEvents", int32_type], ["LabelWarnings", option_type(LabelWarnings_$reflection())]]);
+}
+
+export class OpenFdaSearchResponse extends Record implements IEquatable<OpenFdaSearchResponse>, IComparable<OpenFdaSearchResponse> {
+    readonly Results: FSharpList<OpenFdaSearchResult>;
+    readonly Query: string;
+    readonly CachedAt: Option<string>;
+    constructor(Results: FSharpList<OpenFdaSearchResult>, Query: string, CachedAt: Option<string>) {
+        super();
+        this.Results = Results;
+        this.Query = Query;
+        this.CachedAt = CachedAt;
+    }
+}
+
+export function OpenFdaSearchResponse_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Integrations.OpenFda.OpenFdaSearchResponse", [], OpenFdaSearchResponse, () => [["Results", list_type(OpenFdaSearchResult_$reflection())], ["Query", string_type], ["CachedAt", option_type(string_type)]]);
+}
+
+export class OpenFdaInsightsResponse extends Record implements IEquatable<OpenFdaInsightsResponse>, IComparable<OpenFdaInsightsResponse> {
+    readonly Insights: AllergenInsights;
+    readonly SubstanceName: string;
+    readonly CachedAt: Option<string>;
+    constructor(Insights: AllergenInsights, SubstanceName: string, CachedAt: Option<string>) {
+        super();
+        this.Insights = Insights;
+        this.SubstanceName = SubstanceName;
+        this.CachedAt = CachedAt;
+    }
+}
+
+export function OpenFdaInsightsResponse_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Integrations.OpenFda.OpenFdaInsightsResponse", [], OpenFdaInsightsResponse, () => [["Insights", AllergenInsights_$reflection()], ["SubstanceName", string_type], ["CachedAt", option_type(string_type)]]);
+}
+
+//# sourceMappingURL=OpenFdaTypes.ts.map

package/src/FormSpec.FS/Interop/Facade/BlueprintFilledForm.ts

@@ -0,0 +1,244 @@
+import { bind, Option, unwrap } from "@fable-org/fable-library-js/Option.js";
+import { Shared_FieldValue_$union, Shared_PluginDataProperty, Shared_MatrixAnswer, Shared_FieldAnswer, Shared_MatrixItemKey, Shared_FieldKey } from "../../FormSpec.js";
+import { parse } from "@fable-org/fable-library-js/Guid.js";
+import { toList, minElement, toArray, FSharpSet } from "@fable-org/fable-library-js/Set.js";
+import { map } from "@fable-org/fable-library-js/Array.js";
+import { toArray as toArray_2, ofArray, tryHead } from "@fable-org/fable-library-js/List.js";
+import { createObj } from "@fable-org/fable-library-js/Util.js";
+import { toArray as toArray_1 } from "@fable-org/fable-library-js/Map.js";
+
+export type Brand$1<T> = void;
+
+export type Branded$1<Tag> = string;
+
+export interface FieldKeyBrand {
+
+}
+
+export interface MatrixItemKeyBrand {
+
+}
+
+export interface PluginPropKeyBrand {
+
+}
+
+export type BlueprintFilledFormFieldValueAnswerKind = 
+    | "single"
+    | "multiple"
+    | "matrix"
+    | "pluginData"
+
+export interface IFieldAnswer {
+    description: string,
+    documentation?: string,
+    fieldKey: Branded$1<FieldKeyBrand>,
+    value: string
+}
+
+export interface IPluginDataProperty {
+    dataType: string,
+    description?: string,
+    displayName?: string,
+    name: string,
+    propertyKey: Branded$1<PluginPropKeyBrand>,
+    unit?: string,
+    value: string
+}
+
+export type PluginDataType = 
+    | "string"
+    | "int"
+    | "float"
+    | "bool"
+    | "datetime"
+
+export interface ITypedPluginDataProperty {
+    dataType: PluginDataType,
+    description?: string,
+    displayName?: string,
+    name: string,
+    propertyKey: Branded$1<PluginPropKeyBrand>,
+    unit?: string,
+    value: string
+}
+
+export interface ISingleValue {
+    description: string,
+    fieldKey: Branded$1<FieldKeyBrand>,
+    kind: BlueprintFilledFormFieldValueAnswerKind,
+    value: string
+}
+
+export interface IMultipleValue {
+    description: string,
+    fieldKey: Branded$1<FieldKeyBrand>,
+    kind: BlueprintFilledFormFieldValueAnswerKind,
+    values: IFieldAnswer[]
+}
+
+export interface IMatrixValue {
+    description: string,
+    fieldKey: Branded$1<FieldKeyBrand>,
+    kind: BlueprintFilledFormFieldValueAnswerKind,
+    values: any
+}
+
+export interface IPluginDataValue {
+    kind: BlueprintFilledFormFieldValueAnswerKind,
+    properties: ITypedPluginDataProperty[]
+}
+
+/**
+ * Create a single-value field answer
+ */
+export function BlueprintFilledForm_single(fieldKey: Branded$1<FieldKeyBrand>, description: string, value: string, documentation: Option<string>): ISingleValue {
+    return {
+        description: description,
+        documentation: unwrap(documentation),
+        fieldKey: fieldKey,
+        kind: "single",
+        value: value,
+    };
+}
+
+/**
+ * Create a multi-select field answer
+ */
+export function BlueprintFilledForm_multiple(fieldKey: Branded$1<FieldKeyBrand>, description: string, values: IFieldAnswer[], documentation: Option<string>): IMultipleValue {
+    return {
+        description: description,
+        documentation: unwrap(documentation),
+        fieldKey: fieldKey,
+        kind: "multiple",
+        values: values,
+    };
+}
+
+/**
+ * Create a matrix/likert answer
+ */
+export function BlueprintFilledForm_matrix(fieldKey: Branded$1<FieldKeyBrand>, description: string, values: any, documentation: Option<string>): IMatrixValue {
+    return {
+        description: description,
+        documentation: unwrap(documentation),
+        fieldKey: fieldKey,
+        kind: "matrix",
+        values: values,
+    };
+}
+
+/**
+ * Create a plugin data field value
+ */
+export function BlueprintFilledForm_pluginData(properties: ITypedPluginDataProperty[]): IPluginDataValue {
+    return {
+        kind: "pluginData",
+        properties: properties,
+    };
+}
+
+/**
+ * Create a single field answer record
+ */
+export function BlueprintFilledForm_answer(fieldKey: Branded$1<FieldKeyBrand>, description: string, value: string, documentation: Option<string>): { description: string, documentation?: string, fieldKey: Branded$1<FieldKeyBrand>, value: string } {
+    return {
+        description: description,
+        documentation: unwrap(documentation),
+        fieldKey: fieldKey,
+        value: value,
+    };
+}
+
+/**
+ * Create a typed plugin data property
+ */
+export function BlueprintFilledForm_pluginProp(key: Branded$1<PluginPropKeyBrand>, name: string, dataType: PluginDataType, value: string): { dataType: PluginDataType, description?: Option<any>, displayName?: Option<any>, name: string, propertyKey: Branded$1<PluginPropKeyBrand>, unit?: Option<any>, value: string } {
+    return {
+        dataType: dataType,
+        name: name,
+        propertyKey: key,
+        value: value,
+    };
+}
+
+export function Convert_domainKeyToTs(_arg: Shared_FieldKey): Branded$1<FieldKeyBrand> {
+    const guid: string = _arg.fields[0];
+    return guid;
+}
+
+export function Convert_tsKeyToDomain(tsKey: Branded$1<FieldKeyBrand>): Shared_FieldKey {
+    return new Shared_FieldKey(parse(tsKey));
+}
+
+export function Convert_domainMatrixItemKeyToTs(_arg: Shared_MatrixItemKey): Branded$1<MatrixItemKeyBrand> {
+    const guid: string = _arg.fields[0];
+    return guid;
+}
+
+export function Convert_fieldAnswerToTs(fa: Shared_FieldAnswer): { description: string, documentation?: string, fieldKey: Branded$1<FieldKeyBrand>, value: string } {
+    const guid: string = fa.FieldKey.fields[0];
+    return {
+        description: fa.Description,
+        documentation: unwrap(fa.Documentation),
+        fieldKey: guid,
+        value: fa.Value,
+    };
+}
+
+export function Convert_fieldValueToTs(fv: Shared_FieldValue_$union): any {
+    switch (fv.tag) {
+        case /* Multiple */ 1: {
+            const fas: FSharpSet<Shared_FieldAnswer> = fv.fields[0];
+            const answers: IFieldAnswer[] = map<Shared_FieldAnswer, IFieldAnswer>(Convert_fieldAnswerToTs, toArray<Shared_FieldAnswer>(fas));
+            const firstFk: Shared_FieldKey = minElement<Shared_FieldAnswer>(fas).FieldKey;
+            return {
+                description: "",
+                documentation: unwrap(bind<Shared_FieldAnswer, string>((fa_2: Shared_FieldAnswer): Option<string> => fa_2.Documentation, tryHead<Shared_FieldAnswer>(toList<Shared_FieldAnswer>(fas)))),
+                fieldKey: Convert_domainKeyToTs(firstFk),
+                kind: "multiple",
+                values: answers,
+            };
+        }
+        case /* Matrix */ 2: {
+            const ma: Shared_MatrixAnswer = fv.fields[0];
+            const valuesObj: any = createObj(ofArray<[string, any]>(map<[Shared_MatrixItemKey, string], [string, any]>((tupledArg: [Shared_MatrixItemKey, string]): [string, any] => ([tupledArg[0].fields[0], tupledArg[1]] as [string, any]), toArray_1<Shared_MatrixItemKey, string>(ma.Values))));
+            return {
+                description: ma.Description,
+                documentation: unwrap(ma.Documentation),
+                fieldKey: Convert_domainKeyToTs(ma.FieldKey),
+                kind: "matrix",
+                values: valuesObj,
+            };
+        }
+        case /* PluginData */ 3:
+            return {
+                kind: "pluginData",
+                properties: map<Shared_PluginDataProperty, ITypedPluginDataProperty>((p: Shared_PluginDataProperty): { dataType: PluginDataType, description?: string, displayName?: string, name: string, propertyKey: Branded$1<PluginPropKeyBrand>, unit?: string, value: string } => {
+                    let matchValue: string;
+                    const guid: string = p.PropertyKey.fields[0];
+                    return {
+                        dataType: (matchValue = p.DataType.toLowerCase(), (matchValue === "string") ? "string" : ((matchValue === "int") ? "int" : ((matchValue === "float") ? "float" : ((matchValue === "bool") ? "bool" : ((matchValue === "datetime") ? "datetime" : "string"))))),
+                        description: unwrap(p.Description),
+                        displayName: unwrap(p.DisplayName),
+                        name: p.Name,
+                        propertyKey: guid,
+                        unit: unwrap(p.Unit),
+                        value: p.Value,
+                    };
+                }, toArray_2<Shared_PluginDataProperty>(fv.fields[0])),
+            };
+        default: {
+            const fa: Shared_FieldAnswer = fv.fields[0];
+            return {
+                description: fa.Description,
+                documentation: unwrap(fa.Documentation),
+                fieldKey: Convert_domainKeyToTs(fa.FieldKey),
+                kind: "single",
+                value: fa.Value,
+            };
+        }
+    }
+}
+
+//# sourceMappingURL=BlueprintFilledForm.ts.map