@f1studio/form-spec 5.0.0-alpha.101

package/FormSpec.TS/fable_modules/Fable.Form.Simple.5.0.1/Form.fs.js

@@ -0,0 +1,464 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get Action$1 () {
+        return Action$1;
+    },
+    get Action$1_$reflection () {
+        return Action$1_$reflection;
+    },
+    get Action$1_Custom () {
+        return Action$1_Custom;
+    },
+    get Action$1_SubmitOnly () {
+        return Action$1_SubmitOnly;
+    },
+    get ErrorTracking () {
+        return ErrorTracking;
+    },
+    get ErrorTracking_$reflection () {
+        return ErrorTracking_$reflection;
+    },
+    get FieldConfig$2 () {
+        return FieldConfig$2;
+    },
+    get FieldConfig$2_$reflection () {
+        return FieldConfig$2_$reflection;
+    },
+    get FormConfig$2 () {
+        return FormConfig$2;
+    },
+    get FormConfig$2_$reflection () {
+        return FormConfig$2_$reflection;
+    },
+    get Model$1 () {
+        return Model$1;
+    },
+    get Model$1_$reflection () {
+        return Model$1_$reflection;
+    },
+    get OnSubmit () {
+        return OnSubmit;
+    },
+    get OnSubmit_$reflection () {
+        return OnSubmit_$reflection;
+    },
+    get State () {
+        return State;
+    },
+    get State_$reflection () {
+        return State_$reflection;
+    },
+    get State_Error () {
+        return State_Error;
+    },
+    get State_Idle () {
+        return State_Idle;
+    },
+    get State_Loading () {
+        return State_Loading;
+    },
+    get State_ReadOnly () {
+        return State_ReadOnly;
+    },
+    get State_Success () {
+        return State_Success;
+    },
+    get Validation () {
+        return Validation;
+    },
+    get Validation_$reflection () {
+        return Validation_$reflection;
+    },
+    get Validation_ValidateOnBlur () {
+        return Validation_ValidateOnBlur;
+    },
+    get Validation_ValidateOnSubmit () {
+        return Validation_ValidateOnSubmit;
+    },
+    get ViewConfig$3 () {
+        return ViewConfig$3;
+    },
+    get ViewConfig$3_$reflection () {
+        return ViewConfig$3_$reflection;
+    },
+    get custom () {
+        return custom;
+    },
+    get errorToString () {
+        return errorToString;
+    },
+    get idle () {
+        return idle;
+    },
+    get setLoading () {
+        return setLoading;
+    }
+});
+const _Types = require("@fable-org/fable-library-js/Types.js");
+const _Reflection = require("@fable-org/fable-library-js/Reflection.js");
+const _Set = require("@fable-org/fable-library-js/Set.js");
+const _Util = require("@fable-org/fable-library-js/Util.js");
+const _List = require("@fable-org/fable-library-js/List.js");
+const _Basefs = require("../Fable.Form.3.0.0/Base.fs.js");
+class OnSubmit extends _Types.Union {
+    cases() {
+        return [
+            "OnSubmit"
+        ];
+    }
+    constructor(Item){
+        super();
+        this.tag = 0;
+        this.fields = [
+            Item
+        ];
+    }
+}
+function OnSubmit_$reflection() {
+    return (0, _Reflection.union_type)("Fable.Form.Simple.Form.View.OnSubmit", [], OnSubmit, ()=>[
+            [
+                [
+                    "Item",
+                    (0, _Reflection.lambda_type)(_Reflection.unit_type, _Reflection.unit_type)
+                ]
+            ]
+        ]);
+}
+function State_Idle() {
+    return new State(0, []);
+}
+function State_Loading() {
+    return new State(1, []);
+}
+function State_ReadOnly() {
+    return new State(2, []);
+}
+function State_Error(Item) {
+    return new State(3, [
+        Item
+    ]);
+}
+function State_Success(Item) {
+    return new State(4, [
+        Item
+    ]);
+}
+class State extends _Types.Union {
+    cases() {
+        return [
+            "Idle",
+            "Loading",
+            "ReadOnly",
+            "Error",
+            "Success"
+        ];
+    }
+    constructor(tag, fields){
+        super(), this.tag = tag, this.fields = fields;
+    }
+}
+function State_$reflection() {
+    return (0, _Reflection.union_type)("Fable.Form.Simple.Form.View.State", [], State, ()=>[
+            [],
+            [],
+            [],
+            [
+                [
+                    "Item",
+                    _Reflection.string_type
+                ]
+            ],
+            [
+                [
+                    "Item",
+                    _Reflection.string_type
+                ]
+            ]
+        ]);
+}
+class ErrorTracking extends _Types.Union {
+    cases() {
+        return [
+            "ErrorTracking"
+        ];
+    }
+    constructor(Item){
+        super();
+        this.tag = 0;
+        this.fields = [
+            Item
+        ];
+    }
+}
+function ErrorTracking_$reflection() {
+    return (0, _Reflection.union_type)("Fable.Form.Simple.Form.View.ErrorTracking", [], ErrorTracking, ()=>[
+            [
+                [
+                    "Item",
+                    (0, _Reflection.anonRecord_type)([
+                        "ShowAllErrors",
+                        _Reflection.bool_type
+                    ], [
+                        "ShowFieldError",
+                        (0, _Reflection.class_type)("Microsoft.FSharp.Collections.FSharpSet`1", [
+                            _Reflection.string_type
+                        ])
+                    ])
+                ]
+            ]
+        ]);
+}
+class Model$1 extends _Types.Record {
+    constructor(Values, State, ErrorTracking){
+        super();
+        this.Values = Values;
+        this.State = State;
+        this.ErrorTracking = ErrorTracking;
+    }
+}
+function Model$1_$reflection(gen0) {
+    return (0, _Reflection.record_type)("Fable.Form.Simple.Form.View.Model`1", [
+        gen0
+    ], Model$1, ()=>[
+            [
+                "Values",
+                gen0
+            ],
+            [
+                "State",
+                State_$reflection()
+            ],
+            [
+                "ErrorTracking",
+                ErrorTracking_$reflection()
+            ]
+        ]);
+}
+function Validation_ValidateOnBlur() {
+    return new Validation(0, []);
+}
+function Validation_ValidateOnSubmit() {
+    return new Validation(1, []);
+}
+class Validation extends _Types.Union {
+    cases() {
+        return [
+            "ValidateOnBlur",
+            "ValidateOnSubmit"
+        ];
+    }
+    constructor(tag, fields){
+        super(), this.tag = tag, this.fields = fields;
+    }
+}
+function Validation_$reflection() {
+    return (0, _Reflection.union_type)("Fable.Form.Simple.Form.View.Validation", [], Validation, ()=>[
+            [],
+            []
+        ]);
+}
+function Action$1_SubmitOnly(Item) {
+    return new Action$1(0, [
+        Item
+    ]);
+}
+function Action$1_Custom(Item) {
+    return new Action$1(1, [
+        Item
+    ]);
+}
+class Action$1 extends _Types.Union {
+    cases() {
+        return [
+            "SubmitOnly",
+            "Custom"
+        ];
+    }
+    constructor(tag, fields){
+        super(), this.tag = tag, this.fields = fields;
+    }
+}
+function Action$1_$reflection(gen0) {
+    return (0, _Reflection.union_type)("Fable.Form.Simple.Form.View.Action`1", [
+        gen0
+    ], Action$1, ()=>[
+            [
+                [
+                    "Item",
+                    _Reflection.string_type
+                ]
+            ],
+            [
+                [
+                    "Item",
+                    (0, _Reflection.lambda_type)(State_$reflection(), gen0)
+                ]
+            ]
+        ]);
+}
+class ViewConfig$3 extends _Types.Record {
+    constructor(OnChange, OnSubmit, Action, Validation){
+        super();
+        this.OnChange = OnChange;
+        this.OnSubmit = OnSubmit;
+        this.Action = Action;
+        this.Validation = Validation;
+    }
+}
+function ViewConfig$3_$reflection(gen0, gen1, gen2) {
+    return (0, _Reflection.record_type)("Fable.Form.Simple.Form.View.ViewConfig`3", [
+        gen0,
+        gen1,
+        gen2
+    ], ViewConfig$3, ()=>[
+            [
+                "OnChange",
+                (0, _Reflection.lambda_type)(Model$1_$reflection(gen0), _Reflection.unit_type)
+            ],
+            [
+                "OnSubmit",
+                (0, _Reflection.lambda_type)(gen1, _Reflection.unit_type)
+            ],
+            [
+                "Action",
+                Action$1_$reflection(gen2)
+            ],
+            [
+                "Validation",
+                Validation_$reflection()
+            ]
+        ]);
+}
+class FormConfig$2 extends _Types.Record {
+    constructor(OnSubmit, State, Action, Fields){
+        super();
+        this.OnSubmit = OnSubmit;
+        this.State = State;
+        this.Action = Action;
+        this.Fields = Fields;
+    }
+}
+function FormConfig$2_$reflection(gen0, gen1) {
+    return (0, _Reflection.record_type)("Fable.Form.Simple.Form.View.FormConfig`2", [
+        gen0,
+        gen1
+    ], FormConfig$2, ()=>[
+            [
+                "OnSubmit",
+                (0, _Reflection.option_type)(OnSubmit_$reflection())
+            ],
+            [
+                "State",
+                State_$reflection()
+            ],
+            [
+                "Action",
+                Action$1_$reflection(gen1)
+            ],
+            [
+                "Fields",
+                (0, _Reflection.list_type)(gen1)
+            ]
+        ]);
+}
+function idle(values) {
+    return new Model$1(values, State_Idle(), new ErrorTracking({
+        ShowAllErrors: false,
+        ShowFieldError: (0, _Set.empty)({
+            Compare: _Util.comparePrimitives
+        })
+    }));
+}
+function setLoading(formModel) {
+    return new Model$1(formModel.Values, State_Loading(), formModel.ErrorTracking);
+}
+class FieldConfig$2 extends _Types.Record {
+    constructor(OnChange, OnBlur, Disabled, IsReadOnly, ShowError){
+        super();
+        this.OnChange = OnChange;
+        this.OnBlur = OnBlur;
+        this.Disabled = Disabled;
+        this.IsReadOnly = IsReadOnly;
+        this.ShowError = ShowError;
+    }
+}
+function FieldConfig$2_$reflection(gen0, gen1) {
+    return (0, _Reflection.record_type)("Fable.Form.Simple.Form.View.FieldConfig`2", [
+        gen0,
+        gen1
+    ], FieldConfig$2, ()=>[
+            [
+                "OnChange",
+                (0, _Reflection.lambda_type)(gen0, _Reflection.unit_type)
+            ],
+            [
+                "OnBlur",
+                (0, _Reflection.option_type)((0, _Reflection.lambda_type)(_Reflection.string_type, _Reflection.unit_type))
+            ],
+            [
+                "Disabled",
+                _Reflection.bool_type
+            ],
+            [
+                "IsReadOnly",
+                _Reflection.bool_type
+            ],
+            [
+                "ShowError",
+                (0, _Reflection.lambda_type)(_Reflection.string_type, _Reflection.bool_type)
+            ]
+        ]);
+}
+function errorToString(error) {
+    switch(error.tag){
+        case /* ValidationFailed */ 1:
+            return error.fields[0];
+        case /* External */ 2:
+            return error.fields[0];
+        default:
+            return "This field is required";
+    }
+}
+function custom(viewConfig, renderForm, renderField, form, model) {
+    let msg;
+    let patternInput;
+    const res = (0, _Basefs.fill)(form, model.Values);
+    patternInput = [
+        res.Fields,
+        res.Result
+    ];
+    const result = patternInput[1];
+    const errorTracking = model.ErrorTracking.fields[0];
+    return renderForm(new FormConfig$2(result.tag === /* Error */ 1 ? errorTracking.ShowAllErrors ? undefined : new OnSubmit(()=>{
+        viewConfig.OnChange(new Model$1(model.Values, model.State, new ErrorTracking({
+            ShowAllErrors: true,
+            ShowFieldError: errorTracking.ShowFieldError
+        })));
+    }) : (msg = result.fields[0], (0, _Util.equals)(model.State, State_Loading()) ? undefined : new OnSubmit(()=>{
+        viewConfig.OnSubmit(msg);
+    })), model.State, viewConfig.Action, (0, _List.map)((0, _Util.curry2)(renderField)(new FieldConfig$2((values)=>{
+        viewConfig.OnChange(new Model$1(values, model.State, model.ErrorTracking));
+    }, viewConfig.Validation.tag === /* ValidateOnBlur */ 0 ? (label)=>{
+        viewConfig.OnChange(new Model$1(model.Values, model.State, new ErrorTracking({
+            ShowAllErrors: errorTracking.ShowAllErrors,
+            ShowFieldError: (0, _Set.add)(label, errorTracking.ShowFieldError)
+        })));
+    } : undefined, (0, _Util.equals)(model.State, State_Loading()), (0, _Util.equals)(model.State, State_ReadOnly()), (label_1)=>{
+        if (errorTracking.ShowAllErrors) {
+            return true;
+        } else {
+            return (0, _Set.contains)(label_1, errorTracking.ShowFieldError);
+        }
+    })), patternInput[0])));
+} //# sourceMappingURL=Form.fs.ts.map
+
+//# sourceMappingURL=Form.fs.js.map

package/FormSpec.TS/fable_modules/Fable.Form.Simple.5.0.1/Form.fs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../FormSpec.TS/fable_modules/Fable.Form.Simple.5.0.1/Form.fs.ts"],"names":["values","formModel","error","msg","patternInput","res","form","model","result","errorTracking","renderForm","viewConfig","renderField","label"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA6DY,IAAA,QACaA,QAAAA,cAGL,IAAA,cAAA;uBAEwB;4BACC,UAAA,EAAA;;;;;;WAKjC,IAAA,QAAAC,UAAAA,MAAAA,EAAAA,iBAAAA,UAAAA,aAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAeMC,MAAAA,GAAAA;;YAGsC,OAAAA,MAAAA,MAAAA,CAAAA,EAAAA;;YAEV,OAAAA,MAAAA,MAAAA,CAAAA,EAAAA;;mBAJF;;;;QAuBvBC;IATLC,IAAAA;IACIC,MAAAA,UAAM,YAAA,EAAUC,MAAKC,MAAAA,MAAAA;IADzBH,eAAAA;QAGAC,IAAAA,MAAAA;QAAYA,IAAAA,MAAAA;KAAAA;IAHHG,MAAAA,SAATJ,YAAAA,CAAAA,EAAAA;IAKeK,MAAAA,gBAAiBF,MAAAA,aAAAA,CAAAA,MAAAA,CAAAA,EAAAA;IA+DpC,OAAAG,WACI,IAAA,aA7DM,AAAAF,OAAAA,GAAAA,KAAAA,SAAAA,GAAAA,IASCC,cAAAA,aAAAA,GACC,YAYG,IAAA,SAAA;QARCE,WAAAA,QAAAA,CACI,IAAA,QAAAJ,MAAAA,MAAAA,EAAAA,MAAAA,KAAAA,EAEQ,IAAA,cAAA;2BAEwB;4BADpBE,cAAAA,cAAAA;;UAjBvBN,MACDK,OAAAA,MAAAA,CAAAA,EAAAA,EAAG,gBAAA,EAAAD,MAAAA,KAAAA,EAAAA,mBACC,YAGuC,IAAA,SAAA;QAA5BI,WAAAA,QAAAA,CAAoBR;SA0D3BI,MAAAA,KAAAA,EADCI,WAAAA,MAAAA,MAEA,SAAA,EAAA,IAAA,YAAA,EAnBbC,aACI,IAAA,cAAA,CAAA;QAGYD,WAAAA,QAAAA,CACI,IAAA,QACaX,QADbO,MAAAA,KAAAA,EAAAA,MAAAA,aAAAA;OAzBd,AAAAI,WAAAA,UAAAA,CAAAA,GAAAA,KAAAA,kBAAAA,GAAAA,IAAAA,CAAAA;QAKEA,WAAAA,QAAAA,CACI,IAAA,QAAAJ,MAAAA,MAAAA,EAAAA,MAAAA,KAAAA,EAEQ,IAAA,cAAA;2BACIE,cAAAA,aAAAA;gCAEQ,QAAA,EAAQI,OAAMJ,cAAAA,cAAAA;;QAVxB,eA4BH,YAAA,EAAAF,MAAAA,KAAAA,EAAAA,sBACE,YAAA,EAAAA,MAAAA,KAAAA,EAAAA,mBAAAA,CAAAA;QAbrB,IAAAE,cAAAA,aAAAA,EAAAA;mBAAA;;YAA+B,WAAA,aAAA,EAAaI,SAAMJ,cAAAA,cAAAA;;SAnDlDL,YAAAA,CAAAA,EAAAA"}

package/FormSpec.TS/fable_modules/Fable.Form.Simple.5.0.1/Form.fs.ts.map

@@ -0,0 +1 @@
+{"version":3,"sources":["./Form.fs"],"names":["values","formModel","error","msg","patternInput","res","form","model","result","errorTracking","renderForm","viewConfig","renderField","label"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA6DY,YACaA,sBAGL;uBAEwB;wBACC;;;;;;;WAKjC,YAAA,AAAAC,mCAAA,AAAAA;;;;;;;;;;;;;;;;;;;;;;;;YAeMC;;AAGsC,mBAAA,AAAAA;;AAEV,mBAAA,AAAAA;;mBAJF;;;;;QAuBvBC;AATLC;AACIC,6CAAM,4BAAUC,MAAK,AAAAC;AADzBH,qBAGA,AAAAC,YAAY,AAAAA;AAHHG,8FAAT,AAAAJ;AAKeK,yFAAf,AAAgC,AAAAF;AA\u002BDpC,WAAA,AAAAG,WACI,iBA7DM,CAAA,AAAAF,iCASF,AAAG,AAAAC,8BACC,aAYG;AARC,AAAAE,4BACI,YAAA,AAAAJ,cAAA,AAAAA,aAEQ;2BAEwB;4BADjB,AAAHE;;aAjBvBN,MACD,AAAAK,kBAAA,AAAG,OAAA,AAAAD,gCACC,aAGuC;AAA5B,AAAAI,4BAAoBR;WA0D3B,AAAAI,aADC,AAAAI,mBAEA,2CAnBbC,aACI;AAGY,AAAAD,4BACI,YACaX,QADb,AAAAO,aAAA,AAAAA;OAzBd,CAAA,AAAAI;AAKE,AAAAA,4BACI,YAAA,AAAAJ,cAAA,AAAAA,aAEQ;2BACO,AAAHE;4BAEQ,YAAQI,OAAM,AAAAJ;;SAVxB,WA4BH,OAAA,AAAAF,\u002BBACE,OAAA,AAAAA;AAbrB,YAAA,AAAAE;mBAAA;;;AAA\u002BB,mBAAA,iBAAaI,SAAM,AAAAJ;;SAnDlD,AAAAL","file":null,"sourcesContent":null,"sourceRoot":null}

package/FormSpec.TS/fable_modules/Fable.React.Types.18.3.0/Fable.React.Extensions.fs

@@ -0,0 +1,17 @@
+[<AutoOpen>]
+module Fable.React.Extensions
+
+open Fable.Core
+
+type Browser.Types.Event with
+    /// Access the value from target
+    /// Equivalent to `(this.target :?> HTMLInputElement).value`
+    [<Emit("$0.target.value")>]
+    member this.Value: string =
+        (this.target :?> Browser.Types.HTMLInputElement).value
+
+    /// Access the checked property from target
+    /// Equivalent to `(this.target :?> HTMLInputElement).checked`
+    [<Emit("$0.target.checked")>]
+    member this.Checked: bool =
+        (this.target :?> Browser.Types.HTMLInputElement).``checked``

package/FormSpec.TS/fable_modules/Fable.React.Types.18.3.0/Fable.React.Hooks.fs

@@ -0,0 +1,152 @@
+namespace Fable.React
+
+open Fable.Core
+
+type IStateHook<'T> =
+    [<Emit("$0[0]")>]
+    abstract current: 'T
+    [<Emit("$0[1]($1)")>]
+    abstract update: 'T -> unit
+    [<Emit("$0[1]($1)")>]
+    abstract update: ('T -> 'T) -> unit
+
+// Alias kept for backwards compatibility
+type IRefHook<'T> = IRefValue<'T>
+
+type IReducerHook<'State,'Msg> =
+    [<Emit("$0[0]")>]
+    abstract current: 'State
+    [<Emit("$0[1]($1)")>]
+    abstract update: 'Msg -> unit
+
+type ITransitionHook =
+    [<Emit("$0[0]")>]
+    abstract isPending: bool
+    [<Emit("$0[1]($1)")>]
+    abstract startTransition: callback: (unit -> unit) -> unit
+
+type IHooks =
+    /// Returns the current state with a function to update it.
+    /// More info at  https://reactjs.org/docs/hooks-reference.html#usestate
+    abstract useState: initialState: 'T -> IStateHook<'T>
+
+    /// Returns the current state with a function to update it.
+    /// More info at https://reactjs.org/docs/hooks-reference.html#usestate
+    [<Emit("$0.useState($1)")>]
+    abstract useStateLazy: initialState: (unit->'T) -> IStateHook<'T>
+
+    /// Accepts a function that contains imperative, possibly effectful code.
+    /// More info at https://reactjs.org/docs/hooks-reference.html#useeffect
+    abstract useEffect: effect: (unit->unit) * ?dependencies: obj[] -> unit
+
+    /// Accepts a function that contains imperative, possibly effectful code.
+    /// The signature is identical to useEffect, but it fires synchronously after 
+    /// all DOM mutations. Use this to read layout from the DOM and synchronously 
+    /// re-render. Updates scheduled inside useLayoutEffect will be flushed 
+    /// synchronously, before the browser has a chance to paint.
+    /// More info at https://reactjs.org/docs/hooks-reference.html#uselayouteffect
+    abstract useLayoutEffect: effect: (unit->unit) * ?dependencies: obj[] -> unit
+
+    /// Accepts a function that contains effectful code and returns a disposable for clean-up
+    /// More info at https://reactjs.org/docs/hooks-reference.html#useeffect
+    [<Emit("""$0.useEffect(() => {
+        const disp = $1();
+        return () => disp.Dispose();
+    }{{, $2}})""")>]
+    abstract useEffectDisposable: effect: (unit->System.IDisposable) * ?dependencies: obj[] -> unit
+
+    // abstract useCallback (callback: unit -> unit, dependencies: obj[]): unit -> unit
+
+    /// Accepts a "create" function and an array of dependencies and returns a memoized value
+    /// More info at https://reactjs.org/docs/hooks-reference.html#usememo
+    abstract useMemo: callback: (unit->'T) * dependencies: obj[] -> 'T
+
+    /// The returned object will persist for the full lifetime of the component.
+    /// More info at https://reactjs.org/docs/hooks-reference.html#useref
+    abstract useRef: initialValue: 'T -> IRefValue<'T>
+
+    /// Accepts a context object (the value returned from createContext) and
+    /// returns the current context value for that context. The current context
+    /// value is determined by the value prop of the nearest <MyContext.Provider>
+    /// above the calling component in the tree.
+    /// More info at https://reactjs.org/docs/hooks-reference.html#usecontext
+    abstract useContext: ctx: IContext<'T> -> 'T
+
+    /// Display a label for custom hooks in React DevTools.
+    /// More info at https://reactjs.org/docs/hooks-reference.html#usedebugvalue
+    abstract useDebugValue: label: string -> unit
+
+    /// Defers formatting of debug value until the Hook is actually inspected
+    /// More info at https://reactjs.org/docs/hooks-reference.html#usedebugvalue
+    abstract useDebugValue: value: 'T * format: ('T->string) -> unit
+
+    /// An alternative to useState. Accepts a reducer of type (state, action) => newState, and returns the current state paired with a dispatch method.
+    /// More info at https://reactjs.org/docs/hooks-reference.html#usereducer
+    abstract useReducer: reducer: ('State -> 'Msg -> 'State) * initialState: 'State -> IReducerHook<'State, 'Msg>
+
+    /// An alternative to useState. Accepts a reducer of type (state, action) => newState, and returns the current state paired with a dispatch method.
+    /// More info at https://reactjs.org/docs/hooks-reference.html#usereducer
+    abstract useReducer: reducer: ('State -> 'Msg -> 'State) * initialArg: 'I * init: ('I -> 'State) -> IReducerHook<'State, 'Msg>
+
+    /// Returns a stateful value for the pending state of the transition, and a function to start it.
+    /// More info at https://reactjs.org/docs/hooks-reference.html#usetransition
+    /// Requires React 18.
+    abstract useTransition: unit -> ITransitionHook
+
+    /// useId is a hook for generating unique IDs that are stable across the server and client, while avoiding hydration mismatches.
+    /// More info at https://reactjs.org/docs/hooks-reference.html#useid
+    /// Requires React 18.
+    abstract useId: unit -> string
+
+    /// useDeferredValue accepts a value and returns a new copy of the value that will defer to more urgent updates. If the current render is the result of an urgent update, like user input, React will return the previous value and then render the new value after the urgent render has completed.
+    /// More info at https://reactjs.org/docs/hooks-reference.html#usedeferredvalue
+    /// Requires React 18.
+    abstract useDeferredValue: 'T -> 'T
+
+[<AutoOpen>]
+module HookBindings =
+    let private makeDummyStateHook value =
+        { new IStateHook<'T> with
+            member __.current = value
+            member __.update(x: 'T) = ()
+            member __.update(f: 'T->'T) = () }
+
+    let private makeDummyReducerHook state =
+        { new IReducerHook<'State,'Msg> with
+            member __.current = state
+            member __.update(msg: 'Msg) = () }
+
+    let private makeDummyTransitionHook () =
+        { new ITransitionHook with
+            member __.isPending = false
+            member __.startTransition callback = () }
+
+    #if FABLE_REPL_LIB
+    [<Global("React")>]
+    #else
+    [<Import("*", "react")>]
+    #endif
+    let Hooks: IHooks =
+        // Placeholder for SSR
+        { new IHooks with
+            member __.useState(initialState: 'T) =
+                makeDummyStateHook initialState
+            member __.useStateLazy(initialState) =
+                makeDummyStateHook (initialState())
+            member __.useEffect(effect, dependencies) = ()
+            member __.useEffectDisposable(effect, dependencies) = ()
+            member __.useMemo(callback, dependencies) = callback()
+            member __.useRef(initialValue) =
+                { new IRefValue<_> with
+                    member __.current with get() = initialValue and set _ = () }
+            member __.useContext ctx =
+                (ctx :?> ISSRContext<_>).DefaultValue
+            member __.useDebugValue(label): unit = ()
+            member __.useDebugValue(value, format): unit = ()
+            member __.useReducer(reducer,initialState) = makeDummyReducerHook initialState
+            member __.useReducer(reducer, initialArgument, init) = makeDummyReducerHook (init initialArgument)
+            member __.useTransition() = makeDummyTransitionHook()
+            member __.useDeferredValue value = value
+            member __.useId() = ""
+            member __.useLayoutEffect(effect, dependencies) = ()
+        }

package/FormSpec.TS/fable_modules/Fable.React.Types.18.3.0/Fable.React.Hooks.fs.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function HookBindings_makeDummyStateHook(value) {
+    return {
+        current: value,
+        update (x) {},
+        update (f) {}
+    };
+}
+function HookBindings_makeDummyReducerHook(state) {
+    return {
+        current: state,
+        update (msg) {}
+    };
+}
+function HookBindings_makeDummyTransitionHook() {
+    return {
+        isPending: false,
+        startTransition (callback) {}
+    };
+} //# sourceMappingURL=Fable.React.Hooks.fs.ts.map
+
+//# sourceMappingURL=Fable.React.Hooks.fs.js.map

package/FormSpec.TS/fable_modules/Fable.React.Types.18.3.0/Fable.React.Hooks.fs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../FormSpec.TS/fable_modules/Fable.React.Types.18.3.0/Fable.React.Hooks.fs.ts"],"names":["value","state"],"mappings":";;;;;;iBA6GgCA;;;;;;;iBAMAC;;;;;;mBAKE"}

package/FormSpec.TS/fable_modules/Fable.React.Types.18.3.0/Fable.React.Hooks.fs.ts.map

@@ -0,0 +1 @@
+{"version":3,"sources":["./Fable.React.Hooks.fs"],"names":["value","state"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6GgCA;;;;;;;;;;iBAMAC;;;;;;;;mBAKE","file":null,"sourcesContent":null,"sourceRoot":null}