@frollo/frollo-web-ui 0.0.16 → 0.0.17

package/esm/index-5430e7a3.js

@@ -0,0 +1,565 @@
+import { b as functionUncurryThis, c as aCallable$1, e as functionBindNative, w as wellKnownSymbol$3, g as global$5, i as isCallable$4, f as fails$2, h as getBuiltIn$1, j as isObject$2, t as toObject$1, k as anObject$1, r as requireObjectCoercible$1, a as descriptors, l as hasOwnProperty_1, o as objectIsPrototypeOf, m as isSymbol$1, n as toPrimitive$1, p as objectDefineProperty } from './function-name-a620492a.js';
+import { b as classofRaw$1, i as inspectSource$1, d as indexedObject, l as lengthOfArrayLike$1, e as isForced_1, r as redefine$1, f as objectGetOwnPropertyNames, g as objectGetOwnPropertyDescriptor, _ as _export, h as addToUnscopables$1 } from './add-to-unscopables-874257d1.js';
+import { defineComponent, computed, ref, provide, openBlock, createElementBlock, Fragment, renderList, createElementVNode, normalizeClass, toDisplayString, createCommentVNode, renderSlot, getCurrentInstance, inject, watchEffect } from 'vue';
+
+var uncurryThis$6 = functionUncurryThis;
+var aCallable = aCallable$1;
+var NATIVE_BIND = functionBindNative;
+
+var bind$1 = uncurryThis$6(uncurryThis$6.bind);
+
+// optional / simple context binding
+var functionBindContext = function (fn, that) {
+  aCallable(fn);
+  return that === undefined ? fn : NATIVE_BIND ? bind$1(fn, that) : function (/* ...args */) {
+    return fn.apply(that, arguments);
+  };
+};
+
+var classof$3 = classofRaw$1;
+
+// `IsArray` abstract operation
+// https://tc39.es/ecma262/#sec-isarray
+// eslint-disable-next-line es/no-array-isarray -- safe
+var isArray$1 = Array.isArray || function isArray(argument) {
+  return classof$3(argument) == 'Array';
+};
+
+var wellKnownSymbol$2 = wellKnownSymbol$3;
+
+var TO_STRING_TAG$1 = wellKnownSymbol$2('toStringTag');
+var test = {};
+
+test[TO_STRING_TAG$1] = 'z';
+
+var toStringTagSupport = String(test) === '[object z]';
+
+var global$4 = global$5;
+var TO_STRING_TAG_SUPPORT = toStringTagSupport;
+var isCallable$3 = isCallable$4;
+var classofRaw = classofRaw$1;
+var wellKnownSymbol$1 = wellKnownSymbol$3;
+
+var TO_STRING_TAG = wellKnownSymbol$1('toStringTag');
+var Object$1 = global$4.Object;
+
+// ES3 wrong here
+var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';
+
+// fallback for IE11 Script Access Denied error
+var tryGet = function (it, key) {
+  try {
+    return it[key];
+  } catch (error) { /* empty */ }
+};
+
+// getting tag from ES6+ `Object.prototype.toString`
+var classof$2 = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
+  var O, tag, result;
+  return it === undefined ? 'Undefined' : it === null ? 'Null'
+    // @@toStringTag case
+    : typeof (tag = tryGet(O = Object$1(it), TO_STRING_TAG)) == 'string' ? tag
+    // builtinTag case
+    : CORRECT_ARGUMENTS ? classofRaw(O)
+    // ES3 arguments fallback
+    : (result = classofRaw(O)) == 'Object' && isCallable$3(O.callee) ? 'Arguments' : result;
+};
+
+var uncurryThis$5 = functionUncurryThis;
+var fails$1 = fails$2;
+var isCallable$2 = isCallable$4;
+var classof$1 = classof$2;
+var getBuiltIn = getBuiltIn$1;
+var inspectSource = inspectSource$1;
+
+var noop = function () { /* empty */ };
+var empty = [];
+var construct = getBuiltIn('Reflect', 'construct');
+var constructorRegExp = /^\s*(?:class|function)\b/;
+var exec = uncurryThis$5(constructorRegExp.exec);
+var INCORRECT_TO_STRING = !constructorRegExp.exec(noop);
+
+var isConstructorModern = function isConstructor(argument) {
+  if (!isCallable$2(argument)) return false;
+  try {
+    construct(noop, empty, argument);
+    return true;
+  } catch (error) {
+    return false;
+  }
+};
+
+var isConstructorLegacy = function isConstructor(argument) {
+  if (!isCallable$2(argument)) return false;
+  switch (classof$1(argument)) {
+    case 'AsyncFunction':
+    case 'GeneratorFunction':
+    case 'AsyncGeneratorFunction': return false;
+  }
+  try {
+    // we can't check .prototype since constructors produced by .bind haven't it
+    // `Function#toString` throws on some built-it function in some legacy engines
+    // (for example, `DOMQuad` and similar in FF41-)
+    return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));
+  } catch (error) {
+    return true;
+  }
+};
+
+isConstructorLegacy.sham = true;
+
+// `IsConstructor` abstract operation
+// https://tc39.es/ecma262/#sec-isconstructor
+var isConstructor$1 = !construct || fails$1(function () {
+  var called;
+  return isConstructorModern(isConstructorModern.call)
+    || !isConstructorModern(Object)
+    || !isConstructorModern(function () { called = true; })
+    || called;
+}) ? isConstructorLegacy : isConstructorModern;
+
+var global$3 = global$5;
+var isArray = isArray$1;
+var isConstructor = isConstructor$1;
+var isObject$1 = isObject$2;
+var wellKnownSymbol = wellKnownSymbol$3;
+
+var SPECIES = wellKnownSymbol('species');
+var Array$1 = global$3.Array;
+
+// a part of `ArraySpeciesCreate` abstract operation
+// https://tc39.es/ecma262/#sec-arrayspeciescreate
+var arraySpeciesConstructor$1 = function (originalArray) {
+  var C;
+  if (isArray(originalArray)) {
+    C = originalArray.constructor;
+    // cross-realm fallback
+    if (isConstructor(C) && (C === Array$1 || isArray(C.prototype))) C = undefined;
+    else if (isObject$1(C)) {
+      C = C[SPECIES];
+      if (C === null) C = undefined;
+    }
+  } return C === undefined ? Array$1 : C;
+};
+
+var arraySpeciesConstructor = arraySpeciesConstructor$1;
+
+// `ArraySpeciesCreate` abstract operation
+// https://tc39.es/ecma262/#sec-arrayspeciescreate
+var arraySpeciesCreate$1 = function (originalArray, length) {
+  return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);
+};
+
+var bind = functionBindContext;
+var uncurryThis$4 = functionUncurryThis;
+var IndexedObject = indexedObject;
+var toObject = toObject$1;
+var lengthOfArrayLike = lengthOfArrayLike$1;
+var arraySpeciesCreate = arraySpeciesCreate$1;
+
+var push = uncurryThis$4([].push);
+
+// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation
+var createMethod$1 = function (TYPE) {
+  var IS_MAP = TYPE == 1;
+  var IS_FILTER = TYPE == 2;
+  var IS_SOME = TYPE == 3;
+  var IS_EVERY = TYPE == 4;
+  var IS_FIND_INDEX = TYPE == 6;
+  var IS_FILTER_REJECT = TYPE == 7;
+  var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
+  return function ($this, callbackfn, that, specificCreate) {
+    var O = toObject($this);
+    var self = IndexedObject(O);
+    var boundFunction = bind(callbackfn, that);
+    var length = lengthOfArrayLike(self);
+    var index = 0;
+    var create = specificCreate || arraySpeciesCreate;
+    var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined;
+    var value, result;
+    for (;length > index; index++) if (NO_HOLES || index in self) {
+      value = self[index];
+      result = boundFunction(value, index, O);
+      if (TYPE) {
+        if (IS_MAP) target[index] = result; // map
+        else if (result) switch (TYPE) {
+          case 3: return true;              // some
+          case 5: return value;             // find
+          case 6: return index;             // findIndex
+          case 2: push(target, value);      // filter
+        } else switch (TYPE) {
+          case 4: return false;             // every
+          case 7: push(target, value);      // filterReject
+        }
+      }
+    }
+    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;
+  };
+};
+
+var arrayIteration = {
+  // `Array.prototype.forEach` method
+  // https://tc39.es/ecma262/#sec-array.prototype.foreach
+  forEach: createMethod$1(0),
+  // `Array.prototype.map` method
+  // https://tc39.es/ecma262/#sec-array.prototype.map
+  map: createMethod$1(1),
+  // `Array.prototype.filter` method
+  // https://tc39.es/ecma262/#sec-array.prototype.filter
+  filter: createMethod$1(2),
+  // `Array.prototype.some` method
+  // https://tc39.es/ecma262/#sec-array.prototype.some
+  some: createMethod$1(3),
+  // `Array.prototype.every` method
+  // https://tc39.es/ecma262/#sec-array.prototype.every
+  every: createMethod$1(4),
+  // `Array.prototype.find` method
+  // https://tc39.es/ecma262/#sec-array.prototype.find
+  find: createMethod$1(5),
+  // `Array.prototype.findIndex` method
+  // https://tc39.es/ecma262/#sec-array.prototype.findIndex
+  findIndex: createMethod$1(6),
+  // `Array.prototype.filterReject` method
+  // https://github.com/tc39/proposal-array-filtering
+  filterReject: createMethod$1(7)
+};
+
+var es_number_constructor = {};
+
+var global$2 = global$5;
+var isCallable$1 = isCallable$4;
+
+var String$2 = global$2.String;
+var TypeError$2 = global$2.TypeError;
+
+var aPossiblePrototype$1 = function (argument) {
+  if (typeof argument == 'object' || isCallable$1(argument)) return argument;
+  throw TypeError$2("Can't set " + String$2(argument) + ' as a prototype');
+};
+
+/* eslint-disable no-proto -- safe */
+
+var uncurryThis$3 = functionUncurryThis;
+var anObject = anObject$1;
+var aPossiblePrototype = aPossiblePrototype$1;
+
+// `Object.setPrototypeOf` method
+// https://tc39.es/ecma262/#sec-object.setprototypeof
+// Works with __proto__ only. Old v8 can't work with null proto objects.
+// eslint-disable-next-line es/no-object-setprototypeof -- safe
+var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? function () {
+  var CORRECT_SETTER = false;
+  var test = {};
+  var setter;
+  try {
+    // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+    setter = uncurryThis$3(Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set);
+    setter(test, []);
+    CORRECT_SETTER = test instanceof Array;
+  } catch (error) { /* empty */ }
+  return function setPrototypeOf(O, proto) {
+    anObject(O);
+    aPossiblePrototype(proto);
+    if (CORRECT_SETTER) setter(O, proto);
+    else O.__proto__ = proto;
+    return O;
+  };
+}() : undefined);
+
+var isCallable = isCallable$4;
+var isObject = isObject$2;
+var setPrototypeOf = objectSetPrototypeOf;
+
+// makes subclassing work correct for wrapped built-ins
+var inheritIfRequired$1 = function ($this, dummy, Wrapper) {
+  var NewTarget, NewTargetPrototype;
+  if (
+    // it can work only with native `setPrototypeOf`
+    setPrototypeOf &&
+    // we haven't completely correct pre-ES6 way for getting `new.target`, so use this
+    isCallable(NewTarget = dummy.constructor) &&
+    NewTarget !== Wrapper &&
+    isObject(NewTargetPrototype = NewTarget.prototype) &&
+    NewTargetPrototype !== Wrapper.prototype
+  ) setPrototypeOf($this, NewTargetPrototype);
+  return $this;
+};
+
+var uncurryThis$2 = functionUncurryThis;
+
+// `thisNumberValue` abstract operation
+// https://tc39.es/ecma262/#sec-thisnumbervalue
+var thisNumberValue$1 = uncurryThis$2(1.0.valueOf);
+
+var global$1 = global$5;
+var classof = classof$2;
+
+var String$1 = global$1.String;
+
+var toString$1 = function (argument) {
+  if (classof(argument) === 'Symbol') throw TypeError('Cannot convert a Symbol value to a string');
+  return String$1(argument);
+};
+
+// a string of all valid unicode whitespaces
+var whitespaces$1 = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002' +
+  '\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF';
+
+var uncurryThis$1 = functionUncurryThis;
+var requireObjectCoercible = requireObjectCoercible$1;
+var toString = toString$1;
+var whitespaces = whitespaces$1;
+
+var replace = uncurryThis$1(''.replace);
+var whitespace = '[' + whitespaces + ']';
+var ltrim = RegExp('^' + whitespace + whitespace + '*');
+var rtrim = RegExp(whitespace + whitespace + '*$');
+
+// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation
+var createMethod = function (TYPE) {
+  return function ($this) {
+    var string = toString(requireObjectCoercible($this));
+    if (TYPE & 1) string = replace(string, ltrim, '');
+    if (TYPE & 2) string = replace(string, rtrim, '');
+    return string;
+  };
+};
+
+var stringTrim = {
+  // `String.prototype.{ trimLeft, trimStart }` methods
+  // https://tc39.es/ecma262/#sec-string.prototype.trimstart
+  start: createMethod(1),
+  // `String.prototype.{ trimRight, trimEnd }` methods
+  // https://tc39.es/ecma262/#sec-string.prototype.trimend
+  end: createMethod(2),
+  // `String.prototype.trim` method
+  // https://tc39.es/ecma262/#sec-string.prototype.trim
+  trim: createMethod(3)
+};
+
+'use strict';
+var DESCRIPTORS = descriptors;
+var global = global$5;
+var uncurryThis = functionUncurryThis;
+var isForced = isForced_1;
+var redefine = redefine$1.exports;
+var hasOwn = hasOwnProperty_1;
+var inheritIfRequired = inheritIfRequired$1;
+var isPrototypeOf = objectIsPrototypeOf;
+var isSymbol = isSymbol$1;
+var toPrimitive = toPrimitive$1;
+var fails = fails$2;
+var getOwnPropertyNames = objectGetOwnPropertyNames.f;
+var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
+var defineProperty = objectDefineProperty.f;
+var thisNumberValue = thisNumberValue$1;
+var trim = stringTrim.trim;
+
+var NUMBER = 'Number';
+var NativeNumber = global[NUMBER];
+var NumberPrototype = NativeNumber.prototype;
+var TypeError$1 = global.TypeError;
+var arraySlice = uncurryThis(''.slice);
+var charCodeAt = uncurryThis(''.charCodeAt);
+
+// `ToNumeric` abstract operation
+// https://tc39.es/ecma262/#sec-tonumeric
+var toNumeric = function (value) {
+  var primValue = toPrimitive(value, 'number');
+  return typeof primValue == 'bigint' ? primValue : toNumber(primValue);
+};
+
+// `ToNumber` abstract operation
+// https://tc39.es/ecma262/#sec-tonumber
+var toNumber = function (argument) {
+  var it = toPrimitive(argument, 'number');
+  var first, third, radix, maxCode, digits, length, index, code;
+  if (isSymbol(it)) throw TypeError$1('Cannot convert a Symbol value to a number');
+  if (typeof it == 'string' && it.length > 2) {
+    it = trim(it);
+    first = charCodeAt(it, 0);
+    if (first === 43 || first === 45) {
+      third = charCodeAt(it, 2);
+      if (third === 88 || third === 120) return NaN; // Number('+0x1') should be NaN, old V8 fix
+    } else if (first === 48) {
+      switch (charCodeAt(it, 1)) {
+        case 66: case 98: radix = 2; maxCode = 49; break; // fast equal of /^0b[01]+$/i
+        case 79: case 111: radix = 8; maxCode = 55; break; // fast equal of /^0o[0-7]+$/i
+        default: return +it;
+      }
+      digits = arraySlice(it, 2);
+      length = digits.length;
+      for (index = 0; index < length; index++) {
+        code = charCodeAt(digits, index);
+        // parseInt parses a string to a first unavailable symbol
+        // but ToNumber should return NaN if a string contains unavailable symbols
+        if (code < 48 || code > maxCode) return NaN;
+      } return parseInt(digits, radix);
+    }
+  } return +it;
+};
+
+// `Number` constructor
+// https://tc39.es/ecma262/#sec-number-constructor
+if (isForced(NUMBER, !NativeNumber(' 0o1') || !NativeNumber('0b1') || NativeNumber('+0x1'))) {
+  var NumberWrapper = function Number(value) {
+    var n = arguments.length < 1 ? 0 : NativeNumber(toNumeric(value));
+    var dummy = this;
+    // check on 1..constructor(foo) case
+    return isPrototypeOf(NumberPrototype, dummy) && fails(function () { thisNumberValue(dummy); })
+      ? inheritIfRequired(Object(n), dummy, NumberWrapper) : n;
+  };
+  for (var keys = DESCRIPTORS ? getOwnPropertyNames(NativeNumber) : (
+    // ES3:
+    'MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,' +
+    // ES2015 (in case, if modules with ES2015 Number statics required before):
+    'EPSILON,MAX_SAFE_INTEGER,MIN_SAFE_INTEGER,isFinite,isInteger,isNaN,isSafeInteger,parseFloat,parseInt,' +
+    // ESNext
+    'fromString,range'
+  ).split(','), j = 0, key; keys.length > j; j++) {
+    if (hasOwn(NativeNumber, key = keys[j]) && !hasOwn(NumberWrapper, key)) {
+      defineProperty(NumberWrapper, key, getOwnPropertyDescriptor(NativeNumber, key));
+    }
+  }
+  NumberWrapper.prototype = NumberPrototype;
+  NumberPrototype.constructor = NumberWrapper;
+  redefine(global, NUMBER, NumberWrapper);
+}
+
+var script$1 = defineComponent({
+  name: 'FwTabs',
+  emits: ['update:modelValue'],
+  props: {
+    /**
+     * The active tab v-model
+     */
+    modelValue: {
+      type: Number,
+      required: true
+    }
+  },
+  setup: function setup(props, ctx) {
+    var active = computed(function () {
+      return props.modelValue;
+    });
+    var tabs = ref([]);
+
+    var selectTab = function selectTab(tab) {
+      ctx.emit('update:modelValue', tab);
+    };
+
+    provide('tabsState', {
+      active: active,
+      tabs: tabs
+    });
+    return {
+      active: active,
+      tabs: tabs,
+      selectTab: selectTab
+    };
+  }
+});
+
+var _hoisted_1$1 = {
+  "class": "fw-tabs"
+};
+var _hoisted_2 = {
+  key: 0,
+  "class": "flex flex-wrap -mb-px border-b border-grey-light dark:text-grey-base dark:border-grey-base"
+};
+var _hoisted_3 = ["onClick"];
+function render$1(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("div", _hoisted_1$1, [_ctx.tabs ? (openBlock(), createElementBlock("ul", _hoisted_2, [(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.tabs, function (tab, i) {
+    return openBlock(), createElementBlock("li", {
+      "class": "mr-2",
+      key: i
+    }, [createElementVNode("button", {
+      type: "button",
+      onClick: function onClick($event) {
+        return _ctx.selectTab(i);
+      },
+      "class": normalizeClass(["inline-block p-4 outline-primary border-b-2 border-transparent transition ease-in", _ctx.active === i ? 'font-medium border-black' : 'hover:bg-grey-lightest'])
+    }, toDisplayString(tab.props.label), 11, _hoisted_3)]);
+  }), 128))])) : createCommentVNode("", true), renderSlot(_ctx.$slots, "default")]);
+}
+
+script$1.render = render$1;
+
+var es_array_findIndex = {};
+
+'use strict';
+var $ = _export;
+var $findIndex = arrayIteration.findIndex;
+var addToUnscopables = addToUnscopables$1;
+
+var FIND_INDEX = 'findIndex';
+var SKIPS_HOLES = true;
+
+// Shouldn't skip holes
+if (FIND_INDEX in []) Array(1)[FIND_INDEX](function () { SKIPS_HOLES = false; });
+
+// `Array.prototype.findIndex` method
+// https://tc39.es/ecma262/#sec-array.prototype.findindex
+$({ target: 'Array', proto: true, forced: SKIPS_HOLES }, {
+  findIndex: function findIndex(callbackfn /* , that = undefined */) {
+    return $findIndex(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
+  }
+});
+
+// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
+addToUnscopables(FIND_INDEX);
+
+var script = defineComponent({
+  name: 'FwTab',
+  props: {
+    /**
+     * The label of the tab component used as the button panel label
+     */
+    label: {
+      type: String,
+      required: true
+    }
+  },
+  setup: function setup() {
+    var instance = getCurrentInstance();
+
+    var _ref = inject('tabsState') || {
+      tabs: [],
+      active: 0
+    },
+        tabs = _ref.tabs,
+        active = _ref.active;
+
+    var index = computed(function () {
+      var _tabs$value;
+
+      return (_tabs$value = tabs.value) === null || _tabs$value === void 0 ? void 0 : _tabs$value.findIndex(function (target) {
+        return target.uid === (instance === null || instance === void 0 ? void 0 : instance.uid);
+      });
+    });
+    var isActive = computed(function () {
+      return index.value === active.value;
+    });
+    watchEffect(function () {
+      if (index.value === -1) {
+        tabs.value.push(instance);
+      }
+    });
+    return {
+      isActive: isActive,
+      index: index
+    };
+  }
+});
+
+var _hoisted_1 = {
+  key: 0,
+  "class": "fw-tab w-full"
+};
+function render(_ctx, _cache, $props, $setup, $data, $options) {
+  return _ctx.isActive ? (openBlock(), createElementBlock("div", _hoisted_1, [renderSlot(_ctx.$slots, "default")])) : createCommentVNode("", true);
+}
+
+script.render = render;
+
+export { arrayIteration as a, script as b, classof$2 as c, script$1 as s, toStringTagSupport as t };