@gobolt/genesis 0.0.10 → 0.0.11

package/dist/components/Switch/styles.js

@@ -0,0 +1,456 @@
+import { d as L } from "../../styled-components.browser.esm-CZ1XM4o4.js";
+import * as h from "react";
+import { R as A } from "../../LoadingOutlined-C1qu6ymP.js";
+import { g as X, a as K, e as D, b as N, d as R, F as V } from "../../presets-Djh_L_6R.js";
+import { u as q } from "../../useMergedState-BoELfaU9.js";
+import { K as H } from "../../KeyCode-DM2sFh3-.js";
+import { W as _ } from "../../index-Dyl-ddV6.js";
+import { g as F, m as B, j as f, r as G, k as Q, C as U, D as J } from "../../index-ByspLxrB.js";
+import { u as Y } from "../../useSize-CPo2bUE3.js";
+import "../../index-DLdU7Tpd.js";
+var Z = ["prefixCls", "className", "checked", "defaultChecked", "disabled", "loadingIcon", "checkedChildren", "unCheckedChildren", "onClick", "onChange", "onKeyDown"], O = /* @__PURE__ */ h.forwardRef(function(e, n) {
+  var c, a = e.prefixCls, l = a === void 0 ? "rc-switch" : a, r = e.className, o = e.checked, t = e.defaultChecked, i = e.disabled, d = e.loadingIcon, s = e.checkedChildren, g = e.unCheckedChildren, C = e.onClick, p = e.onChange, w = e.onKeyDown, v = X(e, Z), M = q(!1, {
+    value: o,
+    defaultValue: t
+  }), y = K(M, 2), S = y[0], $ = y[1];
+  function k(u, I) {
+    var b = S;
+    return i || (b = u, $(b), p == null || p(b, I)), b;
+  }
+  function x(u) {
+    u.which === H.LEFT ? k(!1, u) : u.which === H.RIGHT && k(!0, u), w == null || w(u);
+  }
+  function m(u) {
+    var I = k(!S, u);
+    C == null || C(I, u);
+  }
+  var E = D(l, r, (c = {}, N(c, "".concat(l, "-checked"), S), N(c, "".concat(l, "-disabled"), i), c));
+  return /* @__PURE__ */ h.createElement("button", R({}, v, {
+    type: "button",
+    role: "switch",
+    "aria-checked": S,
+    disabled: i,
+    className: E,
+    ref: n,
+    onKeyDown: x,
+    onClick: m
+  }), d, /* @__PURE__ */ h.createElement("span", {
+    className: "".concat(l, "-inner")
+  }, /* @__PURE__ */ h.createElement("span", {
+    className: "".concat(l, "-inner-checked")
+  }, s), /* @__PURE__ */ h.createElement("span", {
+    className: "".concat(l, "-inner-unchecked")
+  }, g)));
+});
+O.displayName = "Switch";
+const ee = (e) => {
+  const {
+    componentCls: n,
+    trackHeightSM: c,
+    trackPadding: a,
+    trackMinWidthSM: l,
+    innerMinMarginSM: r,
+    innerMaxMarginSM: o,
+    handleSizeSM: t,
+    calc: i
+  } = e, d = `${n}-inner`, s = f(i(t).add(i(a).mul(2)).equal()), g = f(i(o).mul(2).equal());
+  return {
+    [n]: {
+      [`&${n}-small`]: {
+        minWidth: l,
+        height: c,
+        lineHeight: f(c),
+        [`${n}-inner`]: {
+          paddingInlineStart: o,
+          paddingInlineEnd: r,
+          [`${d}-checked, ${d}-unchecked`]: {
+            minHeight: c
+          },
+          [`${d}-checked`]: {
+            marginInlineStart: `calc(-100% + ${s} - ${g})`,
+            marginInlineEnd: `calc(100% - ${s} + ${g})`
+          },
+          [`${d}-unchecked`]: {
+            marginTop: i(c).mul(-1).equal(),
+            marginInlineStart: 0,
+            marginInlineEnd: 0
+          }
+        },
+        [`${n}-handle`]: {
+          width: t,
+          height: t
+        },
+        [`${n}-loading-icon`]: {
+          top: i(i(t).sub(e.switchLoadingIconSize)).div(2).equal(),
+          fontSize: e.switchLoadingIconSize
+        },
+        [`&${n}-checked`]: {
+          [`${n}-inner`]: {
+            paddingInlineStart: r,
+            paddingInlineEnd: o,
+            [`${d}-checked`]: {
+              marginInlineStart: 0,
+              marginInlineEnd: 0
+            },
+            [`${d}-unchecked`]: {
+              marginInlineStart: `calc(100% - ${s} + ${g})`,
+              marginInlineEnd: `calc(-100% + ${s} - ${g})`
+            }
+          },
+          [`${n}-handle`]: {
+            insetInlineStart: `calc(100% - ${f(i(t).add(a).equal())})`
+          }
+        },
+        [`&:not(${n}-disabled):active`]: {
+          [`&:not(${n}-checked) ${d}`]: {
+            [`${d}-unchecked`]: {
+              marginInlineStart: i(e.marginXXS).div(2).equal(),
+              marginInlineEnd: i(e.marginXXS).mul(-1).div(2).equal()
+            }
+          },
+          [`&${n}-checked ${d}`]: {
+            [`${d}-checked`]: {
+              marginInlineStart: i(e.marginXXS).mul(-1).div(2).equal(),
+              marginInlineEnd: i(e.marginXXS).div(2).equal()
+            }
+          }
+        }
+      }
+    }
+  };
+}, ne = (e) => {
+  const {
+    componentCls: n,
+    handleSize: c,
+    calc: a
+  } = e;
+  return {
+    [n]: {
+      [`${n}-loading-icon${e.iconCls}`]: {
+        position: "relative",
+        top: a(a(c).sub(e.fontSize)).div(2).equal(),
+        color: e.switchLoadingIconColor,
+        verticalAlign: "top"
+      },
+      [`&${n}-checked ${n}-loading-icon`]: {
+        color: e.switchColor
+      }
+    }
+  };
+}, ie = (e) => {
+  const {
+    componentCls: n,
+    trackPadding: c,
+    handleBg: a,
+    handleShadow: l,
+    handleSize: r,
+    calc: o
+  } = e, t = `${n}-handle`;
+  return {
+    [n]: {
+      [t]: {
+        position: "absolute",
+        top: c,
+        insetInlineStart: c,
+        width: r,
+        height: r,
+        transition: `all ${e.switchDuration} ease-in-out`,
+        "&::before": {
+          position: "absolute",
+          top: 0,
+          insetInlineEnd: 0,
+          bottom: 0,
+          insetInlineStart: 0,
+          backgroundColor: a,
+          borderRadius: o(r).div(2).equal(),
+          boxShadow: l,
+          transition: `all ${e.switchDuration} ease-in-out`,
+          content: '""'
+        }
+      },
+      [`&${n}-checked ${t}`]: {
+        insetInlineStart: `calc(100% - ${f(o(r).add(c).equal())})`
+      },
+      [`&:not(${n}-disabled):active`]: {
+        [`${t}::before`]: {
+          insetInlineEnd: e.switchHandleActiveInset,
+          insetInlineStart: 0
+        },
+        [`&${n}-checked ${t}::before`]: {
+          insetInlineEnd: 0,
+          insetInlineStart: e.switchHandleActiveInset
+        }
+      }
+    }
+  };
+}, ae = (e) => {
+  const {
+    componentCls: n,
+    trackHeight: c,
+    trackPadding: a,
+    innerMinMargin: l,
+    innerMaxMargin: r,
+    handleSize: o,
+    calc: t
+  } = e, i = `${n}-inner`, d = f(t(o).add(t(a).mul(2)).equal()), s = f(t(r).mul(2).equal());
+  return {
+    [n]: {
+      [i]: {
+        display: "block",
+        overflow: "hidden",
+        borderRadius: 100,
+        height: "100%",
+        paddingInlineStart: r,
+        paddingInlineEnd: l,
+        transition: `padding-inline-start ${e.switchDuration} ease-in-out, padding-inline-end ${e.switchDuration} ease-in-out`,
+        [`${i}-checked, ${i}-unchecked`]: {
+          display: "block",
+          color: e.colorTextLightSolid,
+          fontSize: e.fontSizeSM,
+          transition: `margin-inline-start ${e.switchDuration} ease-in-out, margin-inline-end ${e.switchDuration} ease-in-out`,
+          pointerEvents: "none",
+          minHeight: c
+        },
+        [`${i}-checked`]: {
+          marginInlineStart: `calc(-100% + ${d} - ${s})`,
+          marginInlineEnd: `calc(100% - ${d} + ${s})`
+        },
+        [`${i}-unchecked`]: {
+          marginTop: t(c).mul(-1).equal(),
+          marginInlineStart: 0,
+          marginInlineEnd: 0
+        }
+      },
+      [`&${n}-checked ${i}`]: {
+        paddingInlineStart: l,
+        paddingInlineEnd: r,
+        [`${i}-checked`]: {
+          marginInlineStart: 0,
+          marginInlineEnd: 0
+        },
+        [`${i}-unchecked`]: {
+          marginInlineStart: `calc(100% - ${d} + ${s})`,
+          marginInlineEnd: `calc(-100% + ${d} - ${s})`
+        }
+      },
+      [`&:not(${n}-disabled):active`]: {
+        [`&:not(${n}-checked) ${i}`]: {
+          [`${i}-unchecked`]: {
+            marginInlineStart: t(a).mul(2).equal(),
+            marginInlineEnd: t(a).mul(-1).mul(2).equal()
+          }
+        },
+        [`&${n}-checked ${i}`]: {
+          [`${i}-checked`]: {
+            marginInlineStart: t(a).mul(-1).mul(2).equal(),
+            marginInlineEnd: t(a).mul(2).equal()
+          }
+        }
+      }
+    }
+  };
+}, te = (e) => {
+  const {
+    componentCls: n,
+    trackHeight: c,
+    trackMinWidth: a
+  } = e;
+  return {
+    [n]: Object.assign(Object.assign(Object.assign(Object.assign({}, G(e)), {
+      position: "relative",
+      display: "inline-block",
+      boxSizing: "border-box",
+      minWidth: a,
+      height: c,
+      lineHeight: f(c),
+      verticalAlign: "middle",
+      background: e.colorTextQuaternary,
+      border: "0",
+      borderRadius: 100,
+      cursor: "pointer",
+      transition: `all ${e.motionDurationMid}`,
+      userSelect: "none",
+      [`&:hover:not(${n}-disabled)`]: {
+        background: e.colorTextTertiary
+      }
+    }), Q(e)), {
+      [`&${n}-checked`]: {
+        background: e.switchColor,
+        [`&:hover:not(${n}-disabled)`]: {
+          background: e.colorPrimaryHover
+        }
+      },
+      [`&${n}-loading, &${n}-disabled`]: {
+        cursor: "not-allowed",
+        opacity: e.switchDisabledOpacity,
+        "*": {
+          boxShadow: "none",
+          cursor: "not-allowed"
+        }
+      },
+      // rtl style
+      [`&${n}-rtl`]: {
+        direction: "rtl"
+      }
+    })
+  };
+}, ce = (e) => {
+  const {
+    fontSize: n,
+    lineHeight: c,
+    controlHeight: a,
+    colorWhite: l
+  } = e, r = n * c, o = a / 2, t = 2, i = r - t * 2, d = o - t * 2;
+  return {
+    trackHeight: r,
+    trackHeightSM: o,
+    trackMinWidth: i * 2 + t * 4,
+    trackMinWidthSM: d * 2 + t * 2,
+    trackPadding: t,
+    // Fixed value
+    handleBg: l,
+    handleSize: i,
+    handleSizeSM: d,
+    handleShadow: `0 2px 4px 0 ${new V("#00230b").setA(0.2).toRgbString()}`,
+    innerMinMargin: i / 2,
+    innerMaxMargin: i + t + t * 2,
+    innerMinMarginSM: d / 2,
+    innerMaxMarginSM: d + t + t * 2
+  };
+}, le = F("Switch", (e) => {
+  const n = B(e, {
+    switchDuration: e.motionDurationMid,
+    switchColor: e.colorPrimary,
+    switchDisabledOpacity: e.opacityLoading,
+    switchLoadingIconSize: e.calc(e.fontSizeIcon).mul(0.75).equal(),
+    switchLoadingIconColor: `rgba(0, 0, 0, ${e.opacityLoading})`,
+    switchHandleActiveInset: "-30%"
+  });
+  return [
+    te(n),
+    // inner style
+    ae(n),
+    // handle style
+    ie(n),
+    // loading style
+    ne(n),
+    // small style
+    ee(n)
+  ];
+}, ce);
+var de = function(e, n) {
+  var c = {};
+  for (var a in e) Object.prototype.hasOwnProperty.call(e, a) && n.indexOf(a) < 0 && (c[a] = e[a]);
+  if (e != null && typeof Object.getOwnPropertySymbols == "function") for (var l = 0, a = Object.getOwnPropertySymbols(e); l < a.length; l++)
+    n.indexOf(a[l]) < 0 && Object.prototype.propertyIsEnumerable.call(e, a[l]) && (c[a[l]] = e[a[l]]);
+  return c;
+};
+const re = /* @__PURE__ */ h.forwardRef((e, n) => {
+  const {
+    prefixCls: c,
+    size: a,
+    disabled: l,
+    loading: r,
+    className: o,
+    rootClassName: t,
+    style: i,
+    checked: d,
+    value: s,
+    defaultChecked: g,
+    defaultValue: C,
+    onChange: p
+  } = e, w = de(e, ["prefixCls", "size", "disabled", "loading", "className", "rootClassName", "style", "checked", "value", "defaultChecked", "defaultValue", "onChange"]), [v, M] = q(!1, {
+    value: d ?? s,
+    defaultValue: g ?? C
+  }), {
+    getPrefixCls: y,
+    direction: S,
+    switch: $
+  } = h.useContext(U), k = h.useContext(J), x = (l ?? k) || r, m = y("switch", c), E = /* @__PURE__ */ h.createElement("div", {
+    className: `${m}-handle`
+  }, r && /* @__PURE__ */ h.createElement(A, {
+    className: `${m}-loading-icon`
+  })), [u, I, b] = le(m), P = Y(a), T = D($ == null ? void 0 : $.className, {
+    [`${m}-small`]: P === "small",
+    [`${m}-loading`]: r,
+    [`${m}-rtl`]: S === "rtl"
+  }, o, t, I, b), j = Object.assign(Object.assign({}, $ == null ? void 0 : $.style), i), W = function() {
+    M(arguments.length <= 0 ? void 0 : arguments[0]), p == null || p.apply(void 0, arguments);
+  };
+  return u(/* @__PURE__ */ h.createElement(_, {
+    component: "Switch"
+  }, /* @__PURE__ */ h.createElement(O, Object.assign({}, w, {
+    checked: v,
+    onChange: W,
+    prefixCls: m,
+    className: T,
+    style: j,
+    disabled: x,
+    ref: n,
+    loadingIcon: E
+  }))));
+}), z = re;
+z.__ANT_SWITCH = !0;
+process.env.NODE_ENV !== "production" && (z.displayName = "Switch");
+const oe = ({ colors: e, borderRadius: n }) => `
+  &.ant-switch {
+    background-color: ${e.primary.active};
+    border-radius: ${n == null ? void 0 : n.BorderRadiusMd};
+    
+    /* Focus ring styles */
+    &:focus-visible {
+      outline: none;
+      box-shadow: 0 0 0 2px ${e.inputs.onsurface.focus};
+    }
+    
+    /* Unchecked states */
+    &:not(.ant-switch-checked) {
+      background-color: ${e.surface.tertiary};
+
+      &:hover {
+        background-color: ${e.status.info.surface};
+      }
+
+      &:focus {
+        background-color: ${e.surface.tertiary};
+      }
+
+      &:focus-visible {
+        outline: none;
+        box-shadow: 0 0 0 2px ${e.inputs.onsurface.focus};
+      }
+
+      &.ant-switch-disabled {
+        background-color: ${e.inputs.surface.disabled};
+      }
+    }
+
+    /* Checked states */
+    &-checked {
+      background-color: ${e.inputs.surface.checked};
+
+      &:hover {
+        background-color: ${e.inputs.surface["checked-hover"]};
+      }
+
+      &:focus {
+        background-color: ${e.inputs.surface["checked-focussed"]};
+      }
+
+      &:focus-visible {
+        outline: none;
+        box-shadow: 0 0 0 2px ${e.inputs.onsurface.focus};
+      }
+
+      &.ant-switch-disabled {
+        background-color: ${e.inputs.surface.disabled};
+      }
+    }
+  }
+`, be = L(z)`
+  ${({ theme: e }) => oe(e)}
+`;
+export {
+  be as Switch,
+  be as default
+};

package/dist/components/Table/Table.d.ts

@@ -0,0 +1,15 @@
+import * as React from "react";
+export type Column = {
+    title: string;
+    dataIndex: string;
+    key: string;
+    render?: (text: any, record: any) => React.ReactNode;
+};
+export interface TableProps {
+    dataSource: unknown[];
+    columns: Column[];
+    rowKey?: string | ((record: any) => string);
+    size?: "small" | "middle" | "large";
+}
+declare const Table: ({ columns, dataSource, rowKey, size, ...props }: TableProps) => import("react/jsx-runtime").JSX.Element;
+export default Table;

package/dist/components/Table/Table.js

@@ -0,0 +1,23 @@
+import { jsx as r } from "react/jsx-runtime";
+import { T as m } from "../../styles-D9iYILpv.js";
+const d = ({
+  columns: a,
+  dataSource: t,
+  rowKey: e = "id",
+  size: l = "small",
+  ...o
+}) => /* @__PURE__ */ r(
+  m,
+  {
+    "data-testid": "Table",
+    dataSource: t,
+    columns: a,
+    rowKey: e,
+    locale: { emptyText: "No Data" },
+    size: l,
+    ...o
+  }
+);
+export {
+  d as default
+};

package/dist/components/Table/__mocks__/table-mocks.d.ts

@@ -0,0 +1,20 @@
+import { ColumnsType } from 'antd/es/table';
+
+interface AppointmentWithSimpleAddress {
+    id: string;
+    number: string;
+    timerange: string;
+    status: AppointmentStatus;
+    address: {
+        nickname: string;
+        address: string;
+    };
+    job_subtype: "delivery" | "pickup";
+}
+export interface MockDataSource {
+    appointments: AppointmentWithSimpleAddress[];
+}
+type AppointmentStatus = "scheduled" | "completed" | "cancelled" | "in_progress";
+export declare const mockColumns: ColumnsType<AppointmentWithSimpleAddress>;
+export declare const mockDataSource: MockDataSource;
+export {};