orion-design 0.1.0 → 0.1.2

package/dist/components/Flex/Col.d.ts

@@ -0,0 +1,25 @@
+import type { PropType, ExtractPropTypes } from 'vue';
+export declare const colProps: () => {
+    gutter: {
+        default: string | boolean;
+        type: PropType<string | boolean>;
+    };
+    height: StringConstructor;
+};
+export type ColProps = Partial<ExtractPropTypes<ReturnType<typeof colProps>>>;
+declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
+    gutter: {
+        default: string | boolean;
+        type: PropType<string | boolean>;
+    };
+    height: StringConstructor;
+}>, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ExtractPropTypes<{
+    gutter: {
+        default: string | boolean;
+        type: PropType<string | boolean>;
+    };
+    height: StringConstructor;
+}>> & Readonly<{}>, {
+    gutter: string | boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/Flex/Item.d.ts

@@ -0,0 +1,25 @@
+import type { ExtractPropTypes } from 'vue';
+export declare const itemProps: () => {
+    flexBasic: StringConstructor;
+    hidden: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+};
+export type ItemProps = Partial<ExtractPropTypes<ReturnType<typeof itemProps>>>;
+declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
+    flexBasic: StringConstructor;
+    hidden: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ExtractPropTypes<{
+    flexBasic: StringConstructor;
+    hidden: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    hidden: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/Flex/Row.d.ts

@@ -0,0 +1,25 @@
+import type { PropType, ExtractPropTypes } from 'vue';
+export declare const rowProps: () => {
+    gutter: {
+        default: string | boolean;
+        type: PropType<string | boolean>;
+    };
+    height: StringConstructor;
+};
+export type RowProps = Partial<ExtractPropTypes<ReturnType<typeof rowProps>>>;
+declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
+    gutter: {
+        default: string | boolean;
+        type: PropType<string | boolean>;
+    };
+    height: StringConstructor;
+}>, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ExtractPropTypes<{
+    gutter: {
+        default: string | boolean;
+        type: PropType<string | boolean>;
+    };
+    height: StringConstructor;
+}>> & Readonly<{}>, {
+    gutter: string | boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/Flex/index.d.ts

@@ -0,0 +1,10 @@
+import type { Plugin } from 'vue';
+import Row from './Row';
+import Col from './Col';
+import Item from './Item';
+export declare const Rowflex: typeof Row & Plugin;
+export declare const Colflex: typeof Col & Plugin;
+export declare const Flexitem: typeof Item & Plugin;
+export type { RowProps as RowflexProps } from './Row';
+export type { ColProps as ColflexProps } from './Col';
+export type { ItemProps as FlexitemProps } from './Item';

package/dist/components/Flex/index.js

@@ -0,0 +1,151 @@
+import { defineComponent, computed, createVNode } from 'vue';
+import classNames from '../_util/classNames.js';
+import OrionError from '../../error/OrionError.js';
+import { anyType, booleanType } from '../_util/type.js';
+import '../_util/util.js';
+
+const rowProps = () => ({
+  gutter: anyType(),
+  height: String
+});
+var Row = defineComponent({
+  name: 'ORowflex',
+  inheritAttrs: false,
+  props: rowProps(),
+  setup(props, {
+    slots,
+    attrs,
+    emit,
+    expose
+  }) {
+    const style = computed(() => {
+      const rowStyle = {};
+      rowStyle.gap = props.gutter === true || props.gutter === '' ? `var(--orion-flex-gutter)` : props.gutter ? props.gutter : undefined;
+      if (props.height) {
+        if (props.height == 'fill') {
+          throw new OrionError(`ORowflex的height无法配置为['fill'],可以设置的值如['need', '100%', '200px']，请检查!`);
+        } else if (props.height == 'need') ; else {
+          rowStyle.height = props.height;
+        }
+      } else {
+        rowStyle.height = '100%';
+      }
+      return rowStyle;
+    });
+    return () => {
+      const children = slots.default?.();
+      const cn = classNames('orion-flex', 'orion-flex-row', 'orion-flex-justify-start');
+      return createVNode("div", {
+        "class": [cn, attrs.class],
+        "style": [style.value, attrs.style]
+      }, [children]);
+    };
+  }
+});
+
+const colProps = () => ({
+  gutter: anyType(),
+  height: String
+});
+var Col = defineComponent({
+  name: 'OColflex',
+  inheritAttrs: false,
+  props: colProps(),
+  setup(props, {
+    slots,
+    attrs,
+    emit,
+    expose
+  }) {
+    const style = computed(() => {
+      const rowStyle = {};
+      rowStyle.gap = props.gutter === true || props.gutter === '' ? `var(--orion-flex-gutter)` : props.gutter ? props.gutter : undefined;
+      if (props.height) {
+        if (props.height == 'fill') {
+          throw new OrionError(`OColflex的height无法配置为['fill'],可以设置的值如['need', '100%', '200px']，请检查!`);
+        } else if (props.height == 'need') ; else {
+          rowStyle.height = props.height;
+        }
+      } else {
+        rowStyle.height = '100%';
+      }
+      return rowStyle;
+    });
+    return () => {
+      const children = slots.default?.();
+      const cn = classNames('orion-flex', 'orion-flex-column');
+      return createVNode("div", {
+        "class": [cn, attrs.class],
+        "style": [style.value, attrs.style]
+      }, [children]);
+    };
+  }
+});
+
+const itemProps = () => ({
+  flexBasic: String,
+  hidden: booleanType(false)
+});
+var Item = defineComponent({
+  name: 'OFlexitem',
+  inheritAttrs: false,
+  props: itemProps(),
+  setup(props, {
+    slots,
+    attrs,
+    emit,
+    expose
+  }) {
+    const style = computed(() => {
+      const itemStyle = {};
+      if (props.flexBasic !== 'need' && props.flexBasic !== 'fill') {
+        itemStyle['flex'] = `0 0 ${props.flexBasic}`;
+      }
+      return itemStyle;
+    });
+    const classes = computed(() => {
+      const {
+        hidden
+      } = props;
+      let flexClass = 'orion-flexitem-fill';
+      if (props.flexBasic) {
+        if (props.flexBasic == 'need') {
+          flexClass = 'orion-flexitem-auto';
+        } else if (props.flexBasic !== 'need' && props.flexBasic !== 'fill') {
+          flexClass = 'orion-flexitem-fixed';
+        }
+      }
+      return ['orion-flexitem', flexClass, {
+        [`orion-hidden`]: hidden
+      }];
+    });
+    return () => {
+      const children = slots.default?.();
+      return createVNode("div", {
+        "class": [classes.value, attrs.class],
+        "style": [style.value, attrs.style]
+      }, [children]);
+    };
+  }
+});
+
+Row.install = function (app) {
+  // @ts-ignore
+  app.component(Row.name, Row);
+  return app;
+};
+Col.install = function (app) {
+  // @ts-ignore
+  app.component(Col.name, Col);
+  return app;
+};
+Item.install = function (app) {
+  // @ts-ignore
+  app.component(Item.name, Item);
+  return app;
+};
+const Rowflex = Row;
+const Colflex = Col;
+const Flexitem = Item;
+
+export { Colflex, Flexitem, Rowflex };

package/dist/components/Modal/Modal.d.ts

@@ -0,0 +1,2 @@
+declare const OModal: import("vue").DefineComponent<{}, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default OModal;

package/dist/components/Space/index.d.ts

@@ -0,0 +1,76 @@
+import type { PropType, ExtractPropTypes, Plugin } from 'vue';
+import type { CustomSlotsType } from '../_util/type';
+export declare const spaceProps: () => {
+    gutter: {
+        default: string | boolean;
+        type: PropType<string | boolean>;
+    };
+    vertical: {
+        default: string | boolean;
+        type: PropType<string | boolean>;
+    };
+};
+export type SpaceProps = Partial<ExtractPropTypes<ReturnType<typeof spaceProps>>>;
+declare const _default: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<{
+        gutter: {
+            default: string | boolean;
+            type: PropType<string | boolean>;
+        };
+        vertical: {
+            default: string | boolean;
+            type: PropType<string | boolean>;
+        };
+    }>> & Readonly<{}>, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<ExtractPropTypes<{
+        gutter: {
+            default: string | boolean;
+            type: PropType<string | boolean>;
+        };
+        vertical: {
+            default: string | boolean;
+            type: PropType<string | boolean>;
+        };
+    }>> & Readonly<{}>, {
+        gutter: string | boolean;
+        vertical: string | boolean;
+    }, true, {}, CustomSlotsType<{
+        default?: any;
+    }>, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<ExtractPropTypes<{
+        gutter: {
+            default: string | boolean;
+            type: PropType<string | boolean>;
+        };
+        vertical: {
+            default: string | boolean;
+            type: PropType<string | boolean>;
+        };
+    }>> & Readonly<{}>, () => any, {}, {}, {}, {
+        gutter: string | boolean;
+        vertical: string | boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<ExtractPropTypes<{
+    gutter: {
+        default: string | boolean;
+        type: PropType<string | boolean>;
+    };
+    vertical: {
+        default: string | boolean;
+        type: PropType<string | boolean>;
+    };
+}>> & Readonly<{}>, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    gutter: string | boolean;
+    vertical: string | boolean;
+}, {}, string, CustomSlotsType<{
+    default?: any;
+}>, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Plugin;
+export default _default;

package/dist/components/_util/classNames.d.ts

@@ -0,0 +1,2 @@
+declare function classNames(...args: any[]): string;
+export default classNames;

package/dist/components/_util/classNames.js

@@ -0,0 +1,31 @@
+import { isString, isArray, isObject } from './util.js';
+
+function classNames(...args) {
+  const classes = [];
+  for (let i = 0; i < args.length; i++) {
+    const value = args[i];
+    if (!value) continue;
+    if (isString(value)) {
+      // @ts-ignore
+      classes.push(value);
+    } else if (isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        const inner = classNames(value[i]);
+        if (inner) {
+          // @ts-ignore
+          classes.push(inner);
+        }
+      }
+    } else if (isObject(value)) {
+      for (const name in value) {
+        if (value[name]) {
+          // @ts-ignore
+          classes.push(name);
+        }
+      }
+    }
+  }
+  return classes.join(' ');
+}
+
+export { classNames as default };

package/dist/components/_util/isValid.d.ts

@@ -0,0 +1,2 @@
+declare const isValid: (value: any) => boolean;
+export default isValid;

package/dist/components/_util/isValid.js

@@ -0,0 +1,5 @@
+const isValid = value => {
+  return value !== undefined && value !== null && value !== '';
+};
+
+export { isValid as default };

package/dist/components/_util/props-util/index.d.ts

@@ -0,0 +1,6 @@
+import initDefaultProps from './initDefaultProps';
+export declare const skipFlattenKey: unique symbol;
+export declare const flattenChildren: (children?: any[], filterEmpty?: boolean) => any[];
+export declare function filterEmpty(children?: any[]): any[];
+export declare function isEmptyElement(c: any): boolean;
+export { initDefaultProps };

package/dist/components/_util/props-util/index.js

@@ -0,0 +1,53 @@
+import { Fragment, isVNode, Comment, Text } from 'vue';
+import isValid from '../isValid.js';
+export { default as initDefaultProps } from './initDefaultProps.js';
+
+const skipFlattenKey = Symbol('skipFlatten');
+const flattenChildren = (children = [], filterEmpty = true) => {
+  const temp = Array.isArray(children) ? children : [children];
+  const res = [];
+  temp.forEach(child => {
+    if (Array.isArray(child)) {
+      res.push(...flattenChildren(child, filterEmpty));
+      // @ts-ignore
+    } else if (child && child.type === Fragment) {
+      // @ts-ignore
+      if (child.key === skipFlattenKey) {
+        res.push(child);
+      } else {
+        // @ts-ignore
+        res.push(...flattenChildren(child.children, filterEmpty));
+      }
+    } else if (child && isVNode(child)) {
+      if (filterEmpty && !isEmptyElement(child)) {
+        res.push(child);
+      } else if (!filterEmpty) {
+        res.push(child);
+      }
+    } else if (isValid(child)) {
+      res.push(child);
+    }
+  });
+  return res;
+};
+function filterEmpty(children = []) {
+  const res = [];
+  children.forEach(child => {
+    if (Array.isArray(child)) {
+      // @ts-ignore
+      res.push(...child);
+      // @ts-ignore
+    } else if (child?.type === Fragment) {
+      // @ts-ignore
+      res.push(...filterEmpty(child.children));
+    } else {
+      res.push(child);
+    }
+  });
+  return res.filter(c => !isEmptyElement(c));
+}
+function isEmptyElement(c) {
+  return c && (c.type === Comment || c.type === Fragment && c.children.length === 0 || c.type === Text && c.children.trim() === '');
+}
+
+export { filterEmpty, flattenChildren, isEmptyElement, skipFlattenKey };

package/dist/components/_util/props-util/initDefaultProps.d.ts

@@ -0,0 +1,6 @@
+import type { PropType } from 'vue';
+import type { VueTypeValidableDef, VueTypeDef } from 'vue-types';
+declare const initDefaultProps: <T>(types: T, defaultProps: { [K in keyof T]?: T[K] extends VueTypeValidableDef<infer U> ? U : T[K] extends VueTypeDef<infer U> ? U : T[K] extends {
+    type: PropType<infer U>;
+} ? U : any; }) => T;
+export default initDefaultProps;

package/dist/components/_util/props-util/initDefaultProps.js

@@ -0,0 +1,25 @@
+const initDefaultProps = (types, defaultProps) => {
+  const propTypes = {
+    ...types
+  };
+  Object.keys(defaultProps).forEach(k => {
+    const prop = propTypes[k];
+    if (prop) {
+      if (prop.type || prop.default) {
+        prop.default = defaultProps[k];
+      } else if (prop.def) {
+        prop.def(defaultProps[k]);
+      } else {
+        propTypes[k] = {
+          type: prop,
+          default: defaultProps[k]
+        };
+      }
+    } else {
+      throw new Error(`not have ${k} prop`);
+    }
+  });
+  return propTypes;
+};
+
+export { initDefaultProps as default };

package/dist/components/_util/type.d.ts

@@ -0,0 +1,62 @@
+import type { PropType, Plugin, Ref, VNode, SlotsType } from 'vue';
+export declare const tuple: <T extends string[]>(...args: T) => T;
+export declare const tupleNum: <T extends number[]>(...args: T) => T;
+/**
+ * https://stackoverflow.com/a/59187769
+ * Extract the type of an element of an array/tuple without performing indexing
+ */
+export type ElementOf<T> = T extends (infer E)[] ? E : T extends readonly (infer F)[] ? F : never;
+/**
+ * https://github.com/Microsoft/TypeScript/issues/29729
+ */
+export type LiteralUnion<T extends string> = T | (string & {});
+export type Data = Record<string, unknown>;
+export type Key = string | number;
+type DefaultFactory<T> = (props: Data) => T | null | undefined;
+export interface PropOptions<T = any, D = T> {
+    type?: PropType<T> | true | null;
+    required?: boolean;
+    default?: D | DefaultFactory<D> | null | undefined | object;
+    validator?(value: unknown): boolean;
+}
+declare type VNodeChildAtom = VNode | string | number | boolean | null | undefined | void;
+export type VueNode = VNodeChildAtom | VNodeChildAtom[] | VNode;
+export declare const withInstall: <T>(comp: T) => T & Plugin;
+export type MaybeRef<T> = T | Ref<T>;
+export declare function eventType<T>(): {
+    type: PropType<T | T[]>;
+};
+export declare function objectType<T = {}>(defaultVal?: T): {
+    type: PropType<T>;
+    default: T;
+};
+export declare function booleanType(defaultVal?: boolean): {
+    type: BooleanConstructor;
+    default: boolean;
+};
+export declare function functionType<T = () => {}>(defaultVal?: T): {
+    type: PropType<T>;
+    default: T;
+};
+export declare function anyType<T = any>(defaultVal?: T, required?: boolean): {
+    default: T;
+    type: PropType<T>;
+};
+export declare function vNodeType<T = VueNode>(): {
+    type: PropType<T>;
+};
+export declare function arrayType<T extends any[]>(defaultVal?: T): {
+    type: PropType<T>;
+    default: T;
+};
+export declare function stringType<T extends string = string>(defaultVal?: T): {
+    type: PropType<T>;
+    default: T;
+};
+export declare function someType<T>(types?: any[], defaultVal?: T): {
+    type: PropType<T>;
+    default: T;
+};
+export type CustomSlotsType<T> = SlotsType<T>;
+export type AnyObject = Record<PropertyKey, any>;
+export {};

package/dist/components/_util/type.js

@@ -0,0 +1,66 @@
+// https://stackoverflow.com/questions/46176165/ways-to-get-string-literal-type-of-array-values-without-enum-overhead
+const tuple = (...args) => args;
+const tupleNum = (...args) => args;
+const withInstall = comp => {
+  const c = comp;
+  c.install = function (app) {
+    // @ts-ignore
+    app.component(c.displayName || c.name, comp);
+  };
+  return comp;
+};
+function eventType() {
+  return {
+    type: [Function, Array]
+  };
+}
+function objectType(defaultVal) {
+  return {
+    type: Object,
+    default: defaultVal
+  };
+}
+function booleanType(defaultVal) {
+  return {
+    type: Boolean,
+    default: defaultVal
+  };
+}
+function functionType(defaultVal) {
+  return {
+    type: Function,
+    default: defaultVal
+  };
+}
+function anyType(defaultVal, required) {
+  const type = {
+    validator: () => true,
+    default: defaultVal
+  };
+  return required ? type : type;
+}
+function vNodeType() {
+  return {
+    validator: () => true
+  };
+}
+function arrayType(defaultVal) {
+  return {
+    type: Array,
+    default: defaultVal
+  };
+}
+function stringType(defaultVal) {
+  return {
+    type: String,
+    default: defaultVal
+  };
+}
+function someType(types, defaultVal) {
+  return types ? {
+    type: types,
+    default: defaultVal
+  } : anyType(defaultVal);
+}
+
+export { anyType, arrayType, booleanType, eventType, functionType, objectType, someType, stringType, tuple, tupleNum, vNodeType, withInstall };

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

@@ -0,0 +1,18 @@
+import type { VueNode } from './type';
+export declare const isFunction: (val: any) => boolean;
+export declare const controlDefaultValue: any;
+export declare const isArray: (arg: any) => arg is any[];
+export declare const isString: (val: any) => val is string;
+export declare const isSymbol: (val: any) => val is symbol;
+export declare const isObject: (val: any) => boolean;
+declare const isOn: (key: any) => boolean;
+declare const cacheStringFunction: (fn: any) => (str: any) => any;
+declare const camelize: (str: any) => any;
+declare const hyphenate: (str: any) => any;
+declare const capitalize: (str: any) => any;
+declare function resolvePropValue(options: any, props: any, key: any, value: any): any;
+export declare function getDataAndAriaProps(props: any): {};
+export declare function toPx(val: any): any;
+export declare function renderHelper<T = Record<string, any>>(v: VueNode | ((arg0: T) => VueNode), props?: T, defaultV?: any): any;
+export declare function wrapPromiseFn(openFn: (resolve: VoidFunction) => VoidFunction): any;
+export { isOn, cacheStringFunction, camelize, hyphenate, capitalize, resolvePropValue };