orion-design 0.1.1 → 0.1.2

package/dist/components/_util/util.js

@@ -0,0 +1,83 @@
+const isFunction = val => typeof val === 'function';
+const controlDefaultValue = Symbol('controlDefaultValue');
+const isArray = Array.isArray;
+const isString = val => typeof val === 'string';
+const isSymbol = val => typeof val === 'symbol';
+const isObject = val => val !== null && typeof val === 'object';
+const onRE = /^on[^a-z]/;
+const isOn = key => onRE.test(key);
+const cacheStringFunction = fn => {
+  const cache = Object.create(null);
+  return str => {
+    const hit = cache[str];
+    return hit || (cache[str] = fn(str));
+  };
+};
+const camelizeRE = /-(\w)/g;
+const camelize = cacheStringFunction(str => {
+  return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : '');
+});
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cacheStringFunction(str => {
+  return str.replace(hyphenateRE, '-$1').toLowerCase();
+});
+const capitalize = cacheStringFunction(str => {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+});
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const hasOwn = (val, key) => hasOwnProperty.call(val, key);
+// change from vue sourcecode
+function resolvePropValue(options, props, key, value) {
+  const opt = options[key];
+  if (opt != null) {
+    const hasDefault = hasOwn(opt, 'default');
+    // default values
+    if (hasDefault && value === undefined) {
+      const defaultValue = opt.default;
+      value = opt.type !== Function && isFunction(defaultValue) ? defaultValue() : defaultValue;
+    }
+    // boolean casting
+    if (opt.type === Boolean) {
+      if (!hasOwn(props, key) && !hasDefault) {
+        value = false;
+      } else if (value === '') {
+        value = true;
+      }
+    }
+  }
+  return value;
+}
+function getDataAndAriaProps(props) {
+  return Object.keys(props).reduce((memo, key) => {
+    if (key.startsWith('data-') || key.startsWith('aria-')) {
+      memo[key] = props[key];
+    }
+    return memo;
+  }, {});
+}
+function toPx(val) {
+  if (typeof val === 'number') return `${val}px`;
+  return val;
+}
+function renderHelper(v, props = {}, defaultV) {
+  if (typeof v === 'function') {
+    return v(props);
+  }
+  return v ?? defaultV;
+}
+function wrapPromiseFn(openFn) {
+  let closeFn;
+  const closePromise = new Promise(resolve => {
+    closeFn = openFn(() => {
+      resolve(true);
+    });
+  });
+  const result = () => {
+    closeFn?.();
+  };
+  result.then = (filled, rejected) => closePromise.then(filled, rejected);
+  result.promise = closePromise;
+  return result;
+}
+
+export { cacheStringFunction, camelize, capitalize, controlDefaultValue, getDataAndAriaProps, hyphenate, isArray, isFunction, isObject, isOn, isString, isSymbol, renderHelper, resolvePropValue, toPx, wrapPromiseFn };

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

@@ -0,0 +1,12 @@
+import type { CSSProperties } from 'vue';
+import type { VueTypeValidableDef, VueTypesInterface } from 'vue-types';
+import type { VueNode } from '../type';
+export declare function withUndefined<T extends {
+    default?: any;
+}>(type: T): T;
+declare const _default: VueTypesInterface & {
+    readonly looseBool: VueTypeValidableDef<boolean>;
+    readonly style: VueTypeValidableDef<CSSProperties>;
+    readonly VueNode: VueTypeValidableDef<VueNode>;
+};
+export default _default;

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

@@ -0,0 +1,473 @@
+/*!
+ * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+function isObject(o) {
+  return Object.prototype.toString.call(o) === '[object Object]';
+}
+
+function isPlainObject(o) {
+  var ctor,prot;
+
+  if (isObject(o) === false) return false;
+
+  // If has modified constructor
+  ctor = o.constructor;
+  if (ctor === undefined) return true;
+
+  // If has modified prototype
+  prot = ctor.prototype;
+  if (isObject(prot) === false) return false;
+
+  // If constructor does not have an Object-specific method
+  if (prot.hasOwnProperty('isPrototypeOf') === false) {
+    return false;
+  }
+
+  // Most likely a plain Object
+  return true;
+}
+
+function t() {
+  return t = Object.assign ? Object.assign.bind() : function (e) {
+    for (var t = 1; t < arguments.length; t++) {
+      var n = arguments[t];
+      for (var r in n) Object.prototype.hasOwnProperty.call(n, r) && (e[r] = n[r]);
+    }
+    return e;
+  }, t.apply(this, arguments);
+}
+function n(e, t) {
+  if (null == e) return {};
+  var n = {};
+  for (var r in e) if (Object.prototype.hasOwnProperty.call(e, r)) {
+    if (t.indexOf(r) >= 0) continue;
+    n[r] = e[r];
+  }
+  return n;
+}
+const r = {
+    silent: !1,
+    logLevel: "warn"
+  },
+  i = ["validator"],
+  o = Object.prototype,
+  a = o.toString,
+  s = o.hasOwnProperty,
+  u = /^\s*function (\w+)/;
+function l(e) {
+  var t;
+  const n = null !== (t = null == e ? void 0 : e.type) && void 0 !== t ? t : e;
+  if (n) {
+    const e = n.toString().match(u);
+    return e ? e[1] : "";
+  }
+  return "";
+}
+const c = isPlainObject;
+function f() {}
+let d = f;
+if ("production" !== process.env.NODE_ENV) {
+  const e = "undefined" != typeof console;
+  d = e ? function (e, t = r.logLevel) {
+    !1 === r.silent && console[t](`[VueTypes warn]: ${e}`);
+  } : f;
+}
+const p = (e, t) => s.call(e, t),
+  y = Number.isInteger || function (e) {
+    return "number" == typeof e && isFinite(e) && Math.floor(e) === e;
+  },
+  v = Array.isArray || function (e) {
+    return "[object Array]" === a.call(e);
+  },
+  h = e => "[object Function]" === a.call(e),
+  b = (e, t) => c(e) && p(e, "_vueTypes_name") && (!t || e._vueTypes_name === t),
+  g = e => c(e) && (p(e, "type") || ["_vueTypes_name", "validator", "default", "required"].some(t => p(e, t)));
+function O(e, t) {
+  return Object.defineProperty(e.bind(t), "__original", {
+    value: e
+  });
+}
+function m(e, t, n = !1) {
+  let r,
+    i = !0,
+    o = "";
+  r = c(e) ? e : {
+    type: e
+  };
+  const a = b(r) ? r._vueTypes_name + " - " : "";
+  if (g(r) && null !== r.type) {
+    if (void 0 === r.type || !0 === r.type) return i;
+    if (!r.required && null == t) return i;
+    v(r.type) ? (i = r.type.some(e => !0 === m(e, t, !0)), o = r.type.map(e => l(e)).join(" or ")) : (o = l(r), i = "Array" === o ? v(t) : "Object" === o ? c(t) : "String" === o || "Number" === o || "Boolean" === o || "Function" === o ? function (e) {
+      if (null == e) return "";
+      const t = e.constructor.toString().match(u);
+      return t ? t[1].replace(/^Async/, "") : "";
+    }(t) === o : t instanceof r.type);
+  }
+  if (!i) {
+    const e = `${a}value "${t}" should be of type "${o}"`;
+    return !1 === n ? (d(e), !1) : e;
+  }
+  if (p(r, "validator") && h(r.validator)) {
+    const e = d,
+      o = [];
+    if (d = e => {
+      o.push(e);
+    }, i = r.validator(t), d = e, !i) {
+      const e = (o.length > 1 ? "* " : "") + o.join("\n* ");
+      return o.length = 0, !1 === n ? (d(e), i) : e;
+    }
+  }
+  return i;
+}
+function j(e, t) {
+  const n = Object.defineProperties(t, {
+      _vueTypes_name: {
+        value: e,
+        writable: !0
+      },
+      isRequired: {
+        get() {
+          return this.required = !0, this;
+        }
+      },
+      def: {
+        value(e) {
+          return void 0 === e ? this.type === Boolean || Array.isArray(this.type) && this.type.includes(Boolean) ? void (this.default = void 0) : (p(this, "default") && delete this.default, this) : h(e) || !0 === m(this, e, !0) ? (this.default = v(e) ? () => [...e] : c(e) ? () => Object.assign({}, e) : e, this) : (d(`${this._vueTypes_name} - invalid default value: "${e}"`), this);
+        }
+      }
+    }),
+    {
+      validator: r
+    } = n;
+  return h(r) && (n.validator = O(r, n)), n;
+}
+function _(e, t) {
+  const n = j(e, t);
+  return Object.defineProperty(n, "validate", {
+    value(e) {
+      return h(this.validator) && d(`${this._vueTypes_name} - calling .validate() will overwrite the current custom validator function. Validator info:\n${JSON.stringify(this)}`), this.validator = O(e, this), this;
+    }
+  });
+}
+function T(e, t, r) {
+  const o = function (e) {
+    const t = {};
+    return Object.getOwnPropertyNames(e).forEach(n => {
+      t[n] = Object.getOwnPropertyDescriptor(e, n);
+    }), Object.defineProperties({}, t);
+  }(t);
+  if (o._vueTypes_name = e, !c(r)) return o;
+  const {
+      validator: a
+    } = r,
+    s = n(r, i);
+  if (h(a)) {
+    let {
+      validator: e
+    } = o;
+    e && (e = null !== (l = (u = e).__original) && void 0 !== l ? l : u), o.validator = O(e ? function (t) {
+      return e.call(this, t) && a.call(this, t);
+    } : a, o);
+  }
+  var u, l;
+  return Object.assign(o, s);
+}
+function $(e) {
+  return e.replace(/^(?!\s*$)/gm, "  ");
+}
+const w = () => _("any", {}),
+  x = () => _("function", {
+    type: Function
+  }),
+  P = () => _("boolean", {
+    type: Boolean
+  }),
+  A = () => _("string", {
+    type: String
+  }),
+  E = () => _("number", {
+    type: Number
+  }),
+  S = () => _("array", {
+    type: Array
+  }),
+  N = () => _("object", {
+    type: Object
+  }),
+  V = () => j("integer", {
+    type: Number,
+    validator(e) {
+      const t = y(e);
+      return !1 === t && d(`integer - "${e}" is not an integer`), t;
+    }
+  }),
+  q = () => j("symbol", {
+    validator(e) {
+      const t = "symbol" == typeof e;
+      return !1 === t && d(`symbol - invalid value "${e}"`), t;
+    }
+  }),
+  k = () => Object.defineProperty({
+    type: null,
+    validator(e) {
+      const t = null === e;
+      return !1 === t && d("nullable - value should be null"), t;
+    }
+  }, "_vueTypes_name", {
+    value: "nullable"
+  });
+function D(e, t = "custom validation failed") {
+  if ("function" != typeof e) throw new TypeError("[VueTypes error]: You must provide a function as argument");
+  return j(e.name || "<<anonymous function>>", {
+    type: null,
+    validator(n) {
+      const r = e(n);
+      return r || d(`${this._vueTypes_name} - ${t}`), r;
+    }
+  });
+}
+function L(e) {
+  if (!v(e)) throw new TypeError("[VueTypes error]: You must provide an array as argument.");
+  const t = `oneOf - value should be one of "${e.map(e => "symbol" == typeof e ? e.toString() : e).join('", "')}".`,
+    n = {
+      validator(n) {
+        const r = -1 !== e.indexOf(n);
+        return r || d(t), r;
+      }
+    };
+  if (-1 === e.indexOf(null)) {
+    const t = e.reduce((e, t) => {
+      if (null != t) {
+        const n = t.constructor;
+        -1 === e.indexOf(n) && e.push(n);
+      }
+      return e;
+    }, []);
+    t.length > 0 && (n.type = t);
+  }
+  return j("oneOf", n);
+}
+function B(e) {
+  if (!v(e)) throw new TypeError("[VueTypes error]: You must provide an array as argument");
+  let t = !1,
+    n = !1,
+    r = [];
+  for (let i = 0; i < e.length; i += 1) {
+    const o = e[i];
+    if (g(o)) {
+      if (h(o.validator) && (t = !0), b(o, "oneOf") && o.type) {
+        r = r.concat(o.type);
+        continue;
+      }
+      if (b(o, "nullable")) {
+        n = !0;
+        continue;
+      }
+      if (!0 === o.type || !o.type) {
+        d('oneOfType - invalid usage of "true" and "null" as types.');
+        continue;
+      }
+      r = r.concat(o.type);
+    } else r.push(o);
+  }
+  r = r.filter((e, t) => r.indexOf(e) === t);
+  const i = !1 === n && r.length > 0 ? r : null;
+  return j("oneOfType", t ? {
+    type: i,
+    validator(t) {
+      const n = [],
+        r = e.some(e => {
+          const r = m(e, t, !0);
+          return "string" == typeof r && n.push(r), !0 === r;
+        });
+      return r || d(`oneOfType - provided value does not match any of the ${n.length} passed-in validators:\n${$(n.join("\n"))}`), r;
+    }
+  } : {
+    type: i
+  });
+}
+function F(e) {
+  return j("arrayOf", {
+    type: Array,
+    validator(t) {
+      let n = "";
+      const r = t.every(t => (n = m(e, t, !0), !0 === n));
+      return r || d(`arrayOf - value validation error:\n${$(n)}`), r;
+    }
+  });
+}
+function Y(e) {
+  return j("instanceOf", {
+    type: e
+  });
+}
+function I(e) {
+  return j("objectOf", {
+    type: Object,
+    validator(t) {
+      let n = "";
+      const r = Object.keys(t).every(r => (n = m(e, t[r], !0), !0 === n));
+      return r || d(`objectOf - value validation error:\n${$(n)}`), r;
+    }
+  });
+}
+function J(e) {
+  const t = Object.keys(e),
+    n = t.filter(t => {
+      var n;
+      return !(null === (n = e[t]) || void 0 === n || !n.required);
+    }),
+    r = j("shape", {
+      type: Object,
+      validator(r) {
+        if (!c(r)) return !1;
+        const i = Object.keys(r);
+        if (n.length > 0 && n.some(e => -1 === i.indexOf(e))) {
+          const e = n.filter(e => -1 === i.indexOf(e));
+          return d(1 === e.length ? `shape - required property "${e[0]}" is not defined.` : `shape - required properties "${e.join('", "')}" are not defined.`), !1;
+        }
+        return i.every(n => {
+          if (-1 === t.indexOf(n)) return !0 === this._vueTypes_isLoose || (d(`shape - shape definition does not include a "${n}" property. Allowed keys: "${t.join('", "')}".`), !1);
+          const i = m(e[n], r[n], !0);
+          return "string" == typeof i && d(`shape - "${n}" property validation error:\n ${$(i)}`), !0 === i;
+        });
+      }
+    });
+  return Object.defineProperty(r, "_vueTypes_isLoose", {
+    writable: !0,
+    value: !1
+  }), Object.defineProperty(r, "loose", {
+    get() {
+      return this._vueTypes_isLoose = !0, this;
+    }
+  }), r;
+}
+const M = ["name", "validate", "getter"],
+  R = /*#__PURE__*/(e => ((e = class {
+    static get any() {
+      return w();
+    }
+    static get func() {
+      return x().def(this.defaults.func);
+    }
+    static get bool() {
+      return void 0 === this.defaults.bool ? P() : P().def(this.defaults.bool);
+    }
+    static get string() {
+      return A().def(this.defaults.string);
+    }
+    static get number() {
+      return E().def(this.defaults.number);
+    }
+    static get array() {
+      return S().def(this.defaults.array);
+    }
+    static get object() {
+      return N().def(this.defaults.object);
+    }
+    static get integer() {
+      return V().def(this.defaults.integer);
+    }
+    static get symbol() {
+      return q();
+    }
+    static get nullable() {
+      return k();
+    }
+    static extend(e) {
+      if (d("VueTypes.extend is deprecated. Use the ES6+ method instead. See https://dwightjack.github.io/vue-types/advanced/extending-vue-types.html#extending-namespaced-validators-in-es6 for details."), v(e)) return e.forEach(e => this.extend(e)), this;
+      const {
+          name: t,
+          validate: r = !1,
+          getter: i = !1
+        } = e,
+        o = n(e, M);
+      if (p(this, t)) throw new TypeError(`[VueTypes error]: Type "${t}" already defined`);
+      const {
+        type: a
+      } = o;
+      if (b(a)) return delete o.type, Object.defineProperty(this, t, i ? {
+        get: () => T(t, a, o)
+      } : {
+        value(...e) {
+          const n = T(t, a, o);
+          return n.validator && (n.validator = n.validator.bind(n, ...e)), n;
+        }
+      });
+      let s;
+      return s = i ? {
+        get() {
+          const e = Object.assign({}, o);
+          return r ? _(t, e) : j(t, e);
+        },
+        enumerable: !0
+      } : {
+        value(...e) {
+          const n = Object.assign({}, o);
+          let i;
+          return i = r ? _(t, n) : j(t, n), n.validator && (i.validator = n.validator.bind(i, ...e)), i;
+        },
+        enumerable: !0
+      }, Object.defineProperty(this, t, s);
+    }
+  }).defaults = {}, e.sensibleDefaults = void 0, e.config = r, e.custom = D, e.oneOf = L, e.instanceOf = Y, e.oneOfType = B, e.arrayOf = F, e.objectOf = I, e.shape = J, e.utils = {
+    validate: (e, t) => !0 === m(t, e, !0),
+    toType: (e, t, n = !1) => n ? _(e, t) : j(e, t)
+  }, e))();
+function U(e = {
+  func: () => {},
+  bool: !0,
+  string: "",
+  number: 0,
+  array: () => [],
+  object: () => ({}),
+  integer: 0
+}) {
+  var n;
+  return (n = class extends R {
+    static get sensibleDefaults() {
+      return t({}, this.defaults);
+    }
+    static set sensibleDefaults(n) {
+      this.defaults = !1 !== n ? t({}, !0 !== n ? n : e) : {};
+    }
+  }).defaults = t({}, e), n;
+}
+class z extends U() {}
+
+const PropTypes = U({
+  func: undefined,
+  bool: undefined,
+  string: undefined,
+  number: undefined,
+  array: undefined,
+  object: undefined,
+  integer: undefined
+});
+PropTypes.extend([{
+  name: 'looseBool',
+  getter: true,
+  type: Boolean,
+  default: undefined
+}, {
+  name: 'style',
+  getter: true,
+  type: [String, Object],
+  default: undefined
+}, {
+  name: 'VueNode',
+  getter: true,
+  // @ts-ignore
+  type: null
+}]);
+function withUndefined(type) {
+  type.default = undefined;
+  return type;
+}
+
+export { PropTypes as default, withUndefined };

package/dist/components/components.d.ts

@@ -0,0 +1,4 @@
+export { default as Space } from './Space';
+export type { SpaceProps } from './Space';
+export { Rowflex, Colflex, Flexitem } from './Flex';
+export type { RowflexProps, ColflexProps, FlexitemProps } from './Flex';

package/dist/components/components.js

@@ -0,0 +1,10 @@
+export { i as Space } from '../components-O4L3qYfM.js';
+export { Colflex, Flexitem, Rowflex } from './Flex/index.js';
+import 'vue';
+import './_util/props-util/index.js';
+import './_util/isValid.js';
+import './_util/props-util/initDefaultProps.js';
+import './_util/type.js';
+import './_util/classNames.js';
+import './_util/util.js';
+import '../error/OrionError.js';

package/dist/components/index.d.ts

@@ -0,0 +1,3 @@
+import type { App } from 'vue';
+export * from './components';
+export declare const install: (app: App) => App<any>;

package/dist/components/index.js

@@ -0,0 +1,23 @@
+import { c as components } from '../components-O4L3qYfM.js';
+export { i as Space } from '../components-O4L3qYfM.js';
+export { Colflex, Flexitem, Rowflex } from './Flex/index.js';
+import 'vue';
+import './_util/props-util/index.js';
+import './_util/isValid.js';
+import './_util/props-util/initDefaultProps.js';
+import './_util/type.js';
+import './_util/classNames.js';
+import './_util/util.js';
+import '../error/OrionError.js';
+
+const install = function (app) {
+  Object.keys(components).forEach(key => {
+    const component = components[key];
+    if (component.install) {
+      app.use(component);
+    }
+  });
+  return app;
+};
+
+export { install };

package/dist/components-O4L3qYfM.js

@@ -0,0 +1,61 @@
+import { defineComponent, computed, createVNode } from 'vue';
+import { filterEmpty } from './components/_util/props-util/index.js';
+import { withInstall, anyType } from './components/_util/type.js';
+import { Colflex, Flexitem, Rowflex } from './components/Flex/index.js';
+
+const spaceProps = () => ({
+  gutter: anyType(),
+  vertical: anyType()
+});
+const Space = defineComponent({
+  name: 'OSpace',
+  inheritAttrs: false,
+  props: spaceProps(),
+  slots: Object,
+  setup(props, {
+    slots,
+    attrs,
+    emit,
+    expose
+  }) {
+    const classes = computed(() => {
+      const {
+        vertical
+      } = props;
+      return ['orion-space', {
+        [`vertical`]: vertical === true || vertical === ''
+      }];
+    });
+    return () => {
+      const children = slots.default?.();
+      const items = filterEmpty(children);
+      const len = items.length;
+      if (len === 0) {
+        return null;
+      }
+      const gapStyle = {};
+      if (typeof props.gutter == 'string' && props.gutter) {
+        gapStyle.gap = props.gutter;
+      }
+      return createVNode("div", {
+        "class": [classes.value, attrs.class],
+        "style": [gapStyle, attrs.style]
+      }, [items.map(child => {
+        return createVNode("div", {
+          "class": ['orion-space-item']
+        }, [child]);
+      })]);
+    };
+  }
+});
+var index = withInstall(Space);
+
+var components = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Colflex: Colflex,
+  Flexitem: Flexitem,
+  Rowflex: Rowflex,
+  Space: index
+});
+
+export { components as c, index as i };

package/dist/error/OrionError.js

@@ -1,12 +1,14 @@
 class OrionError extends Error {
-    constructor(message, cause) {
-        super(message, { cause });
-        // Maintains proper stack trace for where our error was thrown (only available on V8)
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, OrionError);
-        }
-        this.name = 'OrionError';
+  constructor(message, cause) {
+    super(message, {
+      cause
+    });
+    // Maintains proper stack trace for where our error was thrown (only available on V8)
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, OrionError);
     }
+    this.name = 'OrionError';
+  }
 }
 
 export { OrionError as default };