vviinn-widgets 2.1.0 → 2.2.2

package/dist/collection/stories/teaser.stories.js

@@ -0,0 +1,5 @@
+export default {
+  title: 'Components/Teaser',
+};
+const Template = () => "<vviinn-teaser />";
+export const Default = Template.bind({});

package/dist/collection/stories/vps-widget.stories.js

@@ -0,0 +1,47 @@
+export default {
+  title: "Widgets/VPS",
+  component: "vviinn-vps-widget"
+};
+const Template = () => "<vviinn-vps-widget></vviinn-vps-widget>";
+export const Default = Template.bind({});
+Default.storyName = "Modal window";
+Default.decorators = [(Story) => `
+<style>
+.sb-show-main.sb-main-padded {
+  padding: unset;
+}
+
+#root {
+  align-content: center;
+  display: grid;
+  height: 100vh;
+  justify-items: center;
+}
+
+button {
+  align-items: center;
+  background: #F4F4F4;
+  border: none;
+  border-radius: 6px;
+  cursor: pointer;
+  display: grid;
+  height: 48px;
+  justify-items: center;
+  width: 48px;
+}
+</style>
+<button onclick="showModal()">
+<svg xmlns="http://www.w3.org/2000/svg" width="28" height="28" fill="none">
+  <defs/>
+  <path fill="#525252" fill-rule="evenodd" d="M9.771 3.89a.875.875 0 01.728-.39h7c.293 0 .566.146.728.39l1.49 2.235h3.033a2.625 2.625 0 012.625 2.625V21a2.625 2.625 0 01-2.625 2.625H5.25A2.625 2.625 0 012.625 21V8.75A2.625 2.625 0 015.25 6.125h3.031l1.49-2.235zm1.197 1.36l-1.49 2.235a.875.875 0 01-.729.39H5.25a.875.875 0 00-.875.875V21a.875.875 0 00.875.875h17.5a.875.875 0 00.875-.875V8.75a.875.875 0 00-.875-.875h-3.5a.875.875 0 01-.729-.39l-1.49-2.235h-6.063z" clip-rule="evenodd"/>
+  <path fill="#525252" fill-rule="evenodd" d="M14 11.375a3.062 3.062 0 100 6.125 3.062 3.062 0 000-6.125zm-4.813 3.063a4.812 4.812 0 119.625 0 4.812 4.812 0 01-9.625 0z" clip-rule="evenodd"/>
+</svg>
+</button>
+${Story()}
+<script>
+function showModal () {
+  const modal = document.querySelector("vviinn-vps-widget");
+  modal.active = true;
+}
+</script>
+`];

package/dist/collection/stories/vviinn-product.stories.js

@@ -0,0 +1,19 @@
+export default {
+  title: "Components/Product",
+  component: "vviinn-product-card",
+};
+const Template = ({ productTitle, brand, productType, price, image }) => `<vviinn-product-card
+     product-title="${productTitle}"
+     brand="${brand}"
+     product-type="${productType}"
+     price="${price}"
+     image="${image}"
+   ></vviinn-product-card>`;
+export const Default = Template.bind({});
+Default.args = {
+  productTitle: "1968 Fender Precision Bass Vintage Electric Bass Guitar Sunburst 100% Original Case",
+  productType: "Bass guitar",
+  brand: "Fender",
+  price: 624244,
+  image: "https://images.reverb.com/image/upload/s--pj8uk5Tr--/t_card-square/v1627963897/tcm9cwywsxfzrsnip3tm.jpg"
+};

package/dist/collection/utils/collections/collectionsUtils.js

@@ -0,0 +1,5 @@
+import * as E from "fp-ts/Either";
+import { pipe } from "fp-ts/function";
+export const isEmpty = (x) => x.length === 0;
+const checkEmpty = (x) => isEmpty(x) ? E.left("entity is empty") : E.right(x);
+export const existAndNotEmpty = (x) => pipe(x, E.fromNullable("entity not exist"), E.chain(checkEmpty));

package/dist/collection/utils/either.js

@@ -0,0 +1,3 @@
+import { sequenceT } from "fp-ts/lib/Apply";
+import { Apply } from "fp-ts/lib/Either";
+export const sequenceToEither = sequenceT(Apply);

package/dist/collection/utils/enum/enumUtils.js

@@ -0,0 +1,3 @@
+export const listValues = (e) => Object.values(e)
+  .filter((val) => typeof val === "string")
+  .map((c) => c);

package/dist/collection/utils/event/Events.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/utils/number/index.js

@@ -0,0 +1,4 @@
+export const numberUnderDivisionSemigroup = {
+  concat: (x, y) => x / y,
+};
+export const numberUnderDivisionMonoid = Object.assign(Object.assign({}, numberUnderDivisionSemigroup), { empty: 1 });

package/dist/collection/utils/option/option.js

@@ -0,0 +1,4 @@
+import { sequenceT } from "fp-ts/lib/Apply";
+import { Apply, some, none } from "fp-ts/lib/Option";
+export const sequenceToOption = sequenceT(Apply);
+export const checkEmpryString = (x) => x.length > 0 ? some(x) : none;

package/dist/collection/utils/semigroup/semigroupDiff.js

@@ -0,0 +1,6 @@
+export const semigroupDiff = {
+  concat: (x, y) => x - y,
+};
+export const semigroupDiv = {
+  concat: (x, y) => x / y,
+};

package/dist/collection/utils/token/tokenUtils.js

@@ -0,0 +1,9 @@
+import { pipe } from "fp-ts/function";
+import * as E from "fp-ts/lib/Either";
+import { invalidTokenError } from "../../error";
+import { existAndNotEmpty } from "../collections/collectionsUtils";
+export const createBearerHeaders = (token) => new Headers({
+  Authorization: `Bearer ${token}`,
+});
+export const checkToken = (token) => pipe(token, existAndNotEmpty, E.mapLeft(() => invalidTokenError));
+export const processBearerToken = (token) => pipe(token, checkToken, E.map(createBearerHeaders));

package/dist/esm/Handler-639a4cb3.js

@@ -0,0 +1,308 @@
+// -------------------------------------------------------------------------------------
+/**
+ * @since 2.0.0
+ */
+function identity(a) {
+    return a;
+}
+function flow(ab, bc, cd, de, ef, fg, gh, hi, ij) {
+    switch (arguments.length) {
+        case 1:
+            return ab;
+        case 2:
+            return function () {
+                return bc(ab.apply(this, arguments));
+            };
+        case 3:
+            return function () {
+                return cd(bc(ab.apply(this, arguments)));
+            };
+        case 4:
+            return function () {
+                return de(cd(bc(ab.apply(this, arguments))));
+            };
+        case 5:
+            return function () {
+                return ef(de(cd(bc(ab.apply(this, arguments)))));
+            };
+        case 6:
+            return function () {
+                return fg(ef(de(cd(bc(ab.apply(this, arguments))))));
+            };
+        case 7:
+            return function () {
+                return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))));
+            };
+        case 8:
+            return function () {
+                return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))));
+            };
+        case 9:
+            return function () {
+                return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))));
+            };
+    }
+    return;
+}
+/**
+ * @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;
+    }
+}
+
+// -------------------------------------------------------------------------------------
+// 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;
+
+/**
+ * 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 })
+ *
+ * @category combinators
+ * @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 instances
+ * @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,
+});
+
+var HandlerDirection;
+(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";
+})(HandlerDirection || (HandlerDirection = {}));
+const getCursorValue = (direction) => {
+  switch (direction) {
+    case HandlerDirection.East:
+      return "e-resize";
+    case HandlerDirection.North:
+      return "n-resize";
+    case HandlerDirection.NorthEast:
+      return "ne-resize";
+    case HandlerDirection.NorthWest:
+      return "nw-resize";
+    case HandlerDirection.South:
+      return "s-resize";
+    case HandlerDirection.SouthEast:
+      return "se-resize";
+    case HandlerDirection.SouthWest:
+      return "sw-resize";
+    case HandlerDirection.West:
+      return "w-resize";
+    default:
+      return "pointer";
+  }
+};
+const fromRectangle = (r) => [
+  {
+    position: fromRectangle$1(r),
+    direction: HandlerDirection.NorthWest,
+  },
+  {
+    position: pointSumSemigroup.concat(fromRectangle$1(r), {
+      x: r.width,
+      y: 0,
+    }),
+    direction: HandlerDirection.NorthEast,
+  },
+  {
+    position: pointSumSemigroup.concat(fromRectangle$1(r), {
+      x: 0,
+      y: r.height,
+    }),
+    direction: HandlerDirection.SouthWest,
+  },
+  {
+    position: pointSumSemigroup.concat(fromRectangle$1(r), {
+      x: r.width,
+      y: r.height,
+    }),
+    direction: HandlerDirection.SouthEast,
+  },
+];
+
+export { HandlerDirection as H, isLeft as a, identity as b, flow as c, struct as d, last as e, first as f, pointSumSemigroup as g, fromRectangle$1 as h, isNone as i, isSome as j, fromRectangle as k, left as l, pointDiffSemigroup as m, none as n, fromMouseEvent as o, pipe as p, getCursorValue as q, right as r, some as s, tuple as t };