gi-component 0.0.1

package/packages/components/grid/src/utils/responsive-observe.ts

@@ -0,0 +1,135 @@
+// https://github.com/ant-design/ant-design/blob/master/components/_util/responsiveObserve.ts
+
+export type Breakpoint = 'xxl' | 'xl' | 'lg' | 'md' | 'sm' | 'xs';
+export type BreakpointMap = Partial<Record<Breakpoint, string>>;
+export type ScreenMap = Partial<Record<Breakpoint, boolean>>;
+
+export const responsiveArray: Breakpoint[] = [
+  'xxl',
+  'xl',
+  'lg',
+  'md',
+  'sm',
+  'xs'
+];
+
+export const responsiveMap: BreakpointMap = {
+  xs: '(max-width: 575px)',
+  sm: '(min-width: 576px)',
+  md: '(min-width: 768px)',
+  lg: '(min-width: 992px)',
+  xl: '(min-width: 1200px)',
+  xxl: '(min-width: 1600px)'
+};
+
+type SubscribeFunc = (
+  screens: ScreenMap,
+  breakpointChecked: Breakpoint
+) => void;
+
+interface MediaQueryResult {
+  matches: boolean;
+}
+
+type MediaQueryListener = (matches: MediaQueryResult) => void;
+
+let subscribers: Array<{
+  token: string;
+  func: SubscribeFunc;
+}> = [];
+let subUid = -1;
+let screens = {};
+
+const responsiveObserve: {
+  matchHandlers: {
+    [key: string]: {
+      mql: MediaQueryList;
+      listener: MediaQueryListener;
+    };
+  };
+  dispatch: (pointMap: ScreenMap, breakpointChecked: Breakpoint) => boolean;
+  subscribe: (func: SubscribeFunc) => string;
+  unsubscribe: (token: string) => void;
+  unregister: () => void;
+  register: () => void;
+} = {
+  matchHandlers: {},
+  dispatch(pointMap: ScreenMap, breakpointChecked: Breakpoint) {
+    screens = pointMap;
+    if (subscribers.length < 1) {
+      return false;
+    }
+
+    subscribers.forEach(item => {
+      item.func(screens, breakpointChecked);
+    });
+
+    return true;
+  },
+  subscribe(func: SubscribeFunc) {
+    if (subscribers.length === 0) {
+      this.register();
+    }
+    const token = (++subUid).toString();
+    subscribers.push({
+      token,
+      func
+    });
+    func(screens, null as unknown as Breakpoint);
+    return token;
+  },
+  unsubscribe(token: string) {
+    subscribers = subscribers.filter(item => item.token !== token);
+    if (subscribers.length === 0) {
+      this.unregister();
+    }
+  },
+  unregister() {
+    (Object.keys(responsiveMap) as Breakpoint[]).forEach(
+      (screen: Breakpoint) => {
+        const matchMediaQuery = responsiveMap[screen];
+        if (!matchMediaQuery) return;
+        const handler = this.matchHandlers[matchMediaQuery];
+        if (handler && handler.mql && handler.listener) {
+          if (handler.mql.removeEventListener) {
+            handler.mql.removeEventListener('change', handler.listener);
+          } else {
+            handler.mql.removeListener(handler.listener);
+          }
+        }
+      }
+    );
+  },
+  register() {
+    (Object.keys(responsiveMap) as Breakpoint[]).forEach(
+      (screen: Breakpoint) => {
+        const matchMediaQuery = responsiveMap[screen];
+        if (!matchMediaQuery) return;
+        const listener = ({ matches }: MediaQueryResult) => {
+          this.dispatch(
+            {
+              ...screens,
+              [screen]: matches
+            },
+            screen
+          );
+        };
+        const mql = window.matchMedia(matchMediaQuery);
+        if (mql.addEventListener) {
+          mql.addEventListener('change', listener);
+        } else {
+          mql.addListener(listener);
+        }
+
+        this.matchHandlers[matchMediaQuery] = {
+          mql,
+          listener
+        };
+
+        listener(mql);
+      }
+    );
+  }
+};
+
+export default responsiveObserve;

package/packages/components/input-group/index.ts

@@ -0,0 +1,5 @@
+import InputGroup from './src/input-group.vue';
+
+export type InputGroupInstance = InstanceType<typeof InputGroup>;
+export * from './src/type';
+export default InputGroup;

package/packages/components/input-group/src/input-group.vue

@@ -0,0 +1,92 @@
+<template>
+  <div :class="b('input-group')">
+    <slot></slot>
+  </div>
+</template>
+
+<script lang="ts" setup>
+import { useBemClass } from '../../../hooks';
+
+const { b } = useBemClass();
+</script>
+
+<style lang="scss" scoped>
+@use '../../../styles/var.scss' as a;
+
+:deep(.el-button + .el-button) {
+  margin-left: 0;
+}
+
+:deep(.el-select__wrapper) {
+  box-shadow: none;
+  border: 1px solid var(--el-border-color);
+
+  &.is-focused {
+    box-shadow: none;
+    border-color: var(--el-color-primary);
+  }
+
+  &.is-hovering:not(.is-focused) {
+    box-shadow: none;
+    border-color: var(--el-border-color-hover);
+  }
+}
+
+.#{a.$prefix}-input-group {
+  display: flex;
+
+  > :deep(*:not(:last-child)) {
+    margin-right: -1px;
+  }
+
+  > :deep(*:first-child:last-child) {
+    border-radius: var(--el-border-radius-base);
+
+    .el-input__wrapper,
+    .el-select__wrapper {
+      border-radius: var(--el-border-radius-base);
+    }
+  }
+
+  > :deep(*:not(:first-child):not(:last-child)) {
+    border-radius: 0;
+
+    .el-input__wrapper {
+      border-radius: 0;
+    }
+  }
+
+  > :deep(*:first-child) {
+    border-top-right-radius: 0;
+    border-bottom-right-radius: 0;
+
+    .el-input__wrapper,
+    .el-select__wrapper {
+      border-top-right-radius: 0;
+      border-bottom-right-radius: 0;
+    }
+  }
+
+  > :deep(*:last-child) {
+    border-top-left-radius: 0;
+    border-bottom-left-radius: 0;
+
+    .el-input__wrapper,
+    .el-select__wrapper {
+      border-top-left-radius: 0;
+      border-bottom-left-radius: 0;
+    }
+  }
+
+  > :deep(*:hover, *:focus, *:active) {
+    z-index: 1;
+  }
+
+  > :deep(*) {
+    .el-input__wrapper.is-focus,
+    .el-select__wrapper.is-focused {
+      z-index: 2;
+    }
+  }
+}
+</style>

package/packages/components/input-group/src/type.ts

@@ -0,0 +1 @@
+export interface InputGroupProps {}

package/packages/components/input-search/index.ts

@@ -0,0 +1,5 @@
+import InputSearch from './src/input-search.vue';
+
+export type InputSearchInstance = InstanceType<typeof InputSearch>;
+export * from './src/type';
+export default InputSearch;

package/packages/components/input-search/src/input-search.vue

@@ -0,0 +1,62 @@
+<template>
+  <InputGroup :class="b('input-search')">
+    <el-input
+      v-model="model"
+      :disabled="props.disabled"
+      :readonly="!props.disabled"
+      :placeholder="props.placeholder"
+    >
+    </el-input>
+    <el-button
+      v-if="showButton"
+      :icon="Search"
+      :disabled="props.disabled"
+      @click="emit('search')"
+    ></el-button>
+    <el-button
+      v-if="showButton"
+      :icon="Close"
+      :disabled="props.disabled"
+      @click="emit('clear')"
+    ></el-button>
+  </InputGroup>
+</template>
+
+<script setup lang="ts">
+import type { InputSearchProps } from './type';
+import { Close, Search } from '@element-plus/icons-vue';
+import { computed } from 'vue';
+import { useBemClass } from '../../../hooks';
+import InputGroup from '../../input-group/src/input-group.vue';
+
+const model = defineModel({ type: String });
+
+const props = withDefaults(defineProps<InputSearchProps>(), {
+  disabled: false,
+  readonly: false,
+  placeholder: '请选择',
+  disabledHideButton: false
+});
+
+const emit = defineEmits<{
+  (e: 'search'): void;
+  (e: 'clear'): void;
+}>();
+
+const { b } = useBemClass();
+
+const showButton = computed(() => {
+  if (props.readonly) return false;
+  if (props.disabled) {
+    return !props.disabledHideButton;
+  }
+  return true;
+});
+</script>
+
+<style lang="scss" scoped>
+:deep(.el-button) {
+  padding-right: 12px;
+  padding-left: 12px;
+}
+</style>

package/packages/components/input-search/src/type.ts

@@ -0,0 +1,6 @@
+export interface InputSearchProps {
+  disabled?: boolean;
+  readonly?: boolean;
+  placeholder?: string;
+  disabledHideButton?: boolean; // 禁用的时候隐藏按钮
+}

package/packages/components/page-layout/index.ts

@@ -0,0 +1,5 @@
+import PageLayout from './src/page-layout.vue';
+
+export type PageLayoutInstance = InstanceType<typeof PageLayout>;
+export * from './src/type';
+export default PageLayout;

package/packages/components/page-layout/src/page-layout.vue

@@ -0,0 +1,180 @@
+<template>
+  <el-splitter :class="getClass">
+    <el-splitter-panel v-if="slots.left" v-model:size="size">
+      <div :class="b('page-layout__left')" :style="props.leftStyle">
+        <slot name="left"></slot>
+      </div>
+    </el-splitter-panel>
+    <div v-if="slots.left && props.collapse" :class="b('page-layout__split')">
+      <SplitButton
+        :collapsed="Number(size) === 0"
+        @click="handleClick"
+      ></SplitButton>
+    </div>
+    <el-splitter-panel>
+      <div :class="b('page-layout__right')">
+        <div
+          v-if="slots.header"
+          :class="b('page-layout__header')"
+          :style="props.headerStyle"
+        >
+          <slot name="header"></slot>
+        </div>
+        <div
+          v-if="slots.tool"
+          :class="b('page-layout__tool')"
+          :style="props.toolStyle"
+        >
+          <slot name="tool"></slot>
+        </div>
+        <div :class="b('page-layout__body')" :style="props.bodyStyle">
+          <slot></slot>
+        </div>
+      </div>
+    </el-splitter-panel>
+  </el-splitter>
+</template>
+
+<script lang="ts" setup>
+import type { PageLayoutProps } from './type';
+import { computed, ref, useSlots } from 'vue';
+import { useBemClass } from '../../../hooks';
+import SplitButton from './split-button.vue';
+
+const props = withDefaults(defineProps<PageLayoutProps>(), {
+  size: 270,
+  bordered: false,
+  collapse: true,
+  leftStyle: () => ({}),
+  headerStyle: () => ({}),
+  toolStyle: () => ({}),
+  bodyStyle: () => ({})
+});
+
+defineSlots<{
+  header: () => void;
+  left: () => void;
+  tool: () => void;
+  default: () => void;
+}>();
+
+const slots = useSlots();
+const { b } = useBemClass();
+const size = ref(props.size);
+const collapsing = ref(false);
+
+const getClass = computed(() => {
+  const arr: string[] = [b('page-layout')];
+  if (props.bordered) {
+    arr.push(b('page-layout--bordered'));
+  }
+  if (slots.header) {
+    arr.push(b('page-layout--has-header'));
+  }
+  if (slots.tool) {
+    arr.push(b('page-layout--has-tool'));
+  }
+  if (collapsing.value) {
+    arr.push(b('page-layout--collapsing'));
+  }
+  return arr.join(' ');
+});
+
+function handleClick() {
+  collapsing.value = true;
+  setTimeout(() => {
+    collapsing.value = false;
+  }, 300);
+  size.value = Number(size.value) > 30 ? 0 : props.size;
+}
+</script>
+
+<style lang="scss" scoped>
+@use '../../../styles/var.scss' as a;
+
+:deep(.el-splitter-bar__dragger-horizontal) {
+  &::before,
+  &::after {
+    width: 1px;
+  }
+}
+
+.#{a.$prefix}-page-layout {
+  flex: 1;
+  width: 100%;
+  height: 100%;
+  display: flex;
+  overflow: hidden;
+  background-color: var(--el-bg-color);
+
+  &--bordered {
+    border: 1px solid var(--el-border-color);
+  }
+
+  &__left {
+    width: 100%;
+    height: 100%;
+  }
+
+  &__right {
+    flex: 1;
+    height: 100%;
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+    position: relative;
+  }
+}
+
+.#{a.$prefix}-page-layout__header {
+  padding: var(--padding-x);
+  padding-bottom: 0;
+  border-bottom: 1px solid var(--el-border-color);
+  box-sizing: border-box;
+}
+
+.#{a.$prefix}-page-layout__tool {
+  width: 100%;
+  padding: var(--padding-x);
+  padding-bottom: 0;
+  display: flex;
+  justify-content: end;
+  align-items: center;
+  box-sizing: border-box;
+}
+
+.#{a.$prefix}-page-layout__body {
+  flex: 1;
+  padding: var(--padding-x);
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  box-sizing: border-box;
+}
+
+.#{a.$prefix}-page-layout__split {
+  width: 0;
+  height: auto;
+  position: relative;
+}
+
+.#{a.$prefix}-page-layout--has-header {
+  .#{a.$prefix}-page-layout__tool {
+    padding-top: var(--padding-y);
+  }
+}
+
+.#{a.$prefix}-page-layout--has-header,
+.#{a.$prefix}-page-layout--has-tool {
+  .#{a.$prefix}-page-layout__body {
+    padding-top: var(--padding-y);
+  }
+}
+
+.#{a.$prefix}-page-layout--collapsing {
+  :deep(.el-splitter-panel) {
+    transition: flex-basis 0.3s;
+  }
+}
+</style>

package/packages/components/page-layout/src/split-button.vue

@@ -0,0 +1,106 @@
+<template>
+  <div :class="getClass" @click="handleClick">
+    <el-icon :size="props.iconSize">
+      <ArrowRightBold v-if="collapsed" :size="iconSize" />
+      <ArrowLeftBold v-else :size="iconSize" />
+    </el-icon>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ArrowLeftBold, ArrowRightBold } from '@element-plus/icons-vue';
+import { computed } from 'vue';
+import { useBemClass } from '../../../hooks';
+
+/** 按钮类型 */
+type ButtonType = 'default' | 'circle';
+
+/** 组件属性定义 */
+interface Props {
+  /** 是否折叠状态 */
+  collapsed?: boolean;
+  /** 按钮类型 */
+  type?: ButtonType;
+  /** 图标大小 */
+  iconSize?: number;
+  /** 是否禁用 */
+  disabled?: boolean;
+}
+
+/** 组件事件定义 */
+interface Emits {
+  (e: 'click'): void;
+  (e: 'update:collapsed', value: boolean): void;
+}
+
+const props = withDefaults(defineProps<Props>(), {
+  collapsed: false,
+  type: 'circle',
+  iconSize: 10,
+  disabled: false
+});
+
+const emit = defineEmits<Emits>();
+const { b } = useBemClass();
+
+/** 计算按钮类名 */
+const getClass = computed(() => {
+  const arr: string[] = [b('split-button'), b(`split-button--${props.type}`)];
+  if (props.collapsed) {
+    arr.push(b('split-button--collapsed'));
+  }
+  if (props.disabled) {
+    arr.push(b('split-button--disabled'));
+  }
+  return arr.join(' ');
+});
+
+/** 处理点击事件 */
+const handleClick = () => {
+  if (props.disabled) return;
+  emit('click');
+  emit('update:collapsed', !props.collapsed);
+};
+</script>
+
+<style lang="scss" scoped>
+@use '../../../styles/var.scss' as a;
+
+.#{a.$prefix}-split-button {
+  position: absolute;
+  top: 50%;
+  transform: translateY(-50%);
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  z-index: 9;
+  border: 1px solid var(--el-border-color);
+  background-color: var(--el-bg-color);
+  box-sizing: border-box;
+  cursor: pointer;
+  transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+  will-change: transform, background-color, border-color;
+
+  &--disabled {
+    cursor: not-allowed;
+    opacity: 0.6;
+    pointer-events: none;
+  }
+
+  &--default {
+    width: 18px;
+    height: 40px;
+    left: 0;
+    box-shadow: 2px 0 6px rgba(0, 0, 0, 0.1);
+  }
+
+  &--circle {
+    width: 24px;
+    height: 24px;
+    border-radius: 50%;
+    left: -12px;
+    overflow: hidden;
+    box-shadow: 0 4px 10px rgba(0, 0, 0, 0.1);
+  }
+}
+</style>

package/packages/components/page-layout/src/type.ts

@@ -0,0 +1,12 @@
+import type { SplitterPanelProps } from 'element-plus';
+import type { CSSProperties } from 'vue';
+
+export interface PageLayoutProps {
+  size?: SplitterPanelProps['size'];
+  bordered?: boolean;
+  collapse?: boolean;
+  leftStyle?: CSSProperties;
+  headerStyle?: CSSProperties;
+  toolStyle?: CSSProperties;
+  bodyStyle?: CSSProperties;
+}

package/packages/components/table/index.ts

@@ -0,0 +1,5 @@
+import Table from './src/table.vue';
+
+export type TableInstance = InstanceType<typeof Table>;
+export * from './src/type';
+export default Table;

package/packages/components/table/src/TableColumn.vue

@@ -0,0 +1,49 @@
+<template>
+  <el-table-column v-bind="columnProps">
+    <!-- 处理render函数 -->
+    <template v-if="column.render" v-slot="scope">
+      <component :is="column.render(scope)" />
+    </template>
+
+    <!-- 处理插槽内容 -->
+    <template v-else-if="column.slotName" #default="scope">
+      <slot :name="column.slotName" v-bind="scope" />
+    </template>
+
+    <!-- 递归渲染子列 -->
+    <template v-if="column.children && column.children.length > 0">
+      <TableColumn
+        v-for="child in column.children"
+        :key="child.prop || child.label"
+        :column="child"
+      >
+        <!-- 将所有插槽传递给子组件 -->
+        <template
+          v-for="(_, slotName) in $slots"
+          :key="slotName"
+          #[slotName]="scope"
+        >
+          <slot :name="slotName" v-bind="scope" />
+        </template>
+      </TableColumn>
+    </template>
+  </el-table-column>
+</template>
+
+<script lang="ts" setup>
+import type { TableColumnItem } from './type';
+import { computed } from 'vue';
+import TableColumn from './TableColumn.vue';
+
+const props = defineProps<{
+  column: TableColumnItem;
+}>();
+
+// 计算el-table-column需要的属性
+const columnProps = computed(() => {
+  const { slotName, render, children, ...restProps } = props.column;
+  return restProps;
+});
+</script>
+
+<style scoped></style>