@plasmicpkgs/antd5 0.0.4

package/dist/antd.esm.js

@@ -0,0 +1,908 @@
+import { GlobalActionsProvider } from '@plasmicapp/host';
+import registerToken from '@plasmicapp/host/registerToken';
+import { addLoadingStateListener } from '@plasmicapp/query';
+import App from 'antd/es/app';
+import ConfigProvider from 'antd/es/config-provider';
+import theme from 'antd/es/theme';
+import React from 'react';
+import registerComponent from '@plasmicapp/host/registerComponent';
+import registerGlobalContext from '@plasmicapp/host/registerGlobalContext';
+import Select from 'antd/es/select';
+import Table from 'antd/es/table';
+
+function makeRegisterGlobalContext(component, meta) {
+  return function(loader) {
+    if (loader) {
+      loader.registerGlobalContext(component, meta);
+    } else {
+      registerGlobalContext(component, meta);
+    }
+  };
+}
+function registerComponentHelper(loader, component, meta) {
+  if (loader) {
+    loader.registerComponent(component, meta);
+  } else {
+    registerComponent(component, meta);
+  }
+}
+function traverseReactEltTree(children, callback) {
+  const rec = (elts) => {
+    (Array.isArray(elts) ? elts : [elts]).forEach((elt) => {
+      var _a;
+      if (elt) {
+        callback(elt);
+        if (elt.children) {
+          rec(elt.children);
+        }
+        if (((_a = elt.props) == null ? void 0 : _a.children) && elt.props.children !== elt.children) {
+          rec(elt.props.children);
+        }
+      }
+    });
+  };
+  rec(children);
+}
+function asArray(x) {
+  if (Array.isArray(x)) {
+    return x;
+  } else if (x == null) {
+    return [];
+  } else {
+    return [x];
+  }
+}
+
+var __defProp$2 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$2.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b)) {
+      if (__propIsEnum$2.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+var __objRest$2 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$2.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$2.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function themeToAntdConfig(opts) {
+  const {
+    colorTextBase,
+    colorPrimary,
+    colorSuccess,
+    colorWarning,
+    colorInfo,
+    fontFamily,
+    fontSize,
+    lineWidth,
+    borderRadius,
+    controlHeight,
+    sizeUnit,
+    sizeStep,
+    wireframe,
+    spacing
+  } = opts;
+  return __spreadProps$1(__spreadValues$2({}, spacing && { size: spacing }), {
+    theme: {
+      token: Object.fromEntries(Object.entries({
+        colorTextBase,
+        colorPrimary,
+        colorSuccess,
+        colorWarning,
+        colorInfo,
+        fontFamily,
+        fontSize,
+        lineWidth,
+        borderRadius,
+        controlHeight,
+        sizeUnit,
+        sizeStep,
+        wireframe
+      }).filter(([key, val]) => !!val))
+    }
+  });
+}
+function AntdConfigProvider(props) {
+  const _a = props, { children, themeStyles } = _a, rest = __objRest$2(_a, ["children", "themeStyles"]);
+  return /* @__PURE__ */ React.createElement(ConfigProvider, __spreadValues$2({}, themeToAntdConfig(__spreadProps$1(__spreadValues$2({}, rest), {
+    fontFamily: themeStyles.fontFamily,
+    fontSize: themeStyles.fontSize ? parseInt(themeStyles.fontSize) : void 0,
+    lineHeight: themeStyles.lineHeight ? parseInt(themeStyles.lineHeight) : void 0,
+    colorTextBase: themeStyles.color
+  }))), /* @__PURE__ */ React.createElement(App, null, /* @__PURE__ */ React.createElement(InnerConfigProvider, null, children)));
+}
+function InnerConfigProvider(props) {
+  const { children } = props;
+  const { token } = theme.useToken();
+  const makeVarName = (name) => `--antd-${name}`;
+  const cssStyles = React.useMemo(() => `
+:root {
+  ${Object.entries(token).map(([key, val]) => `${makeVarName(key)}:${typeof val === "string" ? val.trim() : val};`).join("\n")}
+}
+  `, [token]);
+  const app = App.useApp();
+  const actions = React.useMemo(() => ({
+    showNotification: (opts) => {
+      var _b;
+      const _a = opts, rest = __objRest$2(_a, ["type"]);
+      app.notification[(_b = opts.type) != null ? _b : "info"](__spreadValues$2({}, rest));
+    },
+    hideNotifications: () => {
+      app.notification.destroy();
+    }
+  }), [app]);
+  if (!GlobalActionsProvider) {
+    warnOutdatedDeps();
+  }
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement("style", null, cssStyles), GlobalActionsProvider && /* @__PURE__ */ React.createElement(GlobalActionsProvider, {
+    contextName: "plasmic-antd5-config-provider",
+    actions
+  }, children), /* @__PURE__ */ React.createElement(GlobalLoadingIndicator, null));
+}
+let warned = false;
+function warnOutdatedDeps() {
+  if (!warned) {
+    console.log(`You are using a version of @plasmicapp/* that is too old. Please upgrade to the latest version.`);
+    warned = true;
+  }
+}
+function GlobalLoadingIndicator() {
+  const app = App.useApp();
+  React.useEffect(() => {
+    if (addLoadingStateListener) {
+      return addLoadingStateListener((isLoading) => {
+        if (isLoading) {
+          app.message.open({
+            content: "Loading...",
+            duration: 0,
+            key: `plasmic-antd5-global-loading-indicator`
+          });
+        } else {
+          app.message.destroy(`plasmic-antd5-global-loading-indicator`);
+        }
+      }, { immediate: true });
+    } else {
+      warnOutdatedDeps();
+      return () => {
+      };
+    }
+  }, [app]);
+  return null;
+}
+function registerTokens(loader) {
+  const regs = [];
+  const makeColorToken = (name) => {
+    const colorIndex = name.indexOf("color");
+    const humanName = makeNiceName(colorIndex >= 0 ? name.substring(name.indexOf("color") + "color".length) : name);
+    return {
+      name: `Sys: ${humanName}`,
+      value: `var(--antd-${name})`,
+      type: "color"
+    };
+  };
+  function makeNiceName(name) {
+    name = name[0].toUpperCase() + name.substring(1);
+    return name.replace(/([a-z])([A-Z])/g, "$1 $2");
+  }
+  const colorTokens = [
+    "colorPrimary",
+    "colorSuccess",
+    "colorWarning",
+    "colorError",
+    "colorInfo",
+    "colorText",
+    "colorTextSecondary",
+    "colorTextTertiary",
+    "colorTextQuaternary",
+    "colorBorder",
+    "colorBorderSecondary",
+    "colorFill",
+    "colorFillSecondary",
+    "colorFillTertiary",
+    "colorFillQuaternary",
+    "colorBgLayout",
+    "colorBgContainer",
+    "colorBgElevated",
+    "colorBgSpotlight",
+    "colorPrimaryBg",
+    "colorPrimaryBgHover",
+    "colorPrimaryBorder",
+    "colorPrimaryBorderHover",
+    "colorPrimaryHover",
+    "colorPrimaryActive",
+    "colorPrimaryTextHover",
+    "colorPrimaryText",
+    "colorPrimaryTextActive",
+    "colorSuccessBg",
+    "colorSuccessBgHover",
+    "colorSuccessBorder",
+    "colorSuccessBorderHover",
+    "colorSuccessHover",
+    "colorSuccessActive",
+    "colorSuccessTextHover",
+    "colorSuccessText",
+    "colorSuccessTextActive",
+    "colorWarningBg",
+    "colorWarningBgHover",
+    "colorWarningBorder",
+    "colorWarningBorderHover",
+    "colorWarningHover",
+    "colorWarningActive",
+    "colorWarningTextHover",
+    "colorWarningText",
+    "colorWarningTextActive",
+    "colorInfoBg",
+    "colorInfoBgHover",
+    "colorInfoBorder",
+    "colorInfoBorderHover",
+    "colorInfoHover",
+    "colorInfoActive",
+    "colorInfoTextHover",
+    "colorInfoText",
+    "colorInfoTextActive",
+    "colorErrorBg",
+    "colorErrorBgHover",
+    "colorErrorBorder",
+    "colorErrorBorderHover",
+    "colorErrorHover",
+    "colorErrorActive",
+    "colorErrorTextHover",
+    "colorErrorText",
+    "colorErrorTextActive",
+    "colorWhite",
+    "colorBgMask",
+    "colorFillContentHover",
+    "colorFillAlter",
+    "colorFillContent",
+    "colorBgContainerDisabled",
+    "colorBgTextHover",
+    "colorBgTextActive",
+    "colorBorderBg",
+    "colorSplit",
+    "colorTextPlaceholder",
+    "colorTextDisabled",
+    "colorTextHeading",
+    "colorTextLabel",
+    "colorTextDescription",
+    "colorTextLightSolid",
+    "colorIcon",
+    "colorIconHover",
+    "colorLink",
+    "colorLinkHover",
+    "colorLinkActive",
+    "colorLinkHighlight",
+    "controlOutline",
+    "controlWarningOutline",
+    "controlErrorOutline",
+    "controlItemBgHover",
+    "controlItemBgActive",
+    "controlItemBgActiveHover",
+    "controlItemBgActiveDisabled"
+  ];
+  colorTokens.forEach((name) => regs.push(makeColorToken(name)));
+  const makeGenericToken = (name, type) => {
+    return {
+      name: `Sys: ${makeNiceName(name)}`,
+      value: `var(--antd-${name})`,
+      type
+    };
+  };
+  const spacingTokens = [
+    "lineWidth",
+    "borderRadius",
+    "controlHeight",
+    "sizeXXL",
+    "sizeXL",
+    "sizeLG",
+    "sizeMD",
+    "sizeMS",
+    "size",
+    "sizeSM",
+    "sizeXS",
+    "sizeXXS",
+    "controlHeightXS",
+    "controlHeightSM",
+    "controlHeightLG",
+    "lineWidthBold",
+    "borderRadiusXS",
+    "borderRadiusSM",
+    "borderRadiusLG",
+    "borderRadiusOuter",
+    "controlOutlineWidth",
+    "controlInteractiveSize",
+    "paddingXXS",
+    "paddingXS",
+    "paddingSM",
+    "padding",
+    "paddingMD",
+    "paddingLG",
+    "paddingXL",
+    "paddingContentHorizontalLG",
+    "paddingContentHorizontal",
+    "paddingContentHorizontalSM",
+    "paddingContentVerticalLG",
+    "paddingContentVertical",
+    "paddingContentVerticalSM",
+    "marginXXS",
+    "marginXS",
+    "marginSM",
+    "margin",
+    "marginMD",
+    "marginLG",
+    "marginXL",
+    "marginXXL",
+    "controlPaddingHorizontal",
+    "controlPaddingHorizontalSM"
+  ];
+  spacingTokens.forEach((token) => regs.push(makeGenericToken(token, "spacing")));
+  const fontSizeTokens = [
+    "fontSizeSM",
+    "fontSizeLG",
+    "fontSizeXL",
+    "fontSizeHeading1",
+    "fontSizeHeading2",
+    "fontSizeHeading3",
+    "fontSizeHeading4",
+    "fontSizeHeading5"
+  ];
+  fontSizeTokens.forEach((token) => regs.push(makeGenericToken(token, "font-size")));
+  const lineHeightTokens = [
+    "lineHeightLG",
+    "lineHeightSM",
+    "lineHeightHeading1",
+    "lineHeightHeading2",
+    "lineHeightHeading3",
+    "lineHeightHeading4",
+    "lineHeightHeading5"
+  ];
+  lineHeightTokens.forEach((token) => regs.push(makeGenericToken(token, "line-height")));
+  if (loader) {
+    regs.forEach((t) => loader.registerToken(t));
+  } else {
+    regs.forEach((t) => registerToken(t));
+  }
+}
+const registerConfigProvider = makeRegisterGlobalContext(AntdConfigProvider, __spreadProps$1(__spreadValues$2({
+  name: "plasmic-antd5-config-provider",
+  displayName: "Ant Design System Settings",
+  props: {
+    colorPrimary: {
+      type: "color",
+      defaultValue: "#1677ff"
+    },
+    colorSuccess: {
+      type: "color",
+      defaultValue: "#52c41a"
+    },
+    colorWarning: {
+      type: "color",
+      defaultValue: "#faad14"
+    },
+    colorError: {
+      type: "color",
+      defaultValue: "#ff4d4f"
+    },
+    colorInfo: {
+      type: "color",
+      defaultValue: "#1677ff"
+    },
+    colorBgBase: {
+      type: "color",
+      defaultValue: "#ffffff"
+    },
+    lineWidth: {
+      type: "number",
+      defaultValue: 1
+    },
+    borderRadius: {
+      type: "number",
+      defaultValue: 6
+    },
+    controlHeight: {
+      type: "number",
+      defaultValue: 32
+    },
+    sizeUnit: {
+      type: "number",
+      defaultValue: 4
+    },
+    sizeStep: {
+      type: "number",
+      defaultValue: 4
+    },
+    wireframe: {
+      type: "boolean",
+      defaultValue: false
+    },
+    spacing: {
+      type: "choice",
+      options: ["small", "middle", "large"]
+    },
+    themeStyles: {
+      type: "themeStyles"
+    }
+  }
+}, {
+  unstable__globalActions: {
+    showNotification: {
+      displayName: "Show notification",
+      parameters: {
+        type: {
+          type: "choice",
+          options: ["success", "error", "info", "warning"],
+          defaultValue: "info"
+        },
+        message: {
+          type: "string",
+          defaultValue: "A message for you!"
+        },
+        description: {
+          type: "string",
+          defaultValue: "Would you like to learn more?"
+        },
+        duration: {
+          type: "number",
+          defaultValueHint: 5
+        },
+        placement: {
+          type: "choice",
+          options: [
+            "top",
+            "topLeft",
+            "topRight",
+            "bottom",
+            "bottomLeft",
+            "bottomRight"
+          ],
+          defaultValueHint: "topRight"
+        }
+      }
+    },
+    hideNotifications: {
+      displayName: "Hide notifications"
+    }
+  }
+}), {
+  importPath: "@plasmicpkgs/antd5/skinny/registerConfigProvider",
+  importName: "AntdConfigProvider"
+}));
+
+var __defProp$1 = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest$1 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$1.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$1.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+const AntdOption = Select.Option;
+function AntdSelect(props) {
+  const _a = props, {
+    popupClassName,
+    popupScopeClassName,
+    defaultStylesClassName,
+    suffixIcon,
+    mode
+  } = _a, rest = __objRest$1(_a, [
+    "popupClassName",
+    "popupScopeClassName",
+    "defaultStylesClassName",
+    "suffixIcon",
+    "mode"
+  ]);
+  return /* @__PURE__ */ React.createElement(Select, __spreadValues$1(__spreadProps(__spreadValues$1({}, rest), {
+    mode: !mode || mode === "single" ? void 0 : mode,
+    popupClassName: `${defaultStylesClassName} ${popupScopeClassName} ${popupClassName}`
+  }), suffixIcon && { suffixIcon }));
+}
+function registerSelect(loader) {
+  registerComponentHelper(loader, AntdSelect, {
+    name: "plasmic-antd5-select",
+    displayName: "Select",
+    props: {
+      children: {
+        type: "slot",
+        allowedComponents: ["AntdOption"]
+      },
+      placeholder: {
+        type: "slot",
+        defaultValue: "Select..."
+      },
+      suffixIcon: {
+        type: "slot",
+        hidePlaceholder: true
+      },
+      open: {
+        type: "boolean",
+        editOnly: true,
+        uncontrolledProp: "defaultOpen"
+      },
+      value: {
+        type: "choice",
+        displayName: "Selected value",
+        editOnly: true,
+        uncontrolledProp: "defaultValue",
+        description: "Initial selected option",
+        multiSelect: (ps) => ps.mode === "multiple",
+        options: (ps) => {
+          const options = /* @__PURE__ */ new Set();
+          traverseReactEltTree(ps.children, (elt) => {
+            var _a;
+            if ((elt == null ? void 0 : elt.type) === Select.Option && typeof ((_a = elt == null ? void 0 : elt.props) == null ? void 0 : _a.value) === "string") {
+              options.add(elt.props.value);
+            }
+          });
+          return Array.from(options.keys());
+        }
+      },
+      mode: {
+        type: "choice",
+        options: ["single", "multiple"],
+        defaultValueHint: "single"
+      },
+      size: {
+        type: "choice",
+        options: ["small", "middle", "large"]
+      },
+      showSearch: {
+        type: "boolean",
+        defaultValueHint: false,
+        advanced: true
+      },
+      status: {
+        type: "choice",
+        options: ["error", "warning"],
+        advanced: true
+      },
+      bordered: {
+        type: "boolean",
+        defaultValueHint: true
+      },
+      autoFocus: {
+        type: "boolean",
+        displayName: "Focus automatically",
+        advanced: true
+      },
+      onChange: {
+        type: "eventHandler",
+        argTypes: [
+          { name: "value", type: "string" },
+          { name: "option", type: "object" }
+        ]
+      },
+      dropdownMatchSelectWidth: {
+        type: "boolean",
+        displayName: "Should dropdown match trigger button width?",
+        defaultValueHint: true,
+        advanced: true
+      },
+      triggerClassName: {
+        type: "class",
+        displayName: "Trigger styles",
+        noSelf: true,
+        selectors: [
+          {
+            selector: ":component .ant-select-selector.ant-select-selector",
+            label: "Base"
+          },
+          {
+            selector: ":component .ant-select-selector:hover",
+            label: "Hovered"
+          }
+        ],
+        advanced: true
+      },
+      popupScopeClassName: {
+        type: "styleScopeClass",
+        scopeName: "popup"
+      },
+      popupClassName: {
+        type: "class",
+        displayName: "Popup styles",
+        selectors: [],
+        advanced: true
+      },
+      optionClassName: {
+        type: "class",
+        displayName: "Option styles",
+        noSelf: true,
+        selectors: [
+          {
+            selector: ":popup.ant-select-dropdown .ant-select-item-option",
+            label: "Base"
+          },
+          {
+            selector: ":popup.ant-select-dropdown .ant-select-item-option-active",
+            label: "Focused"
+          },
+          {
+            selector: ":popup.ant-select-dropdown .ant-select-item-option-selected",
+            label: "Selected"
+          }
+        ],
+        advanced: true
+      },
+      placeholderClassName: {
+        type: "class",
+        displayName: "Placeholder styles",
+        selectors: [
+          {
+            selector: ":component .ant-select-selector .ant-select-selection-placeholder",
+            label: "Base"
+          }
+        ],
+        advanced: true
+      },
+      defaultStylesClassName: {
+        type: "themeResetClass"
+      },
+      tagRender: {
+        type: "slot",
+        renderPropParams: ["tagProps"],
+        hidePlaceholder: true
+      }
+    },
+    unstable__states: {
+      value: {
+        type: "writable",
+        valueProp: "value",
+        onChangeProp: "onChange"
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/skinny/registerSelect",
+    importName: "AntdSelect"
+  });
+  registerComponentHelper(loader, AntdOption, {
+    name: "plasmic-antd5-option",
+    displayName: "Option",
+    parentComponentName: "plasmic-antd5-select",
+    props: {
+      children: {
+        type: "slot",
+        defaultValue: "Option"
+      },
+      value: {
+        type: "string"
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/skinny/registerSelect",
+    importName: "AntdOption"
+  });
+}
+
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function AntdTable(props) {
+  var _b;
+  const _a = props, {
+    data,
+    onSelectionChange,
+    isSelectable,
+    rowKey,
+    setControlContextData,
+    selectedRowKeys
+  } = _a, rest = __objRest(_a, [
+    "data",
+    "onSelectionChange",
+    "isSelectable",
+    "rowKey",
+    "setControlContextData",
+    "selectedRowKeys"
+  ]);
+  setControlContextData == null ? void 0 : setControlContextData(data);
+  const selection = isSelectable ? {
+    onChange: (rowKeys, rows) => {
+      onSelectionChange == null ? void 0 : onSelectionChange(rowKeys, rows);
+    },
+    type: isSelectable === "single" ? "radio" : "checkbox",
+    selectedRowKeys: (_b = asArray(selectedRowKeys)) != null ? _b : []
+  } : void 0;
+  return /* @__PURE__ */ React.createElement(Table, __spreadValues({
+    loading: data == null ? void 0 : data.isLoading,
+    dataSource: data == null ? void 0 : data.data,
+    rowSelection: selection,
+    rowKey
+  }, rest));
+}
+const AntdColumnGroup = Table.ColumnGroup;
+const AntdColumn = Table.Column;
+function registerTable(loader) {
+  registerComponentHelper(loader, AntdTable, {
+    name: "plasmic-antd5-table",
+    displayName: "Table",
+    props: {
+      data: {
+        type: "dataSourceOpData",
+        displayName: "Data"
+      },
+      children: {
+        type: "slot",
+        allowedComponents: [
+          "plasmic-antd5-table-column",
+          "plasmic-antd5-table-column-group"
+        ]
+      },
+      bordered: {
+        type: "boolean",
+        defaultValueHint: false,
+        advanced: true
+      },
+      isSelectable: {
+        type: "choice",
+        options: ["single", "multiple"],
+        displayName: "Select rows?"
+      },
+      rowKey: {
+        type: "choice",
+        options: (ps, ctx) => {
+          if (ctx.schema) {
+            return ctx.schema.fields.map((f) => ({
+              value: f.id,
+              label: f.label || f.id
+            }));
+          }
+          return [];
+        },
+        hidden: (ps) => !ps.isSelectable
+      },
+      selectedRowKeys: {
+        type: "choice",
+        multiSelect: (ps) => ps.isSelectable === "multiple",
+        options: (ps, ctx) => {
+          const key = ps.rowKey;
+          if (key && ctx.data) {
+            return ctx.data.map((r) => r[key]);
+          }
+          return [];
+        },
+        hidden: (ps) => !ps.rowKey
+      },
+      onSelectionChange: {
+        type: "eventHandler",
+        argTypes: [
+          { name: "keys", type: "object" },
+          { name: "rows", type: "object" }
+        ],
+        hidden: (ps) => !ps.isSelectable
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/registerTable",
+    importName: "AntdTable",
+    unstable__states: {
+      selectedRows: {
+        type: "writable",
+        valueProp: "selectedRowKeys",
+        onChangeProp: "onSelectionChange"
+      }
+    }
+  });
+  registerComponentHelper(loader, AntdColumn, __spreadValues({
+    name: "plasmic-antd5-table-column",
+    displayName: "Column",
+    parentComponentName: "plasmic-antd5-table",
+    props: {
+      title: {
+        type: "slot",
+        defaultValue: "Column Name"
+      },
+      dataIndex: {
+        type: "string"
+      },
+      render: {
+        type: "slot",
+        renderPropParams: ["cell", "row", "index"]
+      },
+      align: {
+        type: "choice",
+        options: ["left", "right", "center"],
+        defaultValueHint: "left"
+      },
+      fixed: {
+        type: "choice",
+        options: ["left", "right"],
+        advanced: true
+      },
+      colSpan: {
+        type: "number",
+        advanced: true
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/registerTable",
+    importName: "AntdColumn"
+  }, { isRenderless: true }));
+  registerComponentHelper(loader, AntdColumnGroup, __spreadValues({
+    name: "plasmic-antd5-table-column-group",
+    displayName: "Column Group",
+    parentComponentName: "plasmic-antd5-table",
+    props: {
+      title: {
+        type: "slot",
+        defaultValue: "Column Group Name"
+      },
+      children: {
+        type: "slot",
+        allowedComponents: ["plasmic-antd5-table-column"]
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/skinny/registerTable",
+    importName: "AntdColumnGroup"
+  }, { isRenderless: true }));
+}
+
+function registerAll(loader) {
+  registerConfigProvider(loader);
+  registerTokens(loader);
+  registerSelect(loader);
+  registerTable(loader);
+}
+
+export { registerAll };
+//# sourceMappingURL=antd.esm.js.map