@rancher/shell 3.0.10 → 3.0.12-rc.1

package/plugins/dashboard-store/resource-class.js

@@ -1358,7 +1358,35 @@ export default class Resource {
     return window.$globalApp.$router;
   }
 
+  get isProdRegistrationV2TopLevelProductResoure() {
+    // this is the logic to determine if the resource is top level product or not
+    // changes c-cluster-product-resource to product-c-cluster-resource
+    // this is for the new extension product registration model
+    let currPluginName = '';
+    const plugins = this.$extension.getPlugins();
+
+    Object.keys(plugins).forEach((key) => {
+      if (plugins[key].productNames.includes(this.$rootGetters['productId'])) {
+        currPluginName = key;
+      }
+    });
+
+    // the flag "topLevelProduct" only exists in the V2 product registration model
+    return plugins[currPluginName]?.topLevelProduct || false;
+  }
+
   get listLocation() {
+    if (this.isProdRegistrationV2TopLevelProductResoure) {
+      return {
+        name:   `${ this.$rootGetters['productId'] }-c-cluster-resource`,
+        params: {
+          product:  this.$rootGetters['productId'],
+          cluster:  this.$rootGetters['clusterId'],
+          resource: this.type,
+        }
+      };
+    }
+
     return {
       name:   `c-cluster-product-resource`,
       params: {
@@ -1375,6 +1403,20 @@ export default class Resource {
 
     const id = this.id?.replace(/.*\//, '');
 
+    if (this.isProdRegistrationV2TopLevelProductResoure) {
+      return {
+        name:   `${ this.$rootGetters['productId'] }-c-cluster-resource${ schema?.attributes?.namespaced ? '-namespace' : '' }-id`,
+        params: {
+          product:   this.$rootGetters['productId'],
+          cluster:   this.$rootGetters['clusterId'],
+          resource:  this.type,
+          namespace: isNamespaced && this.metadata?.namespace ? this.metadata.namespace : undefined,
+          id,
+        }
+      };
+    }
+
+    // normal cluster scoped resource route as we know
     return {
       name:   `c-cluster-product-resource${ schema?.attributes?.namespaced ? '-namespace' : '' }-id`,
       params: {
@@ -1935,6 +1977,25 @@ export default class Resource {
 
   get _glance() {
     const type = this.parentNameOverride || this.$rootGetters['type-map/labelFor'](this.schema);
+    let toRoute = null;
+
+    if (this.isProdRegistrationV2TopLevelProductResoure) {
+      toRoute = {
+        name:   `${ this.$rootGetters['productId'] }-c-cluster-resource-id`,
+        params: {
+          product:  this.$rootGetters['currentProduct']?.id,
+          cluster:  this.$rootGetters['currentCluster']?.id,
+          resource: this.type,
+        }
+      };
+    } else {
+      toRoute = {
+        name:     `c-cluster-product-resource-id`,
+        product:  this.$rootGetters['currentProduct']?.id,
+        cluster:  this.$rootGetters['currentCluster']?.id,
+        resource: this.type
+      };
+    }
 
     return [
       {
@@ -1958,12 +2019,7 @@ export default class Resource {
         label:         this.t('component.resource.detail.glance.namespace'),
         formatter:     this.$rootGetters['currentProduct']?.id && this.$rootGetters['currentCluster']?.id ? 'Link' : undefined,
         formatterOpts: {
-          to: {
-            name:     `c-cluster-product-resource-id`,
-            product:  this.$rootGetters['currentProduct']?.id,
-            cluster:  this.$rootGetters['currentCluster']?.id,
-            resource: this.type
-          },
+          to:      toRoute,
           row:     {},
           options: { internal: true }
         },

package/plugins/plugin.js

@@ -3,6 +3,8 @@ import { allHashSettled } from '@shell/utils/promise';
 import { shouldNotLoadPlugin, UI_PLUGIN_BASE_URL } from '@shell/config/uiplugins';
 import { getKubeVersionData, getVersionData } from '@shell/config/version';
 import versions from '@shell/utils/versions';
+import { listProducts, loadProduct } from '@shell/utils/dynamic-importer';
+import { Plugin as UIPlugin } from '@shell/core/plugin';
 
 export default async function(context) {
   if (process.env.excludeOperatorPkg === 'true') {
@@ -43,6 +45,20 @@ export default async function(context) {
   try {
     const res = await allHashSettled(fetches);
 
+    // Allow legacy products in shell/config/product to be loaded as if they came from an extension (if migrated to use $init)
+    for (const product of listProducts()) {
+      const impl = await loadProduct(product);
+
+      if (impl?.$init) {
+        const p = new UIPlugin(product);
+
+        impl.$init(p);
+
+        context.$plugin._add(product, p);
+        context.$plugin.applyPlugin(p);
+      }
+    }
+
     // Initialize the built-in extensions now - this is now done here so that built-in extensions get the same, correct environment data (version etc)
     context.$extension.loadBuiltinExtensions();
 

package/plugins/steve/steve-pagination-utils.ts

@@ -23,6 +23,7 @@ import { PaginationSettingsStores } from '@shell/types/resources/settings';
 import paginationUtils from '@shell/utils/pagination-utils';
 import { KubeLabelSelector, KubeLabelSelectorExpression } from '@shell/types/kube/kube-api';
 import { parseField } from '@shell/utils/sort';
+import { POD_LAST_RESTART_FIELD, POD_RESTART_FIELD } from '@shell/types/resources/pod';
 
 /**
  * This is a workaround for a ts build issue found in check-plugins-build.
@@ -240,6 +241,8 @@ class StevePaginationUtils extends NamespaceProjectFilters {
     [POD]: [
       { field: 'spec.containers.image' },
       { field: 'spec.nodeName' },
+      { field: POD_RESTART_FIELD },
+      { field: POD_LAST_RESTART_FIELD },
     ],
     [MANAGEMENT.NODE]: [
       { field: 'status.nodeName' },
@@ -514,6 +517,10 @@ class StevePaginationUtils extends NamespaceProjectFilters {
       }
     }
 
+    if (opt.includeAssociatedData) {
+      params.push('includeAssociatedData=true');
+    }
+
     // Note - There is a `limit` property that is by default 100,000. This can be disabled by using `limit=-1`,
     // but we shouldn't be fetching any pages big enough to exceed the default
 
@@ -766,8 +773,7 @@ export const PAGINATION_SETTINGS_STORE_DEFAULTS: PaginationSettingsStores = {
           { resource: CAPI.RANCHER_CLUSTER, context: ['side-bar'] },
           { resource: MANAGEMENT.CLUSTER, context: ['side-bar'] },
           { resource: CATALOG.APP, context: ['branding'] },
-          SECRET,
-          CAPI.MACHINE_SET
+          SECRET
         ],
         generic: false,
       }

package/plugins/steve/subscribe.js

@@ -131,11 +131,17 @@ const isWaitingForDestroy = (storeName, store) => {
 };
 
 const waitForSettingsSchema = (storeName, store) => {
-  return waitFor(() => isWaitingForDestroy(storeName, store) || !!store.getters['management/byId'](SCHEMA, MANAGEMENT.SETTING));
+  return waitFor(
+    () => isWaitingForDestroy(storeName, store) || !!store.getters['management/byId'](SCHEMA, MANAGEMENT.SETTING),
+    'management settings schema to be available'
+  );
 };
 
 const waitForSettings = (storeName, store) => {
-  return waitFor(() => isWaitingForDestroy(storeName, store) || !!store.getters['management/byId'](MANAGEMENT.SETTING, SETTING.UI_PERFORMANCE));
+  return waitFor(
+    () => isWaitingForDestroy(storeName, store) || !!store.getters['management/byId'](MANAGEMENT.SETTING, SETTING.UI_PERFORMANCE),
+    'UI performance settings to be available'
+  );
 };
 
 const isAdvancedWorker = (ctx) => {
@@ -195,8 +201,20 @@ export async function createWorker(store, ctx) {
     };
   }
 
-  await waitForSettingsSchema(storeName, store);
-  await waitForSettings(storeName, store);
+  try {
+    await waitForSettingsSchema(storeName, store);
+    await waitForSettings(storeName, store);
+  } catch (e) {
+    // Clean up the mock worker and abort so callers are not permanently blocked.
+    if (store.$workers[storeName]?.destroy) {
+      store.$workers[storeName].destroy();
+    } else {
+      delete store.$workers[storeName];
+    }
+
+    return;
+  }
+
   if (store.$workers[storeName].waitingForDestroy()) {
     store.$workers[storeName].destroy();
 
@@ -382,6 +400,13 @@ const sharedActions = {
       if (!this.$workers[getters.storeName]) {
         await createWorker(this, ctx);
       }
+
+      // createWorker cleans up and returns early when schema/settings are unavailable.
+      // Guard against calling postMessage on a non-existent worker.
+      if (!this.$workers[getters.storeName]) {
+        return;
+      }
+
       const options = { parseJSON: false };
       const csrf = rootGetters['cookies/get']({ key: CSRF, options });
 

package/rancher-components/RcButton/RcButton.vue

@@ -253,7 +253,7 @@ button {
   &.btn-small {
     //:not(.btn-sm) is being used to make the style more specific to override global styles. We may want to get rid of those styles at some point.
     &, &:not(.btn-sm) {
-      line-height: 15px;
+      line-height: 140%;
       font-size: 12px;
       min-height: 24px;
 
@@ -265,7 +265,7 @@ button {
   &.btn-medium {
     //:not(.btn-sm) is being used to make the style more specific to override global styles. We may want to get rid of those styles at some point.
     &, &:not(.btn-sm) {
-      line-height: 18px;
+      line-height: 140%;
       font-size: 14px;
       min-height: 32px;
 
@@ -277,7 +277,7 @@ button {
   &.btn-large {
     // This is the default size brought by the global button styling
     &, &:not(.btn-sm) {
-      line-height: 20px;
+      line-height: 140%;
       font-size: 16px;
       min-height: 40px;
 

package/rancher-components/RcButtonSplit/RcButtonSplit.test.ts

@@ -0,0 +1,253 @@
+import { mount } from '@vue/test-utils';
+import { defineComponent } from 'vue';
+import RcButtonSplit from './RcButtonSplit.vue';
+import { ButtonVariant, ButtonSize } from '@components/RcButton/types';
+
+// v-dropdown is provided by floating-vue and must be mocked in unit tests.
+// The default slot is the trigger anchor; the popper slot is the dropdown content.
+const vDropdownMock = defineComponent({
+  template: `
+    <div>
+      <slot />
+      <slot name="popper" />
+    </div>
+  `,
+});
+
+const globalConfig = { global: { components: { 'v-dropdown': vDropdownMock } } };
+
+// RcButton and RcDropdownTrigger both use single-root attribute inheritance, so
+// the class added to the component falls through to the rendered <button> element.
+// Selectors like '.rc-button-split-action' refer directly to the <button> element.
+
+describe('rcButtonSplit.vue', () => {
+  it('renders the main action button', () => {
+    const wrapper = mount(RcButtonSplit, globalConfig);
+
+    expect(wrapper.find('.rc-button-split-action').exists()).toBe(true);
+  });
+
+  it('renders the dropdown trigger', () => {
+    const wrapper = mount(RcButtonSplit, globalConfig);
+
+    expect(wrapper.find('.rc-button-split-trigger').exists()).toBe(true);
+  });
+
+  it('emits click when the main action button is clicked', async() => {
+    const wrapper = mount(RcButtonSplit, globalConfig);
+
+    await wrapper.find('.rc-button-split-action').trigger('click');
+
+    expect(wrapper.emitted('click')).toHaveLength(1);
+    expect(wrapper.emitted('click')![0][0]).toBeInstanceOf(MouseEvent);
+  });
+
+  it('does not emit click when the dropdown trigger is clicked', async() => {
+    const wrapper = mount(RcButtonSplit, globalConfig);
+
+    await wrapper.find('.rc-button-split-trigger').trigger('click');
+
+    expect(wrapper.emitted('click')).toBeUndefined();
+  });
+
+  describe('variant prop', () => {
+    it.each([
+      ['primary', 'variant-primary'],
+      ['secondary', 'variant-secondary'],
+      ['tertiary', 'variant-tertiary'],
+    ] as [ButtonVariant, string][])('applies %s variant class to the action button', (variant, className) => {
+      const wrapper = mount(RcButtonSplit, { ...globalConfig, props: { variant } });
+
+      expect(wrapper.find('.rc-button-split-action').classes()).toContain(className);
+    });
+
+    it.each([
+      ['primary', 'variant-primary'],
+      ['secondary', 'variant-secondary'],
+      ['tertiary', 'variant-tertiary'],
+    ] as [ButtonVariant, string][])('applies %s variant class to the dropdown trigger button', (variant, className) => {
+      const wrapper = mount(RcButtonSplit, { ...globalConfig, props: { variant } });
+
+      expect(wrapper.find('.rc-button-split-trigger').classes()).toContain(className);
+    });
+  });
+
+  describe('size prop', () => {
+    it.each([
+      ['small', 'btn-small'],
+      ['medium', 'btn-medium'],
+      ['large', 'btn-large'],
+    ] as [ButtonSize, string][])('applies %s size class to the action button', (size, className) => {
+      const wrapper = mount(RcButtonSplit, { ...globalConfig, props: { size } });
+
+      expect(wrapper.find('.rc-button-split-action').classes()).toContain(className);
+    });
+
+    it.each([
+      ['small', 'btn-small'],
+      ['medium', 'btn-medium'],
+      ['large', 'btn-large'],
+    ] as [ButtonSize, string][])('applies %s size class to the dropdown trigger button', (size, className) => {
+      const wrapper = mount(RcButtonSplit, { ...globalConfig, props: { size } });
+
+      expect(wrapper.find('.rc-button-split-trigger').classes()).toContain(className);
+    });
+  });
+
+  describe('slots', () => {
+    it('renders default slot content in the main button', () => {
+      const wrapper = mount(RcButtonSplit, {
+        ...globalConfig,
+        slots: { default: 'Save' },
+      });
+
+      expect(wrapper.find('.rc-button-split-action').text()).toContain('Save');
+    });
+
+    it('renders before slot content in the main button', () => {
+      const wrapper = mount(RcButtonSplit, {
+        ...globalConfig,
+        slots: {
+          default: 'Save',
+          before:  '<span class="before-content">Before</span>',
+        },
+      });
+
+      expect(wrapper.find('.rc-button-split-action .before-content').exists()).toBe(true);
+    });
+
+    it('renders after slot content in the main button', () => {
+      const wrapper = mount(RcButtonSplit, {
+        ...globalConfig,
+        slots: {
+          default: 'Save',
+          after:   '<span class="after-content">After</span>',
+        },
+      });
+
+      expect(wrapper.find('.rc-button-split-action .after-content').exists()).toBe(true);
+    });
+
+    it('renders dropdownCollection slot content', () => {
+      const wrapper = mount(RcButtonSplit, {
+        ...globalConfig,
+        slots: { dropdownCollection: '<div class="dropdown-item-test">Item 1</div>' },
+      });
+
+      expect(wrapper.find('.dropdown-item-test').exists()).toBe(true);
+      expect(wrapper.find('.dropdown-item-test').text()).toStrictEqual('Item 1');
+    });
+  });
+
+  it('dropdown trigger has aria-haspopup="menu" attribute', () => {
+    const wrapper = mount(RcButtonSplit, globalConfig);
+
+    expect(wrapper.find('.rc-button-split-trigger').attributes('aria-haspopup')).toBe('menu');
+  });
+
+  it('emits update:open when dropdown open state changes', async() => {
+    const wrapper = mount(RcButtonSplit, globalConfig);
+
+    await wrapper.findComponent({ name: 'RcDropdown' }).vm.$emit('update:open', true);
+
+    expect(wrapper.emitted('update:open')).toHaveLength(1);
+    expect(wrapper.emitted('update:open')![0]).toStrictEqual([true]);
+  });
+
+  it('applies default variant "primary" when no variant is provided', () => {
+    const wrapper = mount(RcButtonSplit, globalConfig);
+
+    expect(wrapper.find('.rc-button-split-action').classes()).toContain('variant-primary');
+  });
+
+  it('applies default size "medium" when no size is provided', () => {
+    const wrapper = mount(RcButtonSplit, globalConfig);
+
+    expect(wrapper.find('.rc-button-split-action').classes()).toContain('btn-medium');
+  });
+
+  describe('aria label props', () => {
+    it('ariaLabel is applied to the action button', () => {
+      const wrapper = mount(RcButtonSplit, { ...globalConfig, props: { ariaLabel: 'Save document' } });
+
+      expect(wrapper.find('.rc-button-split-action').attributes('aria-label')).toBe('Save document');
+    });
+
+    it('ariaLabel is absent from the trigger button', () => {
+      const wrapper = mount(RcButtonSplit, { ...globalConfig, props: { ariaLabel: 'Save document' } });
+
+      expect(wrapper.find('.rc-button-split-trigger').attributes('aria-label')).toBeUndefined();
+    });
+
+    it('ariaLabelTrigger is applied to the trigger button', () => {
+      const wrapper = mount(RcButtonSplit, { ...globalConfig, props: { ariaLabelTrigger: 'More save options' } });
+
+      expect(wrapper.find('.rc-button-split-trigger').attributes('aria-label')).toBe('More save options');
+    });
+
+    it('ariaLabelTrigger is absent from the action button', () => {
+      const wrapper = mount(RcButtonSplit, { ...globalConfig, props: { ariaLabelTrigger: 'More save options' } });
+
+      expect(wrapper.find('.rc-button-split-action').attributes('aria-label')).toBeUndefined();
+    });
+
+    it('ariaLabelDropdown is forwarded to RcDropdown', () => {
+      const wrapper = mount(RcButtonSplit, { ...globalConfig, props: { ariaLabelDropdown: 'Save actions' } });
+
+      expect(wrapper.findComponent({ name: 'RcDropdown' }).props('ariaLabel')).toBe('Save actions');
+    });
+  });
+
+  describe('items prop', () => {
+    const items = [
+      { id: 'draft', label: 'Save as Draft' },
+      { id: 'template', label: 'Save as Template' },
+      { id: 'discard', label: 'Discard Changes' },
+    ];
+
+    it('renders an RcDropdownItem for each entry in items', () => {
+      const wrapper = mount(RcButtonSplit, { ...globalConfig, props: { items } });
+
+      const dropdownItems = wrapper.findAllComponents({ name: 'RcDropdownItem' });
+
+      expect(dropdownItems).toHaveLength(3);
+    });
+
+    it('renders each item\'s label text', () => {
+      const wrapper = mount(RcButtonSplit, { ...globalConfig, props: { items } });
+
+      const dropdownItems = wrapper.findAllComponents({ name: 'RcDropdownItem' });
+
+      expect(dropdownItems[0].text()).toContain('Save as Draft');
+      expect(dropdownItems[1].text()).toContain('Save as Template');
+      expect(dropdownItems[2].text()).toContain('Discard Changes');
+    });
+
+    it('emits select with the item id when a prop item is clicked', async() => {
+      const wrapper = mount(RcButtonSplit, { ...globalConfig, props: { items } });
+
+      await wrapper.findAllComponents({ name: 'RcDropdownItem' })[0].trigger('click');
+
+      expect(wrapper.emitted('select')).toHaveLength(1);
+      expect(wrapper.emitted('select')![0]).toStrictEqual(['draft']);
+    });
+
+    it('does not emit select when no items prop is provided', async() => {
+      const wrapper = mount(RcButtonSplit, globalConfig);
+
+      expect(wrapper.emitted('select')).toBeUndefined();
+    });
+
+    it('renders both prop items and dropdownCollection slot content when both are supplied', () => {
+      const wrapper = mount(RcButtonSplit, {
+        ...globalConfig,
+        props: { items: [{ id: 'draft', label: 'Save as Draft' }] },
+        slots: { dropdownCollection: '<div class="slot-item">Slot Item</div>' },
+      });
+
+      expect(wrapper.findAllComponents({ name: 'RcDropdownItem' })).toHaveLength(1);
+      expect(wrapper.find('.slot-item').exists()).toBe(true);
+      expect(wrapper.find('.slot-item').text()).toStrictEqual('Slot Item');
+    });
+  });
+});

package/rancher-components/RcButtonSplit/RcButtonSplit.vue

@@ -0,0 +1,158 @@
+<script setup lang="ts">
+/**
+ * A split button that combines a primary action button with a dropdown trigger
+ * for secondary actions.
+ *
+ * Example:
+ *
+ *  <rc-button-split variant="primary" @click="doAction" @update:open="onOpen">
+ *    Save
+ *    <template #dropdownCollection>
+ *      <rc-dropdown-item @click="doOtherAction">Save as Draft</rc-dropdown-item>
+ *    </template>
+ *  </rc-button-split>
+ */
+import { RcButton } from '@components/RcButton';
+import { RcDropdown, RcDropdownItem, RcDropdownTrigger } from '@components/RcDropdown';
+import RcIcon from '@components/RcIcon/RcIcon.vue';
+import { ButtonVariant, ButtonSize, IconProps } from '@components/RcButton/types';
+import type { Placement } from 'floating-vue';
+
+type RcButtonSplitVariant = Exclude<ButtonVariant, 'link' | 'ghost' | 'multiAction'>;
+
+type RcButtonSplitItem = {
+  id: string;
+  label: string;
+};
+
+type RcButtonSplitProps = {
+  disabled?: boolean;
+  variant?: RcButtonSplitVariant;
+  size?: ButtonSize;
+  ariaLabel?: string;
+  ariaLabelTrigger?: string;
+  ariaLabelDropdown?: string;
+  placement?: Placement;
+  distance?: number;
+  items?: RcButtonSplitItem[];
+} & IconProps;
+
+withDefaults(
+  defineProps<RcButtonSplitProps>(),
+  {
+    disabled:          false,
+    variant:           'primary',
+    size:              'medium',
+    ariaLabel:         undefined,
+    ariaLabelTrigger:  undefined,
+    ariaLabelDropdown: undefined,
+    placement:         'bottom-end',
+    distance:          undefined,
+    items:             undefined,
+  });
+
+const emit = defineEmits<{
+  click: [event: MouseEvent];
+  'update:open': [open: boolean];
+  select: [id: string];
+}>();
+</script>
+
+<template>
+  <RcDropdown
+    :aria-label="ariaLabelDropdown"
+    :placement="placement"
+    :distance="distance"
+    @update:open="emit('update:open', $event)"
+  >
+    <div class="rc-button-split">
+      <RcButton
+        class="rc-button-split-action"
+        :aria-label="ariaLabel"
+        :disabled="disabled"
+        :variant="variant"
+        :size="size"
+        :left-icon="leftIcon"
+        :right-icon="rightIcon"
+        @click="emit('click', $event)"
+      >
+        <template
+          v-if="$slots.before"
+          #before
+        >
+          <slot name="before" />
+        </template>
+        <slot />
+        <template
+          v-if="$slots.after"
+          #after
+        >
+          <slot name="after" />
+        </template>
+      </RcButton>
+
+      <RcDropdownTrigger
+        class="rc-button-split-trigger"
+        :aria-label="ariaLabelTrigger"
+        :disabled="disabled"
+        :variant="variant"
+        :size="size"
+      >
+        <RcIcon
+          type="chevron-down"
+          size="inherit"
+        />
+      </RcDropdownTrigger>
+    </div>
+
+    <template #dropdownCollection>
+      <RcDropdownItem
+        v-for="item in items"
+        :key="item.id"
+        @click="emit('select', item.id)"
+      >
+        {{ item.label }}
+      </RcDropdownItem>
+      <slot name="dropdownCollection" />
+    </template>
+  </RcDropdown>
+</template>
+
+<style lang="scss" scoped>
+.rc-button-split {
+  display: inline-flex;
+
+  // Round only the outer left edge of the main button
+  :deep(.rc-button-split-action) {
+    border-top-right-radius: 0;
+    border-bottom-right-radius: 0;
+  }
+
+  // Round only the outer right edge of the trigger button; narrow padding
+  :deep(button.rc-button-split-trigger) {
+    border-top-left-radius: 0;
+    border-bottom-left-radius: 0;
+    padding-left: 8px;
+    padding-right: 8px;
+    min-width: unset;
+  }
+
+  :deep(button.btn-small.rc-button-split-trigger) {
+    padding-left: 4px;
+    padding-right: 4px;
+  }
+
+  // Primary: semi-transparent right border as separator
+  :deep(.rc-button-split-trigger.variant-primary),
+  :deep(.rc-button-split-trigger.variant-secondary),
+  :deep(.rc-button-split-trigger.variant-tertiary) {
+    border-left: 1px solid rgba(255, 255, 255, 0.3);
+  }
+
+  // Link/Ghost: subtle separator
+  :deep(.rc-button-split-action.variant-link),
+  :deep(.rc-button-split-action.variant-ghost) {
+    border-right: 1px solid var(--border);
+  }
+}
+</style>

package/rancher-components/RcButtonSplit/index.ts

@@ -0,0 +1 @@
+export { default as RcButtonSplit } from './RcButtonSplit.vue';