vviinn-widgets 2.19.1 → 2.20.2

package/dist/cjs/Campaign-13258569.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const campaignTypeNames = {
+  VPR: "Similar Products",
+  VPS: "Visual Search",
+  VCS: "Products Cross-Selling",
+};
+const isVPR = (c) => c._tag === "VPR";
+function fold(onVPR, onVCS) {
+  return (c) => (isVPR(c) ? onVPR() : onVCS());
+}
+function fromString(s) {
+  return s === "VPR" ? { _tag: "VPR" } : { _tag: "VCS" };
+}
+
+exports.campaignTypeNames = campaignTypeNames;
+exports.fold = fold;
+exports.fromString = fromString;

package/dist/cjs/Handler-de64afa5.js

@@ -0,0 +1,317 @@
+'use strict';
+
+var __spreadArray = (undefined && undefined.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+/**
+ * @since 2.0.0
+ */
+function identity(a) {
+    return a;
+}
+/**
+ * @since 2.0.0
+ */
+function tuple() {
+    var t = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        t[_i] = arguments[_i];
+    }
+    return t;
+}
+function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
+    switch (arguments.length) {
+        case 1:
+            return a;
+        case 2:
+            return ab(a);
+        case 3:
+            return bc(ab(a));
+        case 4:
+            return cd(bc(ab(a)));
+        case 5:
+            return de(cd(bc(ab(a))));
+        case 6:
+            return ef(de(cd(bc(ab(a)))));
+        case 7:
+            return fg(ef(de(cd(bc(ab(a))))));
+        case 8:
+            return gh(fg(ef(de(cd(bc(ab(a)))))));
+        case 9:
+            return hi(gh(fg(ef(de(cd(bc(ab(a))))))));
+        default: {
+            var ret = arguments[0];
+            for (var i = 1; i < arguments.length; i++) {
+                ret = arguments[i](ret);
+            }
+            return ret;
+        }
+    }
+}
+/** @internal */
+var dual = function (arity, body) {
+    var isDataFirst = typeof arity === 'number' ? function (args) { return args.length >= arity; } : arity;
+    return function () {
+        var args = Array.from(arguments);
+        if (isDataFirst(arguments)) {
+            return body.apply(this, args);
+        }
+        return function (self) { return body.apply(void 0, __spreadArray([self], args, false)); };
+    };
+};
+
+// -------------------------------------------------------------------------------------
+// Option
+// -------------------------------------------------------------------------------------
+/** @internal */
+var isNone = function (fa) { return fa._tag === 'None'; };
+/** @internal */
+var isSome = function (fa) { return fa._tag === 'Some'; };
+/** @internal */
+var none = { _tag: 'None' };
+/** @internal */
+var some = function (a) { return ({ _tag: 'Some', value: a }); };
+// -------------------------------------------------------------------------------------
+// Either
+// -------------------------------------------------------------------------------------
+/** @internal */
+var isLeft = function (ma) { return ma._tag === 'Left'; };
+/** @internal */
+var left = function (e) { return ({ _tag: 'Left', left: e }); };
+/** @internal */
+var right = function (a) { return ({ _tag: 'Right', right: a }); };
+// -------------------------------------------------------------------------------------
+// Record
+// -------------------------------------------------------------------------------------
+/** @internal */
+var has = Object.prototype.hasOwnProperty;
+/** @internal */
+var flatMapTask = function (F, M) {
+    /*#__PURE__*/ return dual(2, function (self, f) {
+        return M.flatMap(self, function (a) { return F.fromTask(f(a)); });
+    });
+};
+
+/**
+ * If a type `A` can form a `Semigroup` it has an **associative** binary operation.
+ *
+ * ```ts
+ * interface Semigroup<A> {
+ *   readonly concat: (x: A, y: A) => A
+ * }
+ * ```
+ *
+ * Associativity means the following equality must hold for any choice of `x`, `y`, and `z`.
+ *
+ * ```ts
+ * concat(x, concat(y, z)) = concat(concat(x, y), z)
+ * ```
+ *
+ * A common example of a semigroup is the type `string` with the operation `+`.
+ *
+ * ```ts
+ * import { Semigroup } from 'fp-ts/Semigroup'
+ *
+ * const semigroupString: Semigroup<string> = {
+ *   concat: (x, y) => x + y
+ * }
+ *
+ * const x = 'x'
+ * const y = 'y'
+ * const z = 'z'
+ *
+ * semigroupString.concat(x, y) // 'xy'
+ *
+ * semigroupString.concat(x, semigroupString.concat(y, z)) // 'xyz'
+ *
+ * semigroupString.concat(semigroupString.concat(x, y), z) // 'xyz'
+ * ```
+ *
+ * *Adapted from https://typelevel.org/cats*
+ *
+ * @since 2.0.0
+ */
+/**
+ * Given a struct of semigroups returns a semigroup for the struct.
+ *
+ * @example
+ * import { struct } from 'fp-ts/Semigroup'
+ * import * as N from 'fp-ts/number'
+ *
+ * interface Point {
+ *   readonly x: number
+ *   readonly y: number
+ * }
+ *
+ * const S = struct<Point>({
+ *   x: N.SemigroupSum,
+ *   y: N.SemigroupSum
+ * })
+ *
+ * assert.deepStrictEqual(S.concat({ x: 1, y: 2 }, { x: 3, y: 4 }), { x: 4, y: 6 })
+ *
+ * @since 2.10.0
+ */
+var struct = function (semigroups) { return ({
+    concat: function (first, second) {
+        var r = {};
+        for (var k in semigroups) {
+            if (has.call(semigroups, k)) {
+                r[k] = semigroups[k].concat(first[k], second[k]);
+            }
+        }
+        return r;
+    }
+}); };
+// -------------------------------------------------------------------------------------
+// instances
+// -------------------------------------------------------------------------------------
+/**
+ * Always return the first argument.
+ *
+ * @example
+ * import * as S from 'fp-ts/Semigroup'
+ *
+ * assert.deepStrictEqual(S.first<number>().concat(1, 2), 1)
+ *
+ * @category instances
+ * @since 2.10.0
+ */
+var first = function () { return ({ concat: identity }); };
+/**
+ * Always return the last argument.
+ *
+ * @example
+ * import * as S from 'fp-ts/Semigroup'
+ *
+ * assert.deepStrictEqual(S.last<number>().concat(1, 2), 2)
+ *
+ * @category instances
+ * @since 2.10.0
+ */
+var last = function () { return ({ concat: function (_, y) { return y; } }); };
+/**
+ * Use [`SemigroupSum`](./number.ts.html#SemigroupSum) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+var semigroupSum = {
+    concat: function (x, y) { return x + y; }
+};
+
+const semigroupDiff = {
+  concat: (x, y) => x - y,
+};
+
+const fromRectangle$1 = ({ x, y }) => {
+  return {
+    x,
+    y,
+  };
+};
+const fromMouseEvent = ({ clientX, clientY }) => {
+  return {
+    x: clientX,
+    y: clientY,
+  };
+};
+const pointDiffSemigroup = struct({
+  x: semigroupDiff,
+  y: semigroupDiff,
+});
+const pointSumSemigroup = struct({
+  x: semigroupSum,
+  y: semigroupSum,
+});
+
+exports.HandlerDirection = void 0;
+(function (HandlerDirection) {
+  HandlerDirection[HandlerDirection["East"] = 0] = "East";
+  HandlerDirection[HandlerDirection["North"] = 1] = "North";
+  HandlerDirection[HandlerDirection["NorthEast"] = 2] = "NorthEast";
+  HandlerDirection[HandlerDirection["NorthWest"] = 3] = "NorthWest";
+  HandlerDirection[HandlerDirection["South"] = 4] = "South";
+  HandlerDirection[HandlerDirection["SouthEast"] = 5] = "SouthEast";
+  HandlerDirection[HandlerDirection["SouthWest"] = 6] = "SouthWest";
+  HandlerDirection[HandlerDirection["West"] = 7] = "West";
+})(exports.HandlerDirection || (exports.HandlerDirection = {}));
+const getCursorValue = (direction) => {
+  switch (direction) {
+    case exports.HandlerDirection.East:
+      return "e-resize";
+    case exports.HandlerDirection.North:
+      return "n-resize";
+    case exports.HandlerDirection.NorthEast:
+      return "ne-resize";
+    case exports.HandlerDirection.NorthWest:
+      return "nw-resize";
+    case exports.HandlerDirection.South:
+      return "s-resize";
+    case exports.HandlerDirection.SouthEast:
+      return "se-resize";
+    case exports.HandlerDirection.SouthWest:
+      return "sw-resize";
+    case exports.HandlerDirection.West:
+      return "w-resize";
+    default:
+      return "pointer";
+  }
+};
+const fromRectangle = (r) => [
+  {
+    position: fromRectangle$1(r),
+    direction: exports.HandlerDirection.NorthWest,
+  },
+  {
+    position: pointSumSemigroup.concat(fromRectangle$1(r), {
+      x: r.width,
+      y: 0,
+    }),
+    direction: exports.HandlerDirection.NorthEast,
+  },
+  {
+    position: pointSumSemigroup.concat(fromRectangle$1(r), {
+      x: 0,
+      y: r.height,
+    }),
+    direction: exports.HandlerDirection.SouthWest,
+  },
+  {
+    position: pointSumSemigroup.concat(fromRectangle$1(r), {
+      x: r.width,
+      y: r.height,
+    }),
+    direction: exports.HandlerDirection.SouthEast,
+  },
+];
+
+exports.dual = dual;
+exports.first = first;
+exports.flatMapTask = flatMapTask;
+exports.fromMouseEvent = fromMouseEvent;
+exports.fromRectangle = fromRectangle$1;
+exports.fromRectangle$1 = fromRectangle;
+exports.getCursorValue = getCursorValue;
+exports.has = has;
+exports.identity = identity;
+exports.isLeft = isLeft;
+exports.isNone = isNone;
+exports.isSome = isSome;
+exports.last = last;
+exports.left = left;
+exports.none = none;
+exports.pipe = pipe;
+exports.pointDiffSemigroup = pointDiffSemigroup;
+exports.pointSumSemigroup = pointSumSemigroup;
+exports.right = right;
+exports.some = some;
+exports.struct = struct;
+exports.tuple = tuple;

package/dist/cjs/cropper-handler.cjs.entry.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const index = require('./index-a4becaff.js');
+const Handler = require('./Handler-de64afa5.js');
+
+const cropperHandlerCss = ":host{--size:20px;background:transparent;border:4px solid white;box-sizing:content-box;display:block;height:var(--size);touch-action:none;position:absolute;width:var(--size);z-index:4;-webkit-user-select:none;-moz-user-select:none;user-select:none}:host(.disabled){opacity:0.25}:host(.nw-resize){border-bottom:none;border-right:none;top:0;left:0}:host(.ne-resize){border-left:none;border-bottom:none;right:0;top:0}:host(.sw-resize){border-right:none;border-top:none;left:0;bottom:0}:host(.se-resize){border-left:none;border-top:none;bottom:0;right:0}";
+
+const CropperHandler = class {
+  constructor(hostRef) {
+    index.registerInstance(this, hostRef);
+    this.handler = undefined;
+    this.disabled = false;
+  }
+  render() {
+    return (index.h(index.Host, { part: `handle ${Handler.getCursorValue(this.handler.direction)}`, class: {
+        disabled: this.disabled,
+        [Handler.getCursorValue(this.handler.direction)]: true,
+      }, style: {
+        "--size": "20px",
+        cursor: Handler.getCursorValue(this.handler.direction),
+      }, draggable: false }));
+  }
+};
+CropperHandler.style = cropperHandlerCss;
+
+exports.cropper_handler = CropperHandler;

package/dist/cjs/customized-slots-aee3f39d.js

@@ -0,0 +1,54 @@
+'use strict';
+
+const index = require('./index-a4becaff.js');
+
+const defaultSlotsNames = [
+  "vviinn-onboarding-title",
+  "onboarding-card-1-icon",
+  "onboarding-card-1-text",
+  "onboarding-card-2-icon",
+  "onboarding-card-2-text",
+  "onboarding-card-3-icon",
+  "onboarding-card-3-text",
+  "vviinn-example-images-title",
+  "vviinn-example-images-1",
+  "vviinn-example-images-2",
+  "vviinn-example-images-3",
+  "vviinn-example-images-4",
+  "vviinn-teaser-text",
+  "vviinn-image-upload-button-text",
+  "vviinn-privacy-badge-text",
+  "vviinn-image-search-modal-title",
+];
+const renderNamedSlot = (name) => index.h("slot", { name: name });
+const SlotSkeleton = () => defaultSlotsNames.map(renderNamedSlot);
+const getSlots = (element) => Array.from(element.shadowRoot.querySelectorAll("slot"));
+const getNameAttribute = (element) => element.getAttribute("name");
+const getSlotAttribute = (element) => element.getAttribute("slot");
+const elementContainSlot = (slot) => (container) => {
+  const name1 = getNameAttribute(slot);
+  const name2 = getSlotAttribute(container);
+  return name1 === name2;
+};
+const getContentToReplace = (targets) => (acc, content) => {
+  const replaceCandidate = targets.find(elementContainSlot(content));
+  if (replaceCandidate) {
+    acc.set(content, replaceCandidate);
+  }
+  return acc;
+};
+const replaceSlotContent = (content, target) => {
+  target.innerHTML = content.outerHTML;
+};
+const slotChangeListener = (component, element) => {
+  component.connectedCallback = function () {
+    document.addEventListener("globalSlotsChanged", ({ detail }) => {
+      const slotsToReplace = getSlots(element).reduce(getContentToReplace(detail), new Map());
+      slotsToReplace.forEach(replaceSlotContent);
+    }, true);
+  };
+  component.connectedCallback.call(component);
+};
+
+exports.SlotSkeleton = SlotSkeleton;
+exports.slotChangeListener = slotChangeListener;