@fangzhongya/fang-ui 0.0.3

package/dist/utils/enums.d.ts

@@ -0,0 +1,26 @@
+export declare enum SymbolKey {
+    /**
+     * 全部配置数据
+     */
+    GlobalConfig = "config"
+}
+export declare enum FunctConfig {
+    ObjConfig = "configs",
+    epPropKey = "__epPropKey"
+}
+export declare enum DefaultConfig {
+    /**
+     * 组件前缀
+     */
+    alias = ""
+}
+export declare enum TableMapw {
+    M2 = 80,
+    M3 = 90,
+    M4 = 100,
+    M5 = 110,
+    M6 = 120,
+    M7 = 130,
+    M8 = 145,
+    M9 = 160
+}

package/dist/utils/enums.js

@@ -0,0 +1,18 @@
+var SymbolKey = /* @__PURE__ */ ((SymbolKey2) => {
+  SymbolKey2["GlobalConfig"] = "config";
+  return SymbolKey2;
+})(SymbolKey || {});
+var FunctConfig = /* @__PURE__ */ ((FunctConfig2) => {
+  FunctConfig2["ObjConfig"] = "configs";
+  FunctConfig2["epPropKey"] = "__epPropKey";
+  return FunctConfig2;
+})(FunctConfig || {});
+var DefaultConfig = /* @__PURE__ */ ((DefaultConfig2) => {
+  DefaultConfig2["alias"] = "";
+  return DefaultConfig2;
+})(DefaultConfig || {});
+export {
+  DefaultConfig,
+  FunctConfig,
+  SymbolKey
+};

package/dist/utils/getOnlyKey.cjs

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const onlyKey = {};
+function getOnlyKey(key) {
+  if (!onlyKey[key]) {
+    onlyKey[key] = Symbol(key);
+  }
+  return onlyKey[key];
+}
+exports.getOnlyKey = getOnlyKey;

package/dist/utils/getOnlyKey.d.ts

@@ -0,0 +1 @@
+export declare function getOnlyKey(key: string): symbol;

package/dist/utils/getOnlyKey.js

@@ -0,0 +1,10 @@
+const onlyKey = {};
+function getOnlyKey(key) {
+  if (!onlyKey[key]) {
+    onlyKey[key] = Symbol(key);
+  }
+  return onlyKey[key];
+}
+export {
+  getOnlyKey
+};

package/dist/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './vue';
+export * from './css';
+export * from './getOnlyKey';
+export * from './enums';
+export * from './util';

package/dist/utils/util.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function isObject(obj) {
+  return obj !== null && typeof obj === "object";
+}
+function firstUpper(str) {
+  return str.slice(0, 1).toUpperCase() + str.slice(1);
+}
+function firstLower(str) {
+  return str.slice(0, 1).toLowerCase() + str.slice(1);
+}
+function lineToLargeHump(name) {
+  let arr = name.split("-");
+  arr = arr.map((vs) => {
+    return firstUpper(vs);
+  });
+  return arr.join("");
+}
+exports.firstLower = firstLower;
+exports.firstUpper = firstUpper;
+exports.isObject = isObject;
+exports.lineToLargeHump = lineToLargeHump;

package/dist/utils/util.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 是否是对象
+ * @param {any} obj 判断值
+ * @returns {boolean}
+ */
+export declare function isObject(obj: any): boolean;
+declare function firstUpper(str: string): string;
+/**
+ * 首字母小写
+ * @param {string} str 处理字符串
+ * @returns {string}
+ */
+export declare function firstLower(str: string): string;
+declare function lineToLargeHump(name: string): string;
+import { splitUpper } from '@fangzhongya/utils/basic/string/splitUpper';
+import { isArray } from '@fangzhongya/utils/basic/array/isArray';
+export { splitUpper, isArray, firstUpper, lineToLargeHump };

package/dist/utils/util.js

@@ -0,0 +1,22 @@
+function isObject(obj) {
+  return obj !== null && typeof obj === "object";
+}
+function firstUpper(str) {
+  return str.slice(0, 1).toUpperCase() + str.slice(1);
+}
+function firstLower(str) {
+  return str.slice(0, 1).toLowerCase() + str.slice(1);
+}
+function lineToLargeHump(name) {
+  let arr = name.split("-");
+  arr = arr.map((vs) => {
+    return firstUpper(vs);
+  });
+  return arr.join("");
+}
+export {
+  firstLower,
+  firstUpper,
+  isObject,
+  lineToLargeHump
+};

package/dist/utils/vue/common.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("vue");
+const util = require("../util.cjs");
+function setVueValue(v, key) {
+  if (key && util.isObject(v)) {
+    if (typeof key == "function") {
+      return key(v);
+    } else if (typeof key == "string") {
+      return v[key];
+    }
+  }
+  return v;
+}
+exports.setVueValue = setVueValue;

package/dist/utils/vue/common.d.ts

@@ -0,0 +1,18 @@
+import type { ObjStr, ObjAny } from '../../types';
+export declare function setVueValue(v: any, key: string | Function): any;
+/**
+ * 判断是否隐藏
+ */
+export declare function setHide(item: any, v: any): boolean;
+type SetClass = string | string[] | ObjStr;
+export declare function setClass(...arr: Array<SetClass>): string;
+export declare function setMinWidth(obj: ObjAny): any;
+/**
+ * 支持事件别名处理
+ * @param {*} callback
+ * @param {*} arr
+ * @param {*} obj
+ * @param {*} $event
+ */
+export declare function eventAliass(callback: Function, arr: string | string[], obj: any, $event: Event): boolean;
+export {};

package/dist/utils/vue/common.js

@@ -0,0 +1,15 @@
+import "vue";
+import { isObject } from "../util.js";
+function setVueValue(v, key) {
+  if (key && isObject(v)) {
+    if (typeof key == "function") {
+      return key(v);
+    } else if (typeof key == "string") {
+      return v[key];
+    }
+  }
+  return v;
+}
+export {
+  setVueValue
+};

package/dist/utils/vue/definePropType.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function definePropType(val) {
+  return val;
+}
+exports.definePropType = definePropType;

package/dist/utils/vue/definePropType.d.ts

@@ -0,0 +1,2 @@
+import type { PropType } from 'vue';
+export declare function definePropType<T>(val: any): PropType<T>;

package/dist/utils/vue/definePropType.js

@@ -0,0 +1,6 @@
+function definePropType(val) {
+  return val;
+}
+export {
+  definePropType
+};

package/dist/utils/vue/index.d.ts

@@ -0,0 +1,4 @@
+export * from './props';
+export * from './common';
+export * from './definePropType';
+export * from './withInstall';

package/dist/utils/vue/props/index.d.ts

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

package/dist/utils/vue/props/runtime.cjs

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const vue = require("vue");
+const util = require("../../util.cjs");
+const enums = require("../../enums.cjs");
+const { epPropKey, ObjConfig } = enums.FunctConfig;
+function hasOwn(val, key) {
+  return Object.prototype.hasOwnProperty.call(val, key);
+}
+function fromPairs(arr) {
+  const obj = {};
+  for (let index = 0; index < arr.length; index++) {
+    const [key, value] = arr[index];
+    obj[key] = value;
+  }
+  return obj;
+}
+const isEpProp = (val) => util.isObject(val) && !!val[epPropKey];
+const buildProp = (prop, key) => {
+  if (!util.isObject(prop) || isEpProp(prop))
+    return prop;
+  const {
+    values,
+    required,
+    default: defaultValue,
+    type,
+    validator
+  } = prop;
+  const _validator = values || validator ? (val) => {
+    let valid = false;
+    let allowedValues = [];
+    if (values) {
+      allowedValues = Array.from(values);
+      if (hasOwn(prop, "default")) {
+        allowedValues.push(defaultValue);
+      }
+      valid || (valid = allowedValues.includes(val));
+    }
+    if (validator)
+      valid || (valid = validator(val));
+    if (!valid && allowedValues.length > 0) {
+      const allowValuesText = [
+        ...new Set(allowedValues)
+      ].map(
+        (value) => JSON.stringify(value)
+      ).join(", ");
+      vue.warn(
+        `Invalid prop: validation failed${key ? ` for prop "${key}"` : ""}. Expected one of [${allowValuesText}], got value ${JSON.stringify(
+          val
+        )}.`
+      );
+    }
+    return valid;
+  } : void 0;
+  const epProp = {
+    type,
+    required: !!required,
+    validator: _validator,
+    [epPropKey]: true
+  };
+  if (hasOwn(prop, "default"))
+    epProp.default = defaultValue;
+  return epProp;
+};
+function buildProps(props) {
+  const arr = Object.entries(props);
+  arr.push([
+    ObjConfig,
+    buildProp(
+      {
+        type: Object
+      },
+      ObjConfig
+    )
+  ]);
+  let arrs = arr.map(([key, option]) => [
+    key,
+    buildProp(option, key)
+  ]);
+  return fromPairs(arrs);
+}
+function getBuildProps(obj) {
+  return new Proxy(obj, {
+    get: function(target, propKey, receiver) {
+      const v = target[ObjConfig];
+      if (v && propKey != "__v_isRef") {
+        return Reflect.get(
+          target[ObjConfig],
+          propKey,
+          receiver
+        ) || Reflect.get(target, propKey, receiver);
+      } else {
+        return Reflect.get(
+          target,
+          propKey,
+          receiver
+        );
+      }
+    }
+  });
+}
+exports.ObjConfig = ObjConfig;
+exports.buildProp = buildProp;
+exports.buildProps = buildProps;
+exports.epPropKey = epPropKey;
+exports.getBuildProps = getBuildProps;
+exports.isEpProp = isEpProp;

package/dist/utils/vue/props/runtime.d.ts

@@ -0,0 +1,35 @@
+import { FunctConfig } from '../../enums';
+import type { EpProp, EpPropConvert, EpPropFinalized, EpPropInput, EpPropMergeType, IfEpProp, IfNativePropType, NativePropType } from './types';
+export declare const epPropKey: FunctConfig, ObjConfig: FunctConfig;
+type PropertyName = string | number | symbol;
+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_1 extends boolean = false>(prop: EpPropInput<Type, Value, Validator, Default, Required_1>, key?: string) => EpPropFinalized<Type, Value, Validator, Default, Required_1>;
+export declare function 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]>>>;
+};
+export declare function getBuildProps<T extends {
+    [key: PropertyName]: any;
+}>(obj: T): T;
+export {};

package/dist/utils/vue/props/runtime.js

@@ -0,0 +1,107 @@
+import { warn } from "vue";
+import { isObject } from "../../util.js";
+import { FunctConfig } from "../../enums.js";
+const { epPropKey, ObjConfig } = FunctConfig;
+function hasOwn(val, key) {
+  return Object.prototype.hasOwnProperty.call(val, key);
+}
+function fromPairs(arr) {
+  const obj = {};
+  for (let index = 0; index < arr.length; index++) {
+    const [key, value] = arr[index];
+    obj[key] = value;
+  }
+  return obj;
+}
+const isEpProp = (val) => isObject(val) && !!val[epPropKey];
+const buildProp = (prop, key) => {
+  if (!isObject(prop) || isEpProp(prop))
+    return prop;
+  const {
+    values,
+    required,
+    default: defaultValue,
+    type,
+    validator
+  } = prop;
+  const _validator = values || validator ? (val) => {
+    let valid = false;
+    let allowedValues = [];
+    if (values) {
+      allowedValues = Array.from(values);
+      if (hasOwn(prop, "default")) {
+        allowedValues.push(defaultValue);
+      }
+      valid || (valid = allowedValues.includes(val));
+    }
+    if (validator)
+      valid || (valid = validator(val));
+    if (!valid && allowedValues.length > 0) {
+      const allowValuesText = [
+        ...new Set(allowedValues)
+      ].map(
+        (value) => JSON.stringify(value)
+      ).join(", ");
+      warn(
+        `Invalid prop: validation failed${key ? ` for prop "${key}"` : ""}. Expected one of [${allowValuesText}], got value ${JSON.stringify(
+          val
+        )}.`
+      );
+    }
+    return valid;
+  } : void 0;
+  const epProp = {
+    type,
+    required: !!required,
+    validator: _validator,
+    [epPropKey]: true
+  };
+  if (hasOwn(prop, "default"))
+    epProp.default = defaultValue;
+  return epProp;
+};
+function buildProps(props) {
+  const arr = Object.entries(props);
+  arr.push([
+    ObjConfig,
+    buildProp(
+      {
+        type: Object
+      },
+      ObjConfig
+    )
+  ]);
+  let arrs = arr.map(([key, option]) => [
+    key,
+    buildProp(option, key)
+  ]);
+  return fromPairs(arrs);
+}
+function getBuildProps(obj) {
+  return new Proxy(obj, {
+    get: function(target, propKey, receiver) {
+      const v = target[ObjConfig];
+      if (v && propKey != "__v_isRef") {
+        return Reflect.get(
+          target[ObjConfig],
+          propKey,
+          receiver
+        ) || Reflect.get(target, propKey, receiver);
+      } else {
+        return Reflect.get(
+          target,
+          propKey,
+          receiver
+        );
+      }
+    }
+  });
+}
+export {
+  ObjConfig,
+  buildProp,
+  buildProps,
+  epPropKey,
+  getBuildProps,
+  isEpProp
+};

package/dist/utils/vue/props/types.d.ts

@@ -0,0 +1,130 @@
+import type { epPropKey } from './runtime';
+import type { ExtractPropTypes, PropType } from 'vue';
+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>;
+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/utils/vue/withInstall.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function withInstall(component, name) {
+  component.install = (app) => {
+    app.component(
+      name || component.name,
+      component
+    );
+  };
+  return component;
+}
+exports.withInstall = withInstall;

package/dist/utils/vue/withInstall.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vue';
+export type withInstall<T> = T & Plugin;
+export declare function withInstall<T>(component: T, name: string): withInstall<T>;

package/dist/utils/vue/withInstall.js

@@ -0,0 +1,12 @@
+function withInstall(component, name) {
+  component.install = (app) => {
+    app.component(
+      name || component.name,
+      component
+    );
+  };
+  return component;
+}
+export {
+  withInstall
+};