orion-design 0.1.3 → 0.1.5

package/dist/components/_util/vue/index.d.ts

@@ -0,0 +1,9 @@
+export * from './global-node';
+export * from './icon';
+export * from './install';
+export * from './props';
+export * from './refs';
+export * from './size';
+export * from './typescript';
+export * from './validator';
+export * from './vnode';

package/dist/components/_util/vue/index.js

@@ -0,0 +1,44 @@
+import { changeGlobalNodesTarget as t, createGlobalNode as r, removeGlobalNode as p } from "./global-node.js";
+import { CloseComponents as l, TypeComponents as n, TypeComponentsMap as a, ValidateComponentsMap as s, iconPropType as m } from "./icon.js";
+import { withInstall as f, withInstallDirective as C, withInstallFunction as c, withNoopInstall as x } from "./install.js";
+import { buildProp as h, buildProps as T, definePropType as g, epPropKey as y, isEpProp as N } from "./props/runtime.js";
+import { composeRefs as I } from "./refs.js";
+import { getComponentSize as u } from "./size.js";
+import { isValidComponentSize as F, isValidDatePickType as z } from "./validator.js";
+import { PatchFlags as k, ensureOnlyChild as v, flattedChildren as D, getFirstValidNode as E, getNormalizedProps as M, isComment as S, isFragment as B, isTemplate as K, isText as O, isValidElementNode as R, renderBlock as j, renderIf as q } from "./vnode.js";
+export {
+  l as CloseComponents,
+  k as PatchFlags,
+  n as TypeComponents,
+  a as TypeComponentsMap,
+  s as ValidateComponentsMap,
+  h as buildProp,
+  T as buildProps,
+  t as changeGlobalNodesTarget,
+  I as composeRefs,
+  r as createGlobalNode,
+  g as definePropType,
+  v as ensureOnlyChild,
+  y as epPropKey,
+  D as flattedChildren,
+  u as getComponentSize,
+  E as getFirstValidNode,
+  M as getNormalizedProps,
+  m as iconPropType,
+  S as isComment,
+  N as isEpProp,
+  B as isFragment,
+  K as isTemplate,
+  O as isText,
+  F as isValidComponentSize,
+  z as isValidDatePickType,
+  R as isValidElementNode,
+  p as removeGlobalNode,
+  j as renderBlock,
+  q as renderIf,
+  f as withInstall,
+  C as withInstallDirective,
+  c as withInstallFunction,
+  x as withNoopInstall
+};
+//# sourceMappingURL=index.js.map

package/dist/components/_util/vue/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;"}

package/dist/components/_util/vue/install.d.ts

@@ -0,0 +1,6 @@
+import { Directive } from 'vue';
+import { SFCInstallWithContext, SFCWithInstall } from './typescript';
+export declare const withInstall: <T, E extends Record<string, any>>(main: T, extra?: E) => SFCWithInstall<T> & E;
+export declare const withInstallFunction: <T>(fn: T, name: string) => SFCInstallWithContext<T>;
+export declare const withInstallDirective: <T extends Directive>(directive: T, name: string) => SFCWithInstall<T>;
+export declare const withNoopInstall: <T>(component: T) => SFCWithInstall<T>;

package/dist/components/_util/vue/install.js

@@ -0,0 +1,21 @@
+import { N as s } from "../../../functions-DzLqXvGt.js";
+const e = (t, l) => {
+  if (t.install = (o) => {
+    for (const n of [t, ...Object.values(l ?? {})])
+      o.component(n.name, n);
+  }, l)
+    for (const [o, n] of Object.entries(l))
+      t[o] = n;
+  return t;
+}, r = (t, l) => (t.install = (o) => {
+  t._context = o._context, o.config.globalProperties[l] = t;
+}, t), i = (t, l) => (t.install = (o) => {
+  o.directive(l, t);
+}, t), a = (t) => (t.install = s, t);
+export {
+  e as withInstall,
+  i as withInstallDirective,
+  r as withInstallFunction,
+  a as withNoopInstall
+};
+//# sourceMappingURL=install.js.map

package/dist/components/_util/vue/install.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"install.js","sources":["../../../../src/components/_util/vue/install.ts"],"sourcesContent":["import { NOOP } from '../functions'\r\n\r\nimport type { App, Directive } from 'vue'\r\nimport type { SFCInstallWithContext, SFCWithInstall } from './typescript'\r\n\r\nexport const withInstall = <T, E extends Record<string, any>>(\r\n  main: T,\r\n  extra?: E\r\n) => {\r\n  ;(main as SFCWithInstall<T>).install = (app): void => {\r\n    for (const comp of [main, ...Object.values(extra ?? {})]) {\r\n      app.component(comp.name, comp)\r\n    }\r\n  }\r\n\r\n  if (extra) {\r\n    for (const [key, comp] of Object.entries(extra)) {\r\n      ;(main as any)[key] = comp\r\n    }\r\n  }\r\n  return main as SFCWithInstall<T> & E\r\n}\r\n\r\nexport const withInstallFunction = <T>(fn: T, name: string) => {\r\n  ;(fn as SFCWithInstall<T>).install = (app: App) => {\r\n    ;(fn as SFCInstallWithContext<T>)._context = app._context\r\n    app.config.globalProperties[name] = fn\r\n  }\r\n\r\n  return fn as SFCInstallWithContext<T>\r\n}\r\n\r\nexport const withInstallDirective = <T extends Directive>(\r\n  directive: T,\r\n  name: string\r\n) => {\r\n  ;(directive as SFCWithInstall<T>).install = (app: App): void => {\r\n    app.directive(name, directive)\r\n  }\r\n\r\n  return directive as SFCWithInstall<T>\r\n}\r\n\r\nexport const withNoopInstall = <T>(component: T) => {\r\n  ;(component as SFCWithInstall<T>).install = NOOP\r\n\r\n  return component as SFCWithInstall<T>\r\n}\r\n"],"names":["withInstall","main","extra","app","comp","key","withInstallFunction","fn","name","withInstallDirective","directive","withNoopInstall","component","NOOP"],"mappings":";AAKa,MAAAA,IAAc,CACzBC,GACAC,MACG;AAOH,MANED,EAA2B,UAAU,CAACE,MAAc;AACzC,eAAAC,KAAQ,CAACH,GAAM,GAAG,OAAO,OAAOC,KAAS,CAAE,CAAA,CAAC;AACjD,MAAAC,EAAA,UAAUC,EAAK,MAAMA,CAAI;AAAA,EAC/B,GAGEF;AACF,eAAW,CAACG,GAAKD,CAAI,KAAK,OAAO,QAAQF,CAAK;AAC1C,MAAAD,EAAaI,CAAG,IAAID;AAGnB,SAAAH;AACT,GAEaK,IAAsB,CAAIC,GAAOC,OAC1CD,EAAyB,UAAU,CAACJ,MAAa;AAC/C,EAAAI,EAAgC,WAAWJ,EAAI,UAC7CA,EAAA,OAAO,iBAAiBK,CAAI,IAAID;AAAA,GAG/BA,IAGIE,IAAuB,CAClCC,GACAF,OAEEE,EAAgC,UAAU,CAACP,MAAmB;AAC1D,EAAAA,EAAA,UAAUK,GAAME,CAAS;AAAA,GAGxBA,IAGIC,IAAkB,CAAIC,OAC/BA,EAAgC,UAAUC,GAErCD;"}

package/dist/components/_util/vue/props/index.d.ts

@@ -0,0 +1,3 @@
+export * from './util';
+export * from './types';
+export * from './runtime';

package/dist/components/_util/vue/props/index.js

@@ -0,0 +1,9 @@
+import { buildProp as r, buildProps as e, definePropType as P, epPropKey as i, isEpProp as d } from "./runtime.js";
+export {
+  r as buildProp,
+  e as buildProps,
+  P as definePropType,
+  i as epPropKey,
+  d as isEpProp
+};
+//# sourceMappingURL=index.js.map

package/dist/components/_util/vue/props/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/components/_util/vue/props/runtime.d.ts

@@ -0,0 +1,29 @@
+import { PropType } from 'vue';
+import { EpProp, EpPropConvert, EpPropFinalized, EpPropInput, EpPropMergeType, IfEpProp, IfNativePropType, NativePropType } from './types';
+export declare const epPropKey = "__epPropKey";
+export declare const definePropType: <T>(val: any) => PropType<T>;
+export declare const isEpProp: (val: unknown) => val is EpProp<any, any, any>;
+/**
+ * @description Build prop. It can better optimize prop types
+ * @description 生成 prop，能更好地优化类型
+ * @example
+  // limited options
+  // the type will be PropType<'light' | 'dark'>
+  buildProp({
+    type: String,
+    values: ['light', 'dark'],
+  } as const)
+  * @example
+  // limited options and other types
+  // the type will be PropType<'small' | 'large' | number>
+  buildProp({
+    type: [String, Number],
+    values: ['small', 'large'],
+    validator: (val: unknown): val is number => typeof val === 'number',
+  } as const)
+  @link see more: https://github.com/element-plus/element-plus/pull/3341
+ */
+export declare const buildProp: <Type = never, Value = never, Validator = never, Default extends EpPropMergeType<Type, Value, Validator> = never, Required extends boolean = false>(prop: EpPropInput<Type, Value, Validator, Default, Required>, key?: string) => EpPropFinalized<Type, Value, Validator, Default, Required>;
+export declare const buildProps: <Props extends Record<string, {
+    [epPropKey]: true;
+} | NativePropType | EpPropInput<any, any, any, any, any>>>(props: Props) => { [K in keyof Props]: IfEpProp<Props[K], Props[K], IfNativePropType<Props[K], Props[K], EpPropConvert<Props[K]>>>; };

package/dist/components/_util/vue/props/runtime.js

@@ -0,0 +1,37 @@
+import { warn as v } from "vue";
+import { fromPairs as w } from "lodash-es";
+import { d as f, h as d } from "../../../../functions-DzLqXvGt.js";
+const u = "__epPropKey", $ = (e) => e, y = (e) => f(e) && !!e[u], O = (e, t) => {
+  if (!f(e) || y(e)) return e;
+  const { values: r, required: p, default: n, type: c, validator: a } = e, s = {
+    type: c,
+    required: !!p,
+    validator: r || a ? (l) => {
+      let i = !1, o = [];
+      if (r && (o = Array.from(r), d(e, "default") && o.push(n), i || (i = o.includes(l))), a && (i || (i = a(l))), !i && o.length > 0) {
+        const m = [...new Set(o)].map((P) => JSON.stringify(P)).join(", ");
+        v(
+          `Invalid prop: validation failed${t ? ` for prop "${t}"` : ""}. Expected one of [${m}], got value ${JSON.stringify(
+            l
+          )}.`
+        );
+      }
+      return i;
+    } : void 0,
+    [u]: !0
+  };
+  return d(e, "default") && (s.default = n), s;
+}, j = (e) => w(
+  Object.entries(e).map(([t, r]) => [
+    t,
+    O(r, t)
+  ])
+);
+export {
+  O as buildProp,
+  j as buildProps,
+  $ as definePropType,
+  u as epPropKey,
+  y as isEpProp
+};
+//# sourceMappingURL=runtime.js.map

package/dist/components/_util/vue/props/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.js","sources":["../../../../../src/components/_util/vue/props/runtime.ts"],"sourcesContent":["import { warn } from 'vue'\r\nimport { fromPairs } from 'lodash-unified'\r\nimport { isObject } from '../../types'\r\nimport { hasOwn } from '../../objects'\r\n\r\nimport type { PropType } from 'vue'\r\nimport type {\r\n  EpProp,\r\n  EpPropConvert,\r\n  EpPropFinalized,\r\n  EpPropInput,\r\n  EpPropMergeType,\r\n  IfEpProp,\r\n  IfNativePropType,\r\n  NativePropType,\r\n} from './types'\r\n\r\nexport const epPropKey = '__epPropKey'\r\n\r\nexport const definePropType = <T>(val: any): PropType<T> => val\r\n\r\nexport const isEpProp = (val: unknown): val is EpProp<any, any, any> =>\r\n  isObject(val) && !!(val as any)[epPropKey]\r\n\r\n/**\r\n * @description Build prop. It can better optimize prop types\r\n * @description 生成 prop，能更好地优化类型\r\n * @example\r\n  // limited options\r\n  // the type will be PropType<'light' | 'dark'>\r\n  buildProp({\r\n    type: String,\r\n    values: ['light', 'dark'],\r\n  } as const)\r\n  * @example\r\n  // limited options and other types\r\n  // the type will be PropType<'small' | 'large' | number>\r\n  buildProp({\r\n    type: [String, Number],\r\n    values: ['small', 'large'],\r\n    validator: (val: unknown): val is number => typeof val === 'number',\r\n  } as const)\r\n  @link see more: https://github.com/element-plus/element-plus/pull/3341\r\n */\r\nexport const buildProp = <\r\n  Type = never,\r\n  Value = never,\r\n  Validator = never,\r\n  Default extends EpPropMergeType<Type, Value, Validator> = never,\r\n  Required extends boolean = false\r\n>(\r\n  prop: EpPropInput<Type, Value, Validator, Default, Required>,\r\n  key?: string\r\n): EpPropFinalized<Type, Value, Validator, Default, Required> => {\r\n  // filter native prop type and nested prop, e.g `null`, `undefined` (from `buildProps`)\r\n  if (!isObject(prop) || isEpProp(prop)) return prop as any\r\n\r\n  const { values, required, default: defaultValue, type, validator } = prop\r\n\r\n  const _validator =\r\n    values || validator\r\n      ? (val: unknown) => {\r\n          let valid = false\r\n          let allowedValues: unknown[] = []\r\n\r\n          if (values) {\r\n            allowedValues = Array.from(values)\r\n            if (hasOwn(prop, 'default')) {\r\n              allowedValues.push(defaultValue)\r\n            }\r\n            valid ||= allowedValues.includes(val)\r\n          }\r\n          if (validator) valid ||= validator(val)\r\n\r\n          if (!valid && allowedValues.length > 0) {\r\n            const allowValuesText = [...new Set(allowedValues)]\r\n              .map((value) => JSON.stringify(value))\r\n              .join(', ')\r\n            warn(\r\n              `Invalid prop: validation failed${\r\n                key ? ` for prop \"${key}\"` : ''\r\n              }. Expected one of [${allowValuesText}], got value ${JSON.stringify(\r\n                val\r\n              )}.`\r\n            )\r\n          }\r\n          return valid\r\n        }\r\n      : undefined\r\n\r\n  const epProp: any = {\r\n    type,\r\n    required: !!required,\r\n    validator: _validator,\r\n    [epPropKey]: true,\r\n  }\r\n  if (hasOwn(prop, 'default')) epProp.default = defaultValue\r\n  return epProp\r\n}\r\n\r\nexport const buildProps = <\r\n  Props extends Record<\r\n    string,\r\n    | { [epPropKey]: true }\r\n    | NativePropType\r\n    | EpPropInput<any, any, any, any, any>\r\n  >\r\n>(\r\n  props: Props\r\n): {\r\n  [K in keyof Props]: IfEpProp<\r\n    Props[K],\r\n    Props[K],\r\n    IfNativePropType<Props[K], Props[K], EpPropConvert<Props[K]>>\r\n  >\r\n} =>\r\n  fromPairs(\r\n    Object.entries(props).map(([key, option]) => [\r\n      key,\r\n      buildProp(option as any, key),\r\n    ])\r\n  ) as any\r\n"],"names":["epPropKey","definePropType","val","isEpProp","isObject","buildProp","prop","key","values","required","defaultValue","type","validator","epProp","valid","allowedValues","hasOwn","allowValuesText","value","warn","buildProps","props","fromPairs","option"],"mappings":";;;AAiBO,MAAMA,IAAY,eAEZC,IAAiB,CAAIC,MAA0BA,GAE/CC,IAAW,CAACD,MACvBE,EAASF,CAAG,KAAK,CAAC,CAAEA,EAAYF,CAAS,GAsB9BK,IAAY,CAOvBC,GACAC,MAC+D;AAE/D,MAAI,CAACH,EAASE,CAAI,KAAKH,EAASG,CAAI,EAAU,QAAAA;AAE9C,QAAM,EAAE,QAAAE,GAAQ,UAAAC,GAAU,SAASC,GAAc,MAAAC,GAAM,WAAAC,EAAc,IAAAN,GAiC/DO,IAAc;AAAA,IAClB,MAAAF;AAAA,IACA,UAAU,CAAC,CAACF;AAAA,IACZ,WAjCAD,KAAUI,IACN,CAACV,MAAiB;AAChB,UAAIY,IAAQ,IACRC,IAA2B,CAAA;AAW/B,UATIP,MACcO,IAAA,MAAM,KAAKP,CAAM,GAC7BQ,EAAOV,GAAM,SAAS,KACxBS,EAAc,KAAKL,CAAY,GAEvBI,UAAAC,EAAc,SAASb,CAAG,KAElCU,MAAqBE,UAAAF,EAAUV,CAAG,KAElC,CAACY,KAASC,EAAc,SAAS,GAAG;AACtC,cAAME,IAAkB,CAAC,GAAG,IAAI,IAAIF,CAAa,CAAC,EAC/C,IAAI,CAACG,MAAU,KAAK,UAAUA,CAAK,CAAC,EACpC,KAAK,IAAI;AACZ,QAAAC;AAAA,UACE,kCACEZ,IAAM,cAAcA,CAAG,MAAM,EAC/B,sBAAsBU,CAAe,gBAAgB,KAAK;AAAA,YACxDf;AAAA,UACD,CAAA;AAAA,QAAA;AAAA,MAEL;AACO,aAAAY;AAAA,IAET,IAAA;AAAA,IAMJ,CAACd,CAAS,GAAG;AAAA,EAAA;AAEf,SAAIgB,EAAOV,GAAM,SAAS,QAAU,UAAUI,IACvCG;AACT,GAEaO,IAAa,CAQxBC,MAQAC;AAAA,EACE,OAAO,QAAQD,CAAK,EAAE,IAAI,CAAC,CAACd,GAAKgB,CAAM,MAAM;AAAA,IAC3ChB;AAAA,IACAF,EAAUkB,GAAehB,CAAG;AAAA,EAAA,CAC7B;AACH;"}

package/dist/components/_util/vue/props/types.d.ts

@@ -0,0 +1,120 @@
+import { epPropKey } from './runtime';
+import { ExtractPropTypes, PropType } from 'vue';
+import { IfNever, UnknownToNever, WritableArray } from './util';
+type Value<T> = T[keyof T];
+/**
+ * Extract the type of a single prop
+ *
+ * 提取单个 prop 的参数类型
+ *
+ * @example
+ * ExtractPropType<{ type: StringConstructor }> => string | undefined
+ * ExtractPropType<{ type: StringConstructor, required: true }> => string
+ * ExtractPropType<{ type: BooleanConstructor }> => boolean
+ */
+export type ExtractPropType<T extends object> = Value<ExtractPropTypes<{
+    key: T;
+}>>;
+/**
+ * Extracts types via `ExtractPropTypes`, accepting `PropType<T>`, `XXXConstructor`, `never`...
+ *
+ * 通过 `ExtractPropTypes` 提取类型，接受 `PropType<T>`、`XXXConstructor`、`never`...
+ *
+ * @example
+ * ResolvePropType<BooleanConstructor> => boolean
+ * ResolvePropType<PropType<T>> => T
+ **/
+export type ResolvePropType<T> = IfNever<T, never, ExtractPropType<{
+    type: WritableArray<T>;
+    required: true;
+}>>;
+/**
+ * Merge Type, Value, Validator types
+ * 合并 Type、Value、Validator 的类型
+ *
+ * @example
+ * EpPropMergeType<StringConstructor, '1', 1> =>  1 | "1" // ignores StringConstructor
+ * EpPropMergeType<StringConstructor, never, number> =>  string | number
+ */
+export type EpPropMergeType<Type, Value, Validator> = IfNever<UnknownToNever<Value>, ResolvePropType<Type>, never> | UnknownToNever<Value> | UnknownToNever<Validator>;
+/**
+ * Handling default values for input (constraints)
+ *
+ * 处理输入参数的默认值（约束）
+ */
+export type EpPropInputDefault<Required extends boolean, Default> = Required extends true ? never : Default extends Record<string, unknown> | Array<any> ? () => Default : (() => Default) | Default;
+/**
+ * Native prop types, e.g: `BooleanConstructor`, `StringConstructor`, `null`, `undefined`, etc.
+ *
+ * 原生 prop `类型，BooleanConstructor`、`StringConstructor`、`null`、`undefined` 等
+ */
+export type NativePropType = ((...args: any) => any) | {
+    new (...args: any): any;
+} | undefined | null;
+export type IfNativePropType<T, Y, N> = [T] extends [NativePropType] ? Y : N;
+/**
+ * input prop `buildProp` or `buildProps` (constraints)
+ *
+ * prop 输入参数（约束）
+ *
+ * @example
+ * EpPropInput<StringConstructor, 'a', never, never, true>
+ * ⬇️
+ * {
+    type?: StringConstructor | undefined;
+    required?: true | undefined;
+    values?: readonly "a"[] | undefined;
+    validator?: ((val: any) => boolean) | ((val: any) => val is never) | undefined;
+    default?: undefined;
+  }
+ */
+export type EpPropInput<Type, Value, Validator, Default extends EpPropMergeType<Type, Value, Validator>, Required extends boolean> = {
+    type?: Type;
+    required?: Required;
+    values?: readonly Value[];
+    validator?: ((val: any) => val is Validator) | ((val: any) => boolean);
+    default?: EpPropInputDefault<Required, Default>;
+};
+/**
+ * output prop `buildProp` or `buildProps`.
+ *
+ * prop 输出参数。
+ *
+ * @example
+ * EpProp<'a', 'b', true>
+ * ⬇️
+ * {
+    readonly type: PropType<"a">;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    readonly default: "b";
+    __epPropKey: true;
+  }
+ */
+export type EpProp<Type, Default, Required> = {
+    readonly type: PropType<Type>;
+    readonly required: [Required] extends [true] ? true : false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    [epPropKey]: true;
+} & IfNever<Default, unknown, {
+    readonly default: Default;
+}>;
+/**
+ * Determine if it is `EpProp`
+ */
+export type IfEpProp<T, Y, N> = T extends {
+    [epPropKey]: true;
+} ? Y : N;
+/**
+ * Converting input to output.
+ *
+ * 将输入转换为输出
+ */
+export type EpPropConvert<Input> = Input extends EpPropInput<infer Type, infer Value, infer Validator, any, infer Required> ? EpPropFinalized<Type, Value, Validator, Input['default'], Required> : never;
+/**
+ * Finalized conversion output
+ *
+ * 最终转换 EpProp
+ */
+export type EpPropFinalized<Type, Value, Validator, Default, Required> = EpProp<EpPropMergeType<Type, Value, Validator>, UnknownToNever<Default>, Required>;
+export {};

package/dist/components/_util/vue/props/types.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=types.js.map

package/dist/components/_util/vue/props/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/components/_util/vue/props/util.d.ts

@@ -0,0 +1,8 @@
+export type Writable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+export type WritableArray<T> = T extends readonly any[] ? Writable<T> : T;
+export type IfNever<T, Y = true, N = false> = [T] extends [never] ? Y : N;
+export type IfUnknown<T, Y, N> = [unknown] extends [T] ? Y : N;
+export type UnknownToNever<T> = IfUnknown<T, never, T>;
+export {};

package/dist/components/_util/vue/props/util.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=util.js.map

package/dist/components/_util/vue/props/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/components/_util/vue/refs.d.ts

@@ -0,0 +1,3 @@
+import { ComponentPublicInstance, Ref } from 'vue';
+export type RefSetter = (el: Element | ComponentPublicInstance | undefined) => void;
+export declare const composeRefs: (...refs: (Ref<HTMLElement | undefined> | RefSetter)[]) => (el: Element | ComponentPublicInstance | null) => void;

package/dist/components/_util/vue/refs.js

@@ -0,0 +1,12 @@
+import { b as r } from "../../../functions-DzLqXvGt.js";
+import "lodash-es";
+import "vue";
+const c = (...i) => (t) => {
+  i.forEach((o) => {
+    r(o) ? o(t) : o.value = t;
+  });
+};
+export {
+  c as composeRefs
+};
+//# sourceMappingURL=refs.js.map

package/dist/components/_util/vue/refs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"refs.js","sources":["../../../../src/components/_util/vue/refs.ts"],"sourcesContent":["import { isFunction } from '../types'\r\n\r\nimport type { ComponentPublicInstance, Ref } from 'vue'\r\n\r\nexport type RefSetter = (\r\n  el: Element | ComponentPublicInstance | undefined\r\n) => void\r\n\r\nexport const composeRefs = (\r\n  ...refs: (Ref<HTMLElement | undefined> | RefSetter)[]\r\n) => {\r\n  return (el: Element | ComponentPublicInstance | null) => {\r\n    refs.forEach((ref) => {\r\n      if (isFunction(ref)) {\r\n        ref(el as Element | ComponentPublicInstance)\r\n      } else {\r\n        ref.value = el as HTMLElement | undefined\r\n      }\r\n    })\r\n  }\r\n}\r\n"],"names":["composeRefs","refs","el","ref","isFunction"],"mappings":";;;AAQa,MAAAA,IAAc,IACtBC,MAEI,CAACC,MAAiD;AAClD,EAAAD,EAAA,QAAQ,CAACE,MAAQ;AAChB,IAAAC,EAAWD,CAAG,IAChBA,EAAID,CAAuC,IAE3CC,EAAI,QAAQD;AAAA,EACd,CACD;AAAA;"}

package/dist/components/_util/vue/size.d.ts

@@ -0,0 +1,2 @@
+import { ComponentSize } from 'element-plus';
+export declare const getComponentSize: (size?: ComponentSize) => 40 | 32 | 24;

package/dist/components/_util/vue/size.js

@@ -0,0 +1,6 @@
+import { componentSizeMap as o } from "element-plus";
+const n = (e) => o[e || "default"];
+export {
+  n as getComponentSize
+};
+//# sourceMappingURL=size.js.map

package/dist/components/_util/vue/size.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"size.js","sources":["../../../../src/components/_util/vue/size.ts"],"sourcesContent":["import { componentSizeMap } from 'element-plus'\r\n\r\nimport type { ComponentSize } from 'element-plus'\r\n\r\nexport const getComponentSize = (size?: ComponentSize) => {\r\n  return componentSizeMap[size || 'default']\r\n}\r\n"],"names":["getComponentSize","size","componentSizeMap"],"mappings":";AAIa,MAAAA,IAAmB,CAACC,MACxBC,EAAiBD,KAAQ,SAAS;"}

package/dist/components/_util/vue/typescript.d.ts

@@ -0,0 +1,5 @@
+import { AppContext, Plugin } from 'vue';
+export type SFCWithInstall<T> = T & Plugin;
+export type SFCInstallWithContext<T> = SFCWithInstall<T> & {
+    _context: AppContext | null;
+};

package/dist/components/_util/vue/typescript.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=typescript.js.map

package/dist/components/_util/vue/typescript.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/components/_util/vue/validator.d.ts

@@ -0,0 +1,3 @@
+import { ComponentSize, DatePickType } from 'element-plus';
+export declare const isValidComponentSize: (val: string) => val is ComponentSize | "";
+export declare const isValidDatePickType: (val: string) => val is DatePickType;

package/dist/components/_util/vue/validator.js

@@ -0,0 +1,7 @@
+import { componentSizes as i, datePickTypes as o } from "element-plus";
+const s = (e) => ["", ...i].includes(e), t = (e) => [...o].includes(e);
+export {
+  s as isValidComponentSize,
+  t as isValidDatePickType
+};
+//# sourceMappingURL=validator.js.map

package/dist/components/_util/vue/validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.js","sources":["../../../../src/components/_util/vue/validator.ts"],"sourcesContent":["import { componentSizes, datePickTypes } from 'element-plus'\r\nimport type { ComponentSize, DatePickType } from 'element-plus'\r\n\r\nexport const isValidComponentSize = (val: string): val is ComponentSize | '' =>\r\n  ['', ...componentSizes].includes(val)\r\n\r\nexport const isValidDatePickType = (val: string): val is DatePickType =>\r\n  ([...datePickTypes] as string[]).includes(val)\r\n"],"names":["isValidComponentSize","val","componentSizes","isValidDatePickType","datePickTypes"],"mappings":";AAGa,MAAAA,IAAuB,CAACC,MACnC,CAAC,IAAI,GAAGC,CAAc,EAAE,SAASD,CAAG,GAEzBE,IAAsB,CAACF,MACjC,CAAC,GAAGG,CAAa,EAAe,SAASH,CAAG;"}

package/dist/components/_util/vue/vnode.d.ts

@@ -0,0 +1,50 @@
+import { createBlock, VNode, VNodeArrayChildren, VNodeChild, VNodeNormalizedChildren } from 'vue';
+export declare enum PatchFlags {
+    TEXT = 1,
+    CLASS = 2,
+    STYLE = 4,
+    PROPS = 8,
+    FULL_PROPS = 16,
+    HYDRATE_EVENTS = 32,
+    STABLE_FRAGMENT = 64,
+    KEYED_FRAGMENT = 128,
+    UNKEYED_FRAGMENT = 256,
+    NEED_PATCH = 512,
+    DYNAMIC_SLOTS = 1024,
+    HOISTED = -1,
+    BAIL = -2
+}
+export type VNodeChildAtom = Exclude<VNodeChild, Array<any>>;
+export type RawSlots = Exclude<VNodeNormalizedChildren, Array<any> | null | string>;
+export declare function isFragment(node: VNode): boolean;
+export declare function isFragment(node: unknown): node is VNode;
+export declare function isText(node: VNode): boolean;
+export declare function isText(node: unknown): node is VNode;
+export declare function isComment(node: VNode): boolean;
+export declare function isComment(node: unknown): node is VNode;
+export declare function isTemplate(node: VNode): boolean;
+export declare function isTemplate(node: unknown): node is VNode;
+/**
+ * determine if the element is a valid element type rather than fragments and comment e.g. <template> v-if
+ * @param node {VNode} node to be tested
+ */
+export declare function isValidElementNode(node: VNode): boolean;
+export declare function isValidElementNode(node: unknown): node is VNode;
+export declare const getFirstValidNode: (nodes: VNodeNormalizedChildren, maxDepth?: number) => string | number | boolean | void | VNodeArrayChildren | {
+    [name: string]: unknown;
+    $stable?: boolean;
+} | VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> | null | undefined;
+export declare function renderIf(condition: boolean, ...args: Parameters<typeof createBlock>): VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>;
+export declare function renderBlock(...args: Parameters<typeof createBlock>): VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>;
+export declare const getNormalizedProps: (node: VNode) => Record<string, any>;
+export declare const ensureOnlyChild: (children: VNodeArrayChildren | undefined) => VNodeArrayChildren | (string | number | boolean | void | VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> | null | undefined);
+export type FlattenVNodes = Array<VNodeChildAtom | RawSlots>;
+export declare const flattedChildren: (children: FlattenVNodes | VNode | VNodeNormalizedChildren) => FlattenVNodes;

package/dist/components/_util/vue/vnode.js

@@ -0,0 +1,68 @@
+import { isVNode as u, Fragment as m, Text as A, Comment as N, createCommentVNode as S, openBlock as s, createBlock as L } from "vue";
+import { h as _, c as C, i as E } from "../../../functions-DzLqXvGt.js";
+import "lodash-es";
+import { debugWarn as O } from "../error.js";
+const R = "utils/vue/vnode";
+var D = /* @__PURE__ */ ((e) => (e[e.TEXT = 1] = "TEXT", e[e.CLASS = 2] = "CLASS", e[e.STYLE = 4] = "STYLE", e[e.PROPS = 8] = "PROPS", e[e.FULL_PROPS = 16] = "FULL_PROPS", e[e.HYDRATE_EVENTS = 32] = "HYDRATE_EVENTS", e[e.STABLE_FRAGMENT = 64] = "STABLE_FRAGMENT", e[e.KEYED_FRAGMENT = 128] = "KEYED_FRAGMENT", e[e.UNKEYED_FRAGMENT = 256] = "UNKEYED_FRAGMENT", e[e.NEED_PATCH = 512] = "NEED_PATCH", e[e.DYNAMIC_SLOTS = 1024] = "DYNAMIC_SLOTS", e[e.HOISTED = -1] = "HOISTED", e[e.BAIL = -2] = "BAIL", e))(D || {});
+function f(e) {
+  return u(e) && e.type === m;
+}
+function G(e) {
+  return u(e) && e.type === A;
+}
+function p(e) {
+  return u(e) && e.type === N;
+}
+const y = "template";
+function Y(e) {
+  return u(e) && e.type === y;
+}
+function H(e) {
+  return u(e) && !f(e) && !p(e);
+}
+function T(e, t) {
+  if (!p(e))
+    return f(e) || Y(e) ? t > 0 ? M(e.children, t - 1) : void 0 : e;
+}
+const M = (e, t = 3) => Array.isArray(e) ? T(e[0], t) : T(e, t);
+function w(e, ...t) {
+  return e ? v(...t) : S("v-if", !0);
+}
+function v(...e) {
+  return s(), L(...e);
+}
+const K = (e) => {
+  if (!u(e))
+    return O(R, "[getNormalizedProps] must be a VNode"), {};
+  const t = e.props || {}, n = (u(e.type) ? e.type.props : void 0) || {}, r = {};
+  return Object.keys(n).forEach((o) => {
+    _(n[o], "default") && (r[o] = n[o].default);
+  }), Object.keys(t).forEach((o) => {
+    r[C(o)] = t[o];
+  }), r;
+}, U = (e) => {
+  if (!E(e) || e.length > 1)
+    throw new Error("expect to receive a single Vue element child");
+  return e[0];
+}, i = (e) => {
+  const t = E(e) ? e : [e], n = [];
+  return t.forEach((r) => {
+    var o;
+    E(r) ? n.push(...i(r)) : u(r) && E(r.children) ? n.push(...i(r.children)) : (n.push(r), u(r) && ((o = r.component) != null && o.subTree) && n.push(...i(r.component.subTree)));
+  }), n;
+};
+export {
+  D as PatchFlags,
+  U as ensureOnlyChild,
+  i as flattedChildren,
+  M as getFirstValidNode,
+  K as getNormalizedProps,
+  p as isComment,
+  f as isFragment,
+  Y as isTemplate,
+  G as isText,
+  H as isValidElementNode,
+  v as renderBlock,
+  w as renderIf
+};
+//# sourceMappingURL=vnode.js.map

package/dist/components/_util/vue/vnode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vnode.js","sources":["../../../../src/components/_util/vue/vnode.ts"],"sourcesContent":["import {\r\n  Comment,\r\n  Fragment,\r\n  Text,\r\n  createBlock,\r\n  createCommentVNode,\r\n  isVNode,\r\n  openBlock,\r\n} from 'vue'\r\nimport { camelize } from '../strings'\r\nimport { isArray } from '../types'\r\nimport { hasOwn } from '../objects'\r\nimport { debugWarn } from '../error'\r\nimport type {\r\n  VNode,\r\n  VNodeArrayChildren,\r\n  VNodeChild,\r\n  VNodeNormalizedChildren,\r\n} from 'vue'\r\n\r\nconst SCOPE = 'utils/vue/vnode'\r\n\r\nexport enum PatchFlags {\r\n  TEXT = 1,\r\n  CLASS = 2,\r\n  STYLE = 4,\r\n  PROPS = 8,\r\n  FULL_PROPS = 16,\r\n  HYDRATE_EVENTS = 32,\r\n  STABLE_FRAGMENT = 64,\r\n  KEYED_FRAGMENT = 128,\r\n  UNKEYED_FRAGMENT = 256,\r\n  NEED_PATCH = 512,\r\n  DYNAMIC_SLOTS = 1024,\r\n  HOISTED = -1,\r\n  BAIL = -2,\r\n}\r\n\r\nexport type VNodeChildAtom = Exclude<VNodeChild, Array<any>>\r\nexport type RawSlots = Exclude<\r\n  VNodeNormalizedChildren,\r\n  Array<any> | null | string\r\n>\r\n\r\nexport function isFragment(node: VNode): boolean\r\nexport function isFragment(node: unknown): node is VNode\r\nexport function isFragment(node: unknown): node is VNode {\r\n  return isVNode(node) && node.type === Fragment\r\n}\r\n\r\nexport function isText(node: VNode): boolean\r\nexport function isText(node: unknown): node is VNode\r\nexport function isText(node: unknown): node is VNode {\r\n  return isVNode(node) && node.type === Text\r\n}\r\n\r\nexport function isComment(node: VNode): boolean\r\nexport function isComment(node: unknown): node is VNode\r\nexport function isComment(node: unknown): node is VNode {\r\n  return isVNode(node) && node.type === Comment\r\n}\r\n\r\nconst TEMPLATE = 'template'\r\nexport function isTemplate(node: VNode): boolean\r\nexport function isTemplate(node: unknown): node is VNode\r\nexport function isTemplate(node: unknown): node is VNode {\r\n  return isVNode(node) && node.type === TEMPLATE\r\n}\r\n\r\n/**\r\n * determine if the element is a valid element type rather than fragments and comment e.g. <template> v-if\r\n * @param node {VNode} node to be tested\r\n */\r\nexport function isValidElementNode(node: VNode): boolean\r\nexport function isValidElementNode(node: unknown): node is VNode\r\nexport function isValidElementNode(node: unknown): node is VNode {\r\n  return isVNode(node) && !isFragment(node) && !isComment(node)\r\n}\r\n\r\n/**\r\n * get a valid child node (not fragment nor comment)\r\n * @param node {VNode} node to be searched\r\n * @param depth {number} depth to be searched\r\n */\r\nfunction getChildren(\r\n  node: VNodeNormalizedChildren | VNodeChild,\r\n  depth: number\r\n): VNodeNormalizedChildren | VNodeChild {\r\n  if (isComment(node)) return\r\n  if (isFragment(node) || isTemplate(node)) {\r\n    return depth > 0 ? getFirstValidNode(node.children, depth - 1) : undefined\r\n  }\r\n  return node\r\n}\r\n\r\nexport const getFirstValidNode = (\r\n  nodes: VNodeNormalizedChildren,\r\n  maxDepth = 3\r\n) => {\r\n  if (Array.isArray(nodes)) {\r\n    return getChildren(nodes[0], maxDepth)\r\n  } else {\r\n    return getChildren(nodes, maxDepth)\r\n  }\r\n}\r\n\r\nexport function renderIf(\r\n  condition: boolean,\r\n  ...args: Parameters<typeof createBlock>\r\n) {\r\n  return condition ? renderBlock(...args) : createCommentVNode('v-if', true)\r\n}\r\n\r\nexport function renderBlock(...args: Parameters<typeof createBlock>) {\r\n  return openBlock(), createBlock(...args)\r\n}\r\n\r\nexport const getNormalizedProps = (node: VNode) => {\r\n  if (!isVNode(node)) {\r\n    debugWarn(SCOPE, '[getNormalizedProps] must be a VNode')\r\n    return {}\r\n  }\r\n\r\n  const raw = node.props || {}\r\n  const type = (isVNode(node.type) ? node.type.props : undefined) || {}\r\n  const props: Record<string, any> = {}\r\n\r\n  Object.keys(type).forEach((key) => {\r\n    if (hasOwn(type[key], 'default')) {\r\n      props[key] = type[key].default\r\n    }\r\n  })\r\n\r\n  Object.keys(raw).forEach((key) => {\r\n    props[camelize(key)] = raw[key]\r\n  })\r\n\r\n  return props\r\n}\r\n\r\nexport const ensureOnlyChild = (children: VNodeArrayChildren | undefined) => {\r\n  if (!isArray(children) || children.length > 1) {\r\n    throw new Error('expect to receive a single Vue element child')\r\n  }\r\n  return children[0]\r\n}\r\n\r\nexport type FlattenVNodes = Array<VNodeChildAtom | RawSlots>\r\n\r\nexport const flattedChildren = (\r\n  children: FlattenVNodes | VNode | VNodeNormalizedChildren\r\n): FlattenVNodes => {\r\n  const vNodes = isArray(children) ? children : [children]\r\n  const result: FlattenVNodes = []\r\n\r\n  vNodes.forEach((child) => {\r\n    if (isArray(child)) {\r\n      result.push(...flattedChildren(child))\r\n    } else if (isVNode(child) && isArray(child.children)) {\r\n      result.push(...flattedChildren(child.children))\r\n    } else {\r\n      result.push(child)\r\n      if (isVNode(child) && child.component?.subTree) {\r\n        result.push(...flattedChildren(child.component.subTree))\r\n      }\r\n    }\r\n  })\r\n  return result\r\n}\r\n"],"names":["SCOPE","PatchFlags","isFragment","node","isVNode","Fragment","isText","Text","isComment","Comment","TEMPLATE","isTemplate","isValidElementNode","getChildren","depth","getFirstValidNode","nodes","maxDepth","renderIf","condition","args","renderBlock","createCommentVNode","openBlock","createBlock","getNormalizedProps","debugWarn","raw","type","props","key","hasOwn","camelize","ensureOnlyChild","children","isArray","flattedChildren","vNodes","result","child","_a"],"mappings":"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"}

package/dist/components/_util/vue-types/index.d.ts

@@ -1,6 +1,6 @@
-import type { CSSProperties } from 'vue';
-import type { VueTypeValidableDef, VueTypesInterface } from 'vue-types';
-import type { VueNode } from '../type';
+import { CSSProperties } from 'vue';
+import { VueTypeValidableDef, VueTypesInterface } from 'vue-types';
+import { VueNode } from '../type';
 export declare function withUndefined<T extends {
     default?: any;
 }>(type: T): T;