@f1studio/form-spec 5.0.0-alpha.101

package/FormSpec.TS/fable_modules/Fable.Form.3.0.0/Fable.Form.fableproj

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project Sdk="Microsoft.NET.Sdk">
+    <PropertyGroup>
+        <TargetFramework>netstandard2.1</TargetFramework>
+        <Description>
+            Extensible core library used to build forms
+        </Description>
+        <FablePackageType>library</FablePackageType>
+        <PackageTags>fable-javascript</PackageTags>
+    </PropertyGroup>
+    <ItemGroup>
+        <Compile Include="Extensions.fs" />
+        <Compile Include="Error.fs" />
+        <Compile Include="Field.fs" />
+        <Compile Include="Base.fs" />
+    </ItemGroup>
+    <ItemGroup>
+      <PackageReference Include="EasyBuild.PackageReleaseNotes.Tasks">
+        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        <PrivateAssets>all</PrivateAssets>
+      </PackageReference>
+      <PackageReference Include="Fable.Package.SDK">
+        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        <PrivateAssets>all</PrivateAssets>
+      </PackageReference>
+      <PackageReference Include="FSharp.Core" />
+    </ItemGroup>
+</Project>

package/FormSpec.TS/fable_modules/Fable.Form.3.0.0/Field.fs

@@ -0,0 +1,24 @@
+module Fable.Form.Field
+
+type IAttributes =
+    abstract GetFieldId: unit -> string
+
+[<NoComparison; NoEquality>]
+type Field<'Attributes, 'Value, 'Values when 'Attributes :> IAttributes> =
+    {
+        Value: 'Value
+        Update: 'Value -> 'Values
+        Attributes: 'Attributes
+    }
+
+let mapValues
+    (fn: 'A -> 'B)
+    (field: Field<'Attributes, 'Value, 'A>)
+    : Field<'Attributes, 'Value, 'B>
+    =
+
+    {
+        Value = field.Value
+        Update = field.Update >> fn
+        Attributes = field.Attributes
+    }

package/FormSpec.TS/fable_modules/Fable.Form.3.0.0/Field.fs.js

@@ -0,0 +1,56 @@
+"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 Field$3 () {
+        return Field$3;
+    },
+    get Field$3_$reflection () {
+        return Field$3_$reflection;
+    },
+    get mapValues () {
+        return mapValues;
+    }
+});
+const _Types = require("@fable-org/fable-library-js/Types.js");
+const _Reflection = require("@fable-org/fable-library-js/Reflection.js");
+class Field$3 extends _Types.Record {
+    constructor(Value, Update, Attributes){
+        super();
+        this.Value = Value;
+        this.Update = Update;
+        this.Attributes = Attributes;
+    }
+}
+function Field$3_$reflection(gen0, gen1, gen2) {
+    return (0, _Reflection.record_type)("Fable.Form.Field.Field`3", [
+        gen0,
+        gen1,
+        gen2
+    ], Field$3, ()=>[
+            [
+                "Value",
+                gen1
+            ],
+            [
+                "Update",
+                (0, _Reflection.lambda_type)(gen1, gen2)
+            ],
+            [
+                "Attributes",
+                gen0
+            ]
+        ]);
+}
+function mapValues(fn, field) {
+    return new Field$3(field.Value, (arg)=>fn(field.Update(arg)), field.Attributes);
+} //# sourceMappingURL=Field.fs.ts.map
+
+//# sourceMappingURL=Field.fs.js.map

package/FormSpec.TS/fable_modules/Fable.Form.3.0.0/Field.fs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../FormSpec.TS/fable_modules/Fable.Form.3.0.0/Field.fs.ts"],"names":["field","fn"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAmBI,IAAA,QACYA,MAAAA,KAAAA,EAAAA,CAAAA,MACiBC,GAAhBD,MAAAA,MAAAA,CAAAA,OACIA,MAAAA,UAAAA"}

package/FormSpec.TS/fable_modules/Fable.Form.3.0.0/Field.fs.ts.map

@@ -0,0 +1 @@
+{"version":3,"sources":["./Field.fs"],"names":["field","fn"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;WAmBI,YACY,AAAAA,gCACC,AAAgBC,GAAhB,AAAAD,oBACI,AAAAA","file":null,"sourcesContent":null,"sourceRoot":null}

package/FormSpec.TS/fable_modules/Fable.Form.Simple.5.0.1/Fable.Form.Simple.fableproj

@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project Sdk="Microsoft.NET.Sdk">
+    <PropertyGroup>
+        <TargetFramework>netstandard2.1</TargetFramework>
+        <Description>
+Contains the global logic of how a form should behave.
+
+It can be used has a standalone library if you want to build your own fields or
+you can use Fable.Form.Simple.Bulma to have a ready to use fields made for Bulma CSS framework.
+        </Description>
+        <FablePackageType>library</FablePackageType>
+        <PackageTags>fable-javascript</PackageTags>
+    </PropertyGroup>
+    <ItemGroup>
+        <Compile Include="Form.fs" />
+    </ItemGroup>
+    <ItemGroup>
+        <ProjectReference Include="..\Fable.Form\Fable.Form.fsproj" />
+    </ItemGroup>
+    <ItemGroup>
+      <PackageReference Include="EasyBuild.PackageReleaseNotes.Tasks">
+        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        <PrivateAssets>all</PrivateAssets>
+      </PackageReference>
+      <PackageReference Include="Fable.Package.SDK">
+        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        <PrivateAssets>all</PrivateAssets>
+      </PackageReference>
+      <PackageReference Include="FSharp.Core" />
+    </ItemGroup>
+</Project>

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

@@ -0,0 +1,178 @@
+namespace Fable.Form.Simple
+
+open Fable.Form
+
+[<RequireQualifiedAccess>]
+module Form =
+
+    module View =
+
+        [<NoEquality; NoComparison>]
+        type OnSubmit = OnSubmit of (unit -> unit)
+
+        type State =
+            | Idle
+            | Loading
+            | ReadOnly
+            | Error of string
+            | Success of string
+
+        type ErrorTracking =
+            | ErrorTracking of
+                {|
+                    ShowAllErrors: bool
+                    ShowFieldError: Set<string>
+                |}
+
+        type Model<'Values> =
+            {
+                Values: 'Values
+                State: State
+                ErrorTracking: ErrorTracking
+            }
+
+        type Validation =
+            | ValidateOnBlur
+            | ValidateOnSubmit
+
+        [<RequireQualifiedAccess; NoComparison; NoEquality>]
+        type Action<'ViewNode> =
+            | SubmitOnly of string
+            | Custom of (State -> 'ViewNode)
+
+        [<NoComparison; NoEquality>]
+        type ViewConfig<'Values, 'Output, 'ViewNode> =
+            {
+                OnChange: Model<'Values> -> unit
+                OnSubmit: 'Output -> unit
+                Action: Action<'ViewNode>
+                Validation: Validation
+            }
+
+        [<NoComparison; NoEquality>]
+        type FormConfig<'Output, 'ViewNode> =
+            {
+                OnSubmit: OnSubmit option
+                State: State
+                Action: Action<'ViewNode>
+                Fields: 'ViewNode list
+            }
+
+        let idle (values: 'Values) =
+            {
+                Values = values
+                State = Idle
+                ErrorTracking =
+                    ErrorTracking
+                        {|
+                            ShowAllErrors = false
+                            ShowFieldError = Set.empty
+                        |}
+            }
+
+        let setLoading (formModel: Model<'Values>) =
+            { formModel with
+                State = Loading
+            }
+
+        [<NoComparison; NoEquality>]
+        type FieldConfig<'Values, 'Value> =
+            {
+                OnChange: 'Values -> unit
+                OnBlur: (string -> unit) option
+                Disabled: bool
+                IsReadOnly: bool
+                ShowError: string -> bool
+            }
+
+        let errorToString (error: Error.Error) =
+            match error with
+            | Error.RequiredFieldIsEmpty -> "This field is required"
+
+            | Error.ValidationFailed validationError -> validationError
+
+            | Error.External externalError -> externalError
+
+        let custom
+            (viewConfig: ViewConfig<'Values, 'Output, 'ViewNode>)
+            (renderForm: FormConfig<'Output, 'ViewNode> -> 'ViewNode)
+            (renderField: FieldConfig<'Values, 'Output> -> Base.FilledField<'Field> -> 'ViewNode)
+            (form: Base.Form<'Values, 'Output, 'Field>)
+            (model: Model<'Values>)
+            =
+
+            let (fields, result) =
+                let res = Base.fill form model.Values
+
+                res.Fields, res.Result
+
+            let (ErrorTracking errorTracking) = model.ErrorTracking
+
+            let onSubmit =
+                match result with
+                | Ok msg ->
+                    if model.State = Loading then
+                        None
+
+                    else
+                        (fun () -> viewConfig.OnSubmit msg) |> OnSubmit |> Some
+
+                | Result.Error _ ->
+                    if errorTracking.ShowAllErrors then
+                        None
+
+                    else
+                        fun () ->
+                            viewConfig.OnChange
+                                { model with
+                                    ErrorTracking =
+                                        ErrorTracking
+                                            {| errorTracking with
+                                                ShowAllErrors = true
+                                            |}
+                                }
+                        |> OnSubmit
+                        |> Some
+
+            let onBlur =
+                match viewConfig.Validation with
+                | ValidateOnSubmit -> None
+
+                | ValidateOnBlur ->
+                    Some(fun label ->
+                        viewConfig.OnChange
+                            { model with
+                                ErrorTracking =
+                                    ErrorTracking
+                                        {| errorTracking with
+                                            ShowFieldError =
+                                                Set.add label errorTracking.ShowFieldError
+                                        |}
+                            }
+                    )
+
+            let showError (label: string) =
+                errorTracking.ShowAllErrors || Set.contains label errorTracking.ShowFieldError
+
+            let fieldToElement =
+                renderField
+                    {
+                        OnChange =
+                            fun values ->
+                                viewConfig.OnChange
+                                    { model with
+                                        Values = values
+                                    }
+                        OnBlur = onBlur
+                        Disabled = model.State = Loading
+                        IsReadOnly = model.State = ReadOnly
+                        ShowError = showError
+                    }
+
+            renderForm
+                {
+                    OnSubmit = onSubmit
+                    Action = viewConfig.Action
+                    State = model.State
+                    Fields = List.map fieldToElement fields
+                }