ballerina-core 1.0.250 → 1.0.252

package/bin/src/template/state.js

@@ -1,126 +1,174 @@
 import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 import { unit } from "../../main";
 export const createTemplate = (actual) => {
-    const result = actual;
-    result.wrap = function (Wrapper) {
-        return Template.Operations.Wrap(this, Wrapper);
-    };
-    result.withView = function (view) {
-        return Template.Operations.WithView(this, view);
-    };
-    result.withViewFromProps = function (f) {
-        return Template.Operations.WithViewFromProps(this, f);
-    };
-    result.mapState = function (f) {
-        return Template.Operations.MapState(this, f);
-    };
-    result.mapStateFromProps = function (f) {
-        return Template.Operations.MapStateFromProps(this, f);
-    };
-    result.mapContext = function (f) {
-        return Template.Operations.MapContext(this, f);
-    };
-    result.mapForeignMutations = function (f) {
-        return Template.Operations.MapForeignMutations(this, f);
-    };
-    result.mapContextFromProps = function (f) {
-        return Template.Operations.MapContextFromProps(this, f);
-    };
-    result.mapForeignMutationsFromProps = function (f) {
-        return Template.Operations.MapForeignMutationsFromProps(this, f);
-    };
-    result.mapView = function (f) {
-        return Template.Operations.MapView(this, f);
-    };
-    result.mapViewFromProps = function (f) {
-        return Template.Operations.MapViewFromProps(this, f);
-    };
-    result.any = function (others) {
-        return Template.Operations.Any(this, others);
-    };
-    return result;
+  const result = actual;
+  result.wrap = function (Wrapper) {
+    return Template.Operations.Wrap(this, Wrapper);
+  };
+  result.withView = function (view) {
+    return Template.Operations.WithView(this, view);
+  };
+  result.withViewFromProps = function (f) {
+    return Template.Operations.WithViewFromProps(this, f);
+  };
+  result.mapState = function (f) {
+    return Template.Operations.MapState(this, f);
+  };
+  result.mapStateFromProps = function (f) {
+    return Template.Operations.MapStateFromProps(this, f);
+  };
+  result.mapContext = function (f) {
+    return Template.Operations.MapContext(this, f);
+  };
+  result.mapForeignMutations = function (f) {
+    return Template.Operations.MapForeignMutations(this, f);
+  };
+  result.mapContextFromProps = function (f) {
+    return Template.Operations.MapContextFromProps(this, f);
+  };
+  result.mapForeignMutationsFromProps = function (f) {
+    return Template.Operations.MapForeignMutationsFromProps(this, f);
+  };
+  result.mapView = function (f) {
+    return Template.Operations.MapView(this, f);
+  };
+  result.mapViewFromProps = function (f) {
+    return Template.Operations.MapViewFromProps(this, f);
+  };
+  result.any = function (others) {
+    return Template.Operations.Any(this, others);
+  };
+  return result;
 };
 export const Template = {
-    Default: (actual) => createTemplate(actual),
-    Operations: {
-        Wrap: (p, Wrapper) => createTemplate((props) => _jsx(Wrapper, { children: p(props) })),
-        WithView: (p, view) => createTemplate((props) => (_jsx(_Fragment, { children: p(Object.assign(Object.assign({}, props), { view: view })) }))),
-        WithViewFromProps: (p, f) => createTemplate((props) => (_jsx(_Fragment, { children: p(Object.assign(Object.assign({}, props), { view: f(props) })) }))),
-        MapState: (p, f) => createTemplate((props) => (_jsx(_Fragment, { children: p({
-                context: props.context,
-                setState: (_) => props.setState(f(_)),
-                foreignMutations: props.foreignMutations,
-                view: props.view,
-            }) }))),
-        MapStateFromProps: (p, f) => createTemplate((props) => (_jsx(_Fragment, { children: p({
-                context: props.context,
-                setState: (_) => props.setState(f([props, _])),
-                foreignMutations: props.foreignMutations,
-                view: props.view,
-            }) }))),
-        MapContext: (p, f) => createTemplate((props) => {
-            const context = f(props.context);
-            if (!context)
-                return _jsx(_Fragment, {});
-            return (_jsx(_Fragment, { children: p({
-                    context: context,
-                    setState: props.setState,
-                    foreignMutations: props.foreignMutations,
-                    view: props.view,
-                }) }));
+  Default: (actual) => createTemplate(actual),
+  Operations: {
+    Wrap: (p, Wrapper) =>
+      createTemplate((props) => _jsx(Wrapper, { children: p(props) })),
+    WithView: (p, view) =>
+      createTemplate((props) =>
+        _jsx(_Fragment, {
+          children: p(Object.assign(Object.assign({}, props), { view: view })),
         }),
-        MapForeignMutations: (p, f) => createTemplate((props) => (_jsx(_Fragment, { children: p({
-                context: props.context,
-                setState: props.setState,
-                foreignMutations: f(props.foreignMutations),
-                view: props.view,
-            }) }))),
-        MapContextFromProps: (p, f) => createTemplate((props) => {
-            const context = f(props);
-            if (!context)
-                return _jsx(_Fragment, {});
-            return (_jsx(_Fragment, { children: p({
-                    context: context,
-                    setState: props.setState,
-                    foreignMutations: props.foreignMutations,
-                    view: props.view,
-                }) }));
+      ),
+    WithViewFromProps: (p, f) =>
+      createTemplate((props) =>
+        _jsx(_Fragment, {
+          children: p(
+            Object.assign(Object.assign({}, props), { view: f(props) }),
+          ),
         }),
-        MapForeignMutationsFromProps: (p, f) => createTemplate((props) => (_jsx(_Fragment, { children: p({
-                context: props.context,
-                setState: props.setState,
-                foreignMutations: f(props),
-                view: props.view,
-            }) }))),
-        Any: (p, others) => createTemplate((props) => {
-            return (_jsx(_Fragment, { children: [
-                    p(props),
-                    ...others.map((_) => _({
-                        context: props.context,
-                        setState: props.setState,
-                        foreignMutations: props.foreignMutations,
-                        view: unit,
-                    })),
-                ] }));
+      ),
+    MapState: (p, f) =>
+      createTemplate((props) =>
+        _jsx(_Fragment, {
+          children: p({
+            context: props.context,
+            setState: (_) => props.setState(f(_)),
+            foreignMutations: props.foreignMutations,
+            view: props.view,
+          }),
+        }),
+      ),
+    MapStateFromProps: (p, f) =>
+      createTemplate((props) =>
+        _jsx(_Fragment, {
+          children: p({
+            context: props.context,
+            setState: (_) => props.setState(f([props, _])),
+            foreignMutations: props.foreignMutations,
+            view: props.view,
+          }),
         }),
-        MapView: (p, f) => createTemplate((props) => {
-            const view = f(props.view);
-            return (_jsx(_Fragment, { children: p({
-                    context: props.context,
-                    setState: props.setState,
-                    foreignMutations: props.foreignMutations,
-                    view: view,
-                }) }));
+      ),
+    MapContext: (p, f) =>
+      createTemplate((props) => {
+        const context = f(props.context);
+        if (!context) return _jsx(_Fragment, {});
+        return _jsx(_Fragment, {
+          children: p({
+            context: context,
+            setState: props.setState,
+            foreignMutations: props.foreignMutations,
+            view: props.view,
+          }),
+        });
+      }),
+    MapForeignMutations: (p, f) =>
+      createTemplate((props) =>
+        _jsx(_Fragment, {
+          children: p({
+            context: props.context,
+            setState: props.setState,
+            foreignMutations: f(props.foreignMutations),
+            view: props.view,
+          }),
         }),
-        MapViewFromProps: (p, f) => createTemplate((props) => {
-            const view = f(props);
-            return (_jsx(_Fragment, { children: p({
-                    context: props.context,
-                    setState: props.setState,
-                    foreignMutations: props.foreignMutations,
-                    view: view,
-                }) }));
+      ),
+    MapContextFromProps: (p, f) =>
+      createTemplate((props) => {
+        const context = f(props);
+        if (!context) return _jsx(_Fragment, {});
+        return _jsx(_Fragment, {
+          children: p({
+            context: context,
+            setState: props.setState,
+            foreignMutations: props.foreignMutations,
+            view: props.view,
+          }),
+        });
+      }),
+    MapForeignMutationsFromProps: (p, f) =>
+      createTemplate((props) =>
+        _jsx(_Fragment, {
+          children: p({
+            context: props.context,
+            setState: props.setState,
+            foreignMutations: f(props),
+            view: props.view,
+          }),
         }),
-    },
+      ),
+    Any: (p, others) =>
+      createTemplate((props) => {
+        return _jsx(_Fragment, {
+          children: [
+            p(props),
+            ...others.map((_) =>
+              _({
+                context: props.context,
+                setState: props.setState,
+                foreignMutations: props.foreignMutations,
+                view: unit,
+              }),
+            ),
+          ],
+        });
+      }),
+    MapView: (p, f) =>
+      createTemplate((props) => {
+        const view = f(props.view);
+        return _jsx(_Fragment, {
+          children: p({
+            context: props.context,
+            setState: props.setState,
+            foreignMutations: props.foreignMutations,
+            view: view,
+          }),
+        });
+      }),
+    MapViewFromProps: (p, f) =>
+      createTemplate((props) => {
+        const view = f(props);
+        return _jsx(_Fragment, {
+          children: p({
+            context: props.context,
+            setState: props.setState,
+            foreignMutations: props.foreignMutations,
+            view: view,
+          }),
+        });
+      }),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/validation/state.d.ts

@@ -1,10 +1,24 @@
 import { BasicFun, Unit, Option } from "../../main";
-export type ValidationResult = "valid" | {
-    kind: "error";
-    errors: Array<string>;
-};
-export type TypeDescriptor<T> = T extends Date ? "date" : T extends number ? "number" : T extends boolean ? "boolean" : T extends string ? "string" : T extends Unit ? {} & {
-    [_ in keyof T]: TypeDescriptor<T[_]>;
-} : never;
-export declare const parse: <E>(entityDescriptor: TypeDescriptor<E>) => BasicFun<any, Option<E>>;
-//# sourceMappingURL=state.d.ts.map
+export type ValidationResult =
+  | "valid"
+  | {
+      kind: "error";
+      errors: Array<string>;
+    };
+export type TypeDescriptor<T> = T extends Date
+  ? "date"
+  : T extends number
+    ? "number"
+    : T extends boolean
+      ? "boolean"
+      : T extends string
+        ? "string"
+        : T extends Unit
+          ? {} & {
+              [_ in keyof T]: TypeDescriptor<T[_]>;
+            }
+          : never;
+export declare const parse: <E>(
+  entityDescriptor: TypeDescriptor<E>,
+) => BasicFun<any, Option<E>>;
+//# sourceMappingURL=state.d.ts.map

package/bin/src/validation/state.js

@@ -1,51 +1,44 @@
 import { Sum, unit } from "../../main";
 export const parse = (entityDescriptor) => (raw) => {
-    if (entityDescriptor == "date") {
-        if (typeof raw == "string") {
-            const parsedTimestamp = Date.parse(raw);
-            if (!Number.isNaN(parsedTimestamp))
-                return Sum.Default.right(new Date(parsedTimestamp));
-        }
-        return Sum.Default.left(unit);
+  if (entityDescriptor == "date") {
+    if (typeof raw == "string") {
+      const parsedTimestamp = Date.parse(raw);
+      if (!Number.isNaN(parsedTimestamp))
+        return Sum.Default.right(new Date(parsedTimestamp));
     }
-    if (entityDescriptor == "number") {
-        if (typeof raw == "number")
-            return Sum.Default.right(raw);
-        else if (typeof raw == "string") {
-            let parsedNumber = parseInt(raw);
-            if (!Number.isNaN(parsedNumber))
-                return Sum.Default.right(parsedNumber);
-            parsedNumber = parseFloat(raw);
-            if (!Number.isNaN(parsedNumber))
-                return Sum.Default.right(parsedNumber);
-        }
-        return Sum.Default.left(unit);
+    return Sum.Default.left(unit);
+  }
+  if (entityDescriptor == "number") {
+    if (typeof raw == "number") return Sum.Default.right(raw);
+    else if (typeof raw == "string") {
+      let parsedNumber = parseInt(raw);
+      if (!Number.isNaN(parsedNumber)) return Sum.Default.right(parsedNumber);
+      parsedNumber = parseFloat(raw);
+      if (!Number.isNaN(parsedNumber)) return Sum.Default.right(parsedNumber);
     }
-    if (entityDescriptor == "boolean") {
-        if (typeof raw == "boolean")
-            return Sum.Default.right(raw);
-        else if (typeof raw == "string") {
-            let parsedBoolean = raw == "true" ? true : raw == "false" ? false : undefined;
-            if (parsedBoolean != undefined)
-                return Sum.Default.right(parsedBoolean);
-        }
-        return Sum.Default.left(unit);
+    return Sum.Default.left(unit);
+  }
+  if (entityDescriptor == "boolean") {
+    if (typeof raw == "boolean") return Sum.Default.right(raw);
+    else if (typeof raw == "string") {
+      let parsedBoolean =
+        raw == "true" ? true : raw == "false" ? false : undefined;
+      if (parsedBoolean != undefined) return Sum.Default.right(parsedBoolean);
     }
-    if (entityDescriptor == "string") {
-        if (typeof raw == "string")
-            return Sum.Default.right(raw);
-        return Sum.Default.left(unit);
-    }
-    let result = {};
-    for (const fieldName in entityDescriptor) {
-        const fieldDescriptor = entityDescriptor[fieldName];
-        if (fieldName in raw == false)
-            return Sum.Default.left(unit);
-        const parsedField = parse(fieldDescriptor)(raw[fieldName]);
-        if (parsedField.kind == "l")
-            return Sum.Default.left(unit);
-        result[fieldName] = parsedField.value;
-    }
-    return Sum.Default.right(raw);
+    return Sum.Default.left(unit);
+  }
+  if (entityDescriptor == "string") {
+    if (typeof raw == "string") return Sum.Default.right(raw);
+    return Sum.Default.left(unit);
+  }
+  let result = {};
+  for (const fieldName in entityDescriptor) {
+    const fieldDescriptor = entityDescriptor[fieldName];
+    if (fieldName in raw == false) return Sum.Default.left(unit);
+    const parsedField = parse(fieldDescriptor)(raw[fieldName]);
+    if (parsedField.kind == "l") return Sum.Default.left(unit);
+    result[fieldName] = parsedField.value;
+  }
+  return Sum.Default.right(raw);
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/value/domains/mutable-value/state.d.ts

@@ -1,9 +1,9 @@
 import { SimpleCallback } from "ballerina-core";
 import { Value } from "../../state";
 export type MutableValue<v> = Value<v> & {
-    onChange: SimpleCallback<v>;
+  onChange: SimpleCallback<v>;
 };
 export declare const MutableValue: {
-    Default: <v>(v: v, onChange: SimpleCallback<v>) => MutableValue<v>;
+  Default: <v>(v: v, onChange: SimpleCallback<v>) => MutableValue<v>;
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/value/domains/mutable-value/state.js

@@ -1,5 +1,6 @@
 import { Value } from "../../state";
 export const MutableValue = {
-    Default: (v, onChange) => (Object.assign(Object.assign({}, Value.Default(v)), { onChange })),
+  Default: (v, onChange) =>
+    Object.assign(Object.assign({}, Value.Default(v)), { onChange }),
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/value/state.d.ts

@@ -1,14 +1,14 @@
 import { BasicUpdater, Updater } from "../fun/domains/updater/state";
 export type Value<v> = {
-    value: v;
+  value: v;
 };
 export declare const Value: {
-    Default: <v>(v: v) => Value<v>;
-    Updaters: {
-        value: <v>(_: BasicUpdater<v>) => Updater<Value<v>>;
-    };
-    Operations: {
-        value: <v>(_: Value<v>) => v;
-    };
+  Default: <v>(v: v) => Value<v>;
+  Updaters: {
+    value: <v>(_: BasicUpdater<v>) => Updater<Value<v>>;
+  };
+  Operations: {
+    value: <v>(_: Value<v>) => v;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/value/state.js

@@ -1,11 +1,14 @@
 import { Updater } from "../fun/domains/updater/state";
 export const Value = {
-    Default: (v) => ({ value: v }),
-    Updaters: {
-        value: (_) => Updater((current) => (Object.assign(Object.assign({}, current), { value: _(current.value) }))),
-    },
-    Operations: {
-        value: (_) => _.value,
-    },
+  Default: (v) => ({ value: v }),
+  Updaters: {
+    value: (_) =>
+      Updater((current) =>
+        Object.assign(Object.assign({}, current), { value: _(current.value) }),
+      ),
+  },
+  Operations: {
+    value: (_) => _.value,
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map