@kg-ui/kg-ui-plus 0.0.1 → 0.0.2

package/dist/es/node_modules/.pnpm/@iconify_vue@4.0.0_vue@3.2.45/node_modules/@iconify/vue/dist/offline.mjs

@@ -0,0 +1,436 @@
+import { defineComponent, h } from "vue";
+const defaultIconDimensions = Object.freeze(
+  {
+    left: 0,
+    top: 0,
+    width: 16,
+    height: 16
+  }
+);
+const defaultIconTransformations = Object.freeze({
+  rotate: 0,
+  vFlip: false,
+  hFlip: false
+});
+const defaultIconProps = Object.freeze({
+  ...defaultIconDimensions,
+  ...defaultIconTransformations
+});
+Object.freeze({
+  ...defaultIconProps,
+  body: "",
+  hidden: false
+});
+({
+  provider: "",
+  aliases: {},
+  not_found: {},
+  ...defaultIconDimensions
+});
+const defaultIconSizeCustomisations = Object.freeze({
+  width: null,
+  height: null
+});
+const defaultIconCustomisations = Object.freeze({
+  ...defaultIconSizeCustomisations,
+  ...defaultIconTransformations
+});
+function mergeCustomisations(defaults, item) {
+  const result = {
+    ...defaults
+  };
+  for (const key in item) {
+    const value = item[key];
+    const valueType = typeof value;
+    if (key in defaultIconSizeCustomisations) {
+      if (value === null || value && (valueType === "string" || valueType === "number")) {
+        result[key] = value;
+      }
+    } else if (valueType === typeof result[key]) {
+      result[key] = key === "rotate" ? value % 4 : value;
+    }
+  }
+  return result;
+}
+const separator = /[\s,]+/;
+function flipFromString(custom, flip) {
+  flip.split(separator).forEach((str) => {
+    const value = str.trim();
+    switch (value) {
+      case "horizontal":
+        custom.hFlip = true;
+        break;
+      case "vertical":
+        custom.vFlip = true;
+        break;
+    }
+  });
+}
+function rotateFromString(value, defaultValue = 0) {
+  const units = value.replace(/^-?[0-9.]*/, "");
+  function cleanup(value2) {
+    while (value2 < 0) {
+      value2 += 4;
+    }
+    return value2 % 4;
+  }
+  if (units === "") {
+    const num = parseInt(value);
+    return isNaN(num) ? 0 : cleanup(num);
+  } else if (units !== value) {
+    let split = 0;
+    switch (units) {
+      case "%":
+        split = 25;
+        break;
+      case "deg":
+        split = 90;
+    }
+    if (split) {
+      let num = parseFloat(value.slice(0, value.length - units.length));
+      if (isNaN(num)) {
+        return 0;
+      }
+      num = num / split;
+      return num % 1 === 0 ? cleanup(num) : 0;
+    }
+  }
+  return defaultValue;
+}
+const unitsSplit = /(-?[0-9.]*[0-9]+[0-9.]*)/g;
+const unitsTest = /^-?[0-9.]*[0-9]+[0-9.]*$/g;
+function calculateSize(size, ratio, precision) {
+  if (ratio === 1) {
+    return size;
+  }
+  precision = precision || 100;
+  if (typeof size === "number") {
+    return Math.ceil(size * ratio * precision) / precision;
+  }
+  if (typeof size !== "string") {
+    return size;
+  }
+  const oldParts = size.split(unitsSplit);
+  if (oldParts === null || !oldParts.length) {
+    return size;
+  }
+  const newParts = [];
+  let code = oldParts.shift();
+  let isNumber = unitsTest.test(code);
+  while (true) {
+    if (isNumber) {
+      const num = parseFloat(code);
+      if (isNaN(num)) {
+        newParts.push(code);
+      } else {
+        newParts.push(Math.ceil(num * ratio * precision) / precision);
+      }
+    } else {
+      newParts.push(code);
+    }
+    code = oldParts.shift();
+    if (code === void 0) {
+      return newParts.join("");
+    }
+    isNumber = !isNumber;
+  }
+}
+function iconToSVG(icon, customisations) {
+  const fullIcon = {
+    ...defaultIconProps,
+    ...icon
+  };
+  const fullCustomisations = {
+    ...defaultIconCustomisations,
+    ...customisations
+  };
+  const box = {
+    left: fullIcon.left,
+    top: fullIcon.top,
+    width: fullIcon.width,
+    height: fullIcon.height
+  };
+  let body = fullIcon.body;
+  [fullIcon, fullCustomisations].forEach((props) => {
+    const transformations = [];
+    const hFlip = props.hFlip;
+    const vFlip = props.vFlip;
+    let rotation = props.rotate;
+    if (hFlip) {
+      if (vFlip) {
+        rotation += 2;
+      } else {
+        transformations.push(
+          "translate(" + (box.width + box.left).toString() + " " + (0 - box.top).toString() + ")"
+        );
+        transformations.push("scale(-1 1)");
+        box.top = box.left = 0;
+      }
+    } else if (vFlip) {
+      transformations.push(
+        "translate(" + (0 - box.left).toString() + " " + (box.height + box.top).toString() + ")"
+      );
+      transformations.push("scale(1 -1)");
+      box.top = box.left = 0;
+    }
+    let tempValue;
+    if (rotation < 0) {
+      rotation -= Math.floor(rotation / 4) * 4;
+    }
+    rotation = rotation % 4;
+    switch (rotation) {
+      case 1:
+        tempValue = box.height / 2 + box.top;
+        transformations.unshift(
+          "rotate(90 " + tempValue.toString() + " " + tempValue.toString() + ")"
+        );
+        break;
+      case 2:
+        transformations.unshift(
+          "rotate(180 " + (box.width / 2 + box.left).toString() + " " + (box.height / 2 + box.top).toString() + ")"
+        );
+        break;
+      case 3:
+        tempValue = box.width / 2 + box.left;
+        transformations.unshift(
+          "rotate(-90 " + tempValue.toString() + " " + tempValue.toString() + ")"
+        );
+        break;
+    }
+    if (rotation % 2 === 1) {
+      if (box.left !== box.top) {
+        tempValue = box.left;
+        box.left = box.top;
+        box.top = tempValue;
+      }
+      if (box.width !== box.height) {
+        tempValue = box.width;
+        box.width = box.height;
+        box.height = tempValue;
+      }
+    }
+    if (transformations.length) {
+      body = '<g transform="' + transformations.join(" ") + '">' + body + "</g>";
+    }
+  });
+  const customisationsWidth = fullCustomisations.width;
+  const customisationsHeight = fullCustomisations.height;
+  const boxWidth = box.width;
+  const boxHeight = box.height;
+  let width;
+  let height;
+  if (customisationsWidth === null) {
+    height = customisationsHeight === null ? "1em" : customisationsHeight === "auto" ? boxHeight : customisationsHeight;
+    width = calculateSize(height, boxWidth / boxHeight);
+  } else {
+    width = customisationsWidth === "auto" ? boxWidth : customisationsWidth;
+    height = customisationsHeight === null ? calculateSize(width, boxHeight / boxWidth) : customisationsHeight === "auto" ? boxHeight : customisationsHeight;
+  }
+  const result = {
+    attributes: {
+      width: width.toString(),
+      height: height.toString(),
+      viewBox: box.left.toString() + " " + box.top.toString() + " " + boxWidth.toString() + " " + boxHeight.toString()
+    },
+    body
+  };
+  return result;
+}
+const regex = /\sid="(\S+)"/g;
+const randomPrefix = "IconifyId" + Date.now().toString(16) + (Math.random() * 16777216 | 0).toString(16);
+let counter = 0;
+function replaceIDs(body, prefix = randomPrefix) {
+  const ids = [];
+  let match;
+  while (match = regex.exec(body)) {
+    ids.push(match[1]);
+  }
+  if (!ids.length) {
+    return body;
+  }
+  ids.forEach((id) => {
+    const newID = typeof prefix === "function" ? prefix(id) : prefix + (counter++).toString();
+    const escapedID = id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    body = body.replace(
+      new RegExp('([#;"])(' + escapedID + ')([")]|\\.[a-z])', "g"),
+      "$1" + newID + "$3"
+    );
+  });
+  return body;
+}
+function iconToHTML(body, attributes) {
+  let renderAttribsHTML = body.indexOf("xlink:") === -1 ? "" : ' xmlns:xlink="http://www.w3.org/1999/xlink"';
+  for (const attr in attributes) {
+    renderAttribsHTML += " " + attr + '="' + attributes[attr] + '"';
+  }
+  return '<svg xmlns="http://www.w3.org/2000/svg"' + renderAttribsHTML + ">" + body + "</svg>";
+}
+function encodeSVGforURL(svg) {
+  return svg.replace(/"/g, "'").replace(/%/g, "%25").replace(/#/g, "%23").replace(/</g, "%3C").replace(/>/g, "%3E").replace(/\s+/g, " ");
+}
+function svgToURL(svg) {
+  return 'url("data:image/svg+xml,' + encodeSVGforURL(svg) + '")';
+}
+const defaultExtendedIconCustomisations = {
+  ...defaultIconCustomisations,
+  inline: false
+};
+const svgDefaults = {
+  "xmlns": "http://www.w3.org/2000/svg",
+  "xmlns:xlink": "http://www.w3.org/1999/xlink",
+  "aria-hidden": true,
+  "role": "img"
+};
+const commonProps = {
+  display: "inline-block"
+};
+const monotoneProps = {
+  backgroundColor: "currentColor"
+};
+const coloredProps = {
+  backgroundColor: "transparent"
+};
+const propsToAdd = {
+  Image: "var(--svg)",
+  Repeat: "no-repeat",
+  Size: "100% 100%"
+};
+const propsToAddTo = {
+  webkitMask: monotoneProps,
+  mask: monotoneProps,
+  background: coloredProps
+};
+for (const prefix in propsToAddTo) {
+  const list = propsToAddTo[prefix];
+  for (const prop in propsToAdd) {
+    list[prefix + prop] = propsToAdd[prop];
+  }
+}
+const customisationAliases = {};
+["horizontal", "vertical"].forEach((prefix) => {
+  const attr = prefix.slice(0, 1) + "Flip";
+  customisationAliases[prefix + "-flip"] = attr;
+  customisationAliases[prefix.slice(0, 1) + "-flip"] = attr;
+  customisationAliases[prefix + "Flip"] = attr;
+});
+function fixSize(value) {
+  return value + (value.match(/^[-0-9.]+$/) ? "px" : "");
+}
+const render = (icon, props) => {
+  const customisations = mergeCustomisations(defaultExtendedIconCustomisations, props);
+  const componentProps = { ...svgDefaults };
+  const mode = props.mode || "svg";
+  const style = {};
+  const propsStyle = props.style;
+  const customStyle = typeof propsStyle === "object" && !(propsStyle instanceof Array) ? propsStyle : {};
+  for (let key in props) {
+    const value = props[key];
+    if (value === void 0) {
+      continue;
+    }
+    switch (key) {
+      case "icon":
+      case "style":
+      case "onLoad":
+      case "mode":
+        break;
+      case "inline":
+      case "hFlip":
+      case "vFlip":
+        customisations[key] = value === true || value === "true" || value === 1;
+        break;
+      case "flip":
+        if (typeof value === "string") {
+          flipFromString(customisations, value);
+        }
+        break;
+      case "color":
+        style.color = value;
+        break;
+      case "rotate":
+        if (typeof value === "string") {
+          customisations[key] = rotateFromString(value);
+        } else if (typeof value === "number") {
+          customisations[key] = value;
+        }
+        break;
+      case "ariaHidden":
+      case "aria-hidden":
+        if (value !== true && value !== "true") {
+          delete componentProps["aria-hidden"];
+        }
+        break;
+      default: {
+        const alias = customisationAliases[key];
+        if (alias) {
+          if (value === true || value === "true" || value === 1) {
+            customisations[alias] = true;
+          }
+        } else if (defaultExtendedIconCustomisations[key] === void 0) {
+          componentProps[key] = value;
+        }
+      }
+    }
+  }
+  const item = iconToSVG(icon, customisations);
+  const renderAttribs = item.attributes;
+  if (customisations.inline) {
+    style.verticalAlign = "-0.125em";
+  }
+  if (mode === "svg") {
+    componentProps.style = {
+      ...style,
+      ...customStyle
+    };
+    Object.assign(componentProps, renderAttribs);
+    let localCounter = 0;
+    let id = props.id;
+    if (typeof id === "string") {
+      id = id.replace(/-/g, "_");
+    }
+    componentProps["innerHTML"] = replaceIDs(item.body, id ? () => id + "ID" + localCounter++ : "iconifyVue");
+    return h("svg", componentProps);
+  }
+  const { body, width, height } = icon;
+  const useMask = mode === "mask" || (mode === "bg" ? false : body.indexOf("currentColor") !== -1);
+  const html = iconToHTML(body, {
+    ...renderAttribs,
+    width: width + "",
+    height: height + ""
+  });
+  componentProps.style = {
+    ...style,
+    "--svg": svgToURL(html),
+    "width": fixSize(renderAttribs.width),
+    "height": fixSize(renderAttribs.height),
+    ...commonProps,
+    ...useMask ? monotoneProps : coloredProps,
+    ...customStyle
+  };
+  return h("span", componentProps);
+};
+const storage = /* @__PURE__ */ Object.create(null);
+function addIcon(name, data) {
+  storage[name] = data;
+}
+const Icon = defineComponent({
+  // Do not inherit other attributes: it is handled by render()
+  inheritAttrs: false,
+  // Render icon
+  render() {
+    const props = this.$attrs;
+    const propsIcon = props.icon;
+    const icon = typeof propsIcon === "string" ? storage[propsIcon] : typeof propsIcon === "object" ? propsIcon : null;
+    if (icon === null || typeof icon !== "object" || typeof icon.body !== "string") {
+      return this.$slots.default ? this.$slots.default() : null;
+    }
+    return render({
+      ...defaultIconProps,
+      ...icon
+    }, props);
+  }
+});
+export {
+  Icon,
+  addIcon
+};

package/dist/es/node_modules/.pnpm/@pureadmin_utils@1.8.5_vue@3.2.45/node_modules/@pureadmin/utils/dist/index.mjs

@@ -0,0 +1,70 @@
+import * as __viteBrowserExternal from "../../../../../../../_virtual/__vite-browser-external.mjs";
+import * as se from "vue";
+var at = Object.defineProperty;
+var It = Object.getOwnPropertyDescriptor;
+var Ut = Object.getOwnPropertyNames;
+var Pt = Object.prototype.hasOwnProperty;
+var ct = (t, n) => {
+  for (var e in n)
+    at(t, e, { get: n[e], enumerable: true });
+}, it = (t, n, e, r) => {
+  if (n && typeof n == "object" || typeof n == "function")
+    for (let o of Ut(n))
+      !Pt.call(t, o) && o !== e && at(t, o, { get: () => n[o], enumerable: !(r = It(n, o)) || r.enumerable });
+  return t;
+}, D = (t, n, e) => (it(t, n, "default"), e && it(e, n, "default"));
+var Bt = Object.prototype.toString;
+function O(t, n) {
+  return Bt.call(t) === `[object ${n}]`;
+}
+function H(t) {
+  return t !== null && O(t, "Object");
+}
+function R(t) {
+  return typeof t < "u";
+}
+function dt(t) {
+  return !R(t);
+}
+function gt(t) {
+  return t === null;
+}
+function Nt(t) {
+  return gt(t) || dt(t);
+}
+function Ft(t) {
+  return Q(t) || S(t) ? t.length === 0 : t instanceof Map || t instanceof Set ? t.size === 0 : H(t) ? Object.keys(t).length === 0 : false;
+}
+function B(t) {
+  return !!(Ft(t) || Nt(t));
+}
+function S(t) {
+  return O(t, "String");
+}
+function mt(t) {
+  return typeof t == "function";
+}
+function Q(t) {
+  return t && Array.isArray(t);
+}
+var I = (t = 20) => new Promise((n) => setTimeout(n, t));
+var A = {};
+ct(A, { Fs: () => __viteBrowserExternal });
+D(A, __viteBrowserExternal);
+var i = {};
+ct(i, { Vue: () => se });
+D(i, se);
+export {
+  I as delay,
+  O as is,
+  B as isAllEmpty,
+  Q as isArray,
+  R as isDef,
+  Ft as isEmpty,
+  mt as isFunction,
+  gt as isNull,
+  Nt as isNullOrUnDef,
+  H as isObject,
+  S as isString,
+  dt as isUnDef
+};

package/dist/es/node_modules/.pnpm/call-bind@1.0.7/node_modules/call-bind/callBound.mjs

@@ -0,0 +1,16 @@
+import getIntrinsic from "../../../get-intrinsic@1.2.4/node_modules/get-intrinsic/index.mjs";
+import "./index.mjs";
+import { exports as callBindExports } from "../../../../../_virtual/index.mjs";
+var GetIntrinsic = getIntrinsic;
+var callBind = callBindExports;
+var $indexOf = callBind(GetIntrinsic("String.prototype.indexOf"));
+var callBound = function callBoundIntrinsic(name, allowMissing) {
+  var intrinsic = GetIntrinsic(name, !!allowMissing);
+  if (typeof intrinsic === "function" && $indexOf(name, ".prototype.") > -1) {
+    return callBind(intrinsic);
+  }
+  return intrinsic;
+};
+export {
+  callBound as default
+};

package/dist/es/node_modules/.pnpm/call-bind@1.0.7/node_modules/call-bind/index.mjs

@@ -0,0 +1,36 @@
+import { __module as callBind } from "../../../../../_virtual/index.mjs";
+import functionBind from "../../../function-bind@1.1.2/node_modules/function-bind/index.mjs";
+import getIntrinsic from "../../../get-intrinsic@1.2.4/node_modules/get-intrinsic/index.mjs";
+import setFunctionLength from "../../../set-function-length@1.2.2/node_modules/set-function-length/index.mjs";
+import type from "../../../es-errors@1.3.0/node_modules/es-errors/type.mjs";
+import { __require as requireEsDefineProperty } from "../../../es-define-property@1.0.0/node_modules/es-define-property/index.mjs";
+(function(module) {
+  var bind = functionBind;
+  var GetIntrinsic = getIntrinsic;
+  var setFunctionLength$1 = setFunctionLength;
+  var $TypeError = type;
+  var $apply = GetIntrinsic("%Function.prototype.apply%");
+  var $call = GetIntrinsic("%Function.prototype.call%");
+  var $reflectApply = GetIntrinsic("%Reflect.apply%", true) || bind.call($call, $apply);
+  var $defineProperty = requireEsDefineProperty();
+  var $max = GetIntrinsic("%Math.max%");
+  module.exports = function callBind2(originalFunction) {
+    if (typeof originalFunction !== "function") {
+      throw new $TypeError("a function is required");
+    }
+    var func = $reflectApply(bind, $call, arguments);
+    return setFunctionLength$1(
+      func,
+      1 + $max(0, originalFunction.length - (arguments.length - 1)),
+      true
+    );
+  };
+  var applyBind = function applyBind2() {
+    return $reflectApply(bind, $apply, arguments);
+  };
+  if ($defineProperty) {
+    $defineProperty(module.exports, "apply", { value: applyBind });
+  } else {
+    module.exports.apply = applyBind;
+  }
+})(callBind);

package/dist/es/node_modules/.pnpm/define-data-property@1.1.4/node_modules/define-data-property/index.mjs

@@ -0,0 +1,48 @@
+import { __require as requireEsDefineProperty } from "../../../es-define-property@1.0.0/node_modules/es-define-property/index.mjs";
+import syntax from "../../../es-errors@1.3.0/node_modules/es-errors/syntax.mjs";
+import type from "../../../es-errors@1.3.0/node_modules/es-errors/type.mjs";
+import gopd$1 from "../../../gopd@1.0.1/node_modules/gopd/index.mjs";
+var $defineProperty = requireEsDefineProperty();
+var $SyntaxError = syntax;
+var $TypeError = type;
+var gopd = gopd$1;
+var defineDataProperty = function defineDataProperty2(obj, property, value) {
+  if (!obj || typeof obj !== "object" && typeof obj !== "function") {
+    throw new $TypeError("`obj` must be an object or a function`");
+  }
+  if (typeof property !== "string" && typeof property !== "symbol") {
+    throw new $TypeError("`property` must be a string or a symbol`");
+  }
+  if (arguments.length > 3 && typeof arguments[3] !== "boolean" && arguments[3] !== null) {
+    throw new $TypeError("`nonEnumerable`, if provided, must be a boolean or null");
+  }
+  if (arguments.length > 4 && typeof arguments[4] !== "boolean" && arguments[4] !== null) {
+    throw new $TypeError("`nonWritable`, if provided, must be a boolean or null");
+  }
+  if (arguments.length > 5 && typeof arguments[5] !== "boolean" && arguments[5] !== null) {
+    throw new $TypeError("`nonConfigurable`, if provided, must be a boolean or null");
+  }
+  if (arguments.length > 6 && typeof arguments[6] !== "boolean") {
+    throw new $TypeError("`loose`, if provided, must be a boolean");
+  }
+  var nonEnumerable = arguments.length > 3 ? arguments[3] : null;
+  var nonWritable = arguments.length > 4 ? arguments[4] : null;
+  var nonConfigurable = arguments.length > 5 ? arguments[5] : null;
+  var loose = arguments.length > 6 ? arguments[6] : false;
+  var desc = !!gopd && gopd(obj, property);
+  if ($defineProperty) {
+    $defineProperty(obj, property, {
+      configurable: nonConfigurable === null && desc ? desc.configurable : !nonConfigurable,
+      enumerable: nonEnumerable === null && desc ? desc.enumerable : !nonEnumerable,
+      value,
+      writable: nonWritable === null && desc ? desc.writable : !nonWritable
+    });
+  } else if (loose || !nonEnumerable && !nonWritable && !nonConfigurable) {
+    obj[property] = value;
+  } else {
+    throw new $SyntaxError("This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.");
+  }
+};
+export {
+  defineDataProperty as default
+};