publ-echo-test 0.0.1

package/dist/lib/Draggable/utils/domHelpers.js

@@ -0,0 +1,222 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import browserPrefix, { browserPrefixToKey } from "./getPrefix";
+import { findInArray, int, isFunction } from "./validationHelpers";
+export var matchSelector = function (el, selector) {
+    var matchedSelector = "";
+    var selectors = [
+        "matches",
+        "webkitMatchesSelector",
+        // "mozMatchesSelector",
+        // "msMatchesSelector",
+        // "oMatchesSelector",
+    ];
+    var callback = function (method) {
+        return isFunction(el[method]);
+    };
+    if (!matchedSelector) {
+        matchedSelector = findInArray(selectors, callback);
+        if (matchedSelector === "matches" ||
+            matchedSelector === "webkitMatchesSelector") {
+            return el[matchedSelector](selector);
+        }
+    }
+    return false;
+};
+export var matchSelectorAndParentsTo = function (el, selector, baseNode) {
+    var node = el;
+    do {
+        if (matchSelector(node, selector))
+            return true;
+        if (node === baseNode)
+            return false;
+        if (node.parentNode)
+            node = node.parentNode;
+    } while (node);
+    return false;
+};
+export var addEvent = function (el, eventType, handler, inputOptions) {
+    if (!el)
+        return;
+    var options = __assign({ capture: true }, inputOptions);
+    if (el.addEventListener) {
+        el.addEventListener(eventType, handler, options);
+    }
+    // if (el.addEventListener) {
+    //   el.addEventListener(eventType, handler, options);
+    // } else {
+    //   (el as { [key: string]: any })['on' + eventType] = handler;
+    // }
+};
+export var removeEvent = function (el, eventType, handler, inputOptions) {
+    if (!el)
+        return;
+    var options = __assign({ capture: true }, inputOptions);
+    if (el.removeEventListener) {
+        el.removeEventListener(eventType, handler, options);
+    }
+    // if (el.removeEventListener) {
+    //   el.removeEventListener(eventType, handler, options);
+    // } else {
+    //   (el as { [key: string]: any })['on' + eventType] = null;
+    // }
+};
+export var outerHeight = function (node) {
+    var _a;
+    var height = node.clientHeight;
+    var computedStyle = (_a = node.ownerDocument.defaultView) === null || _a === void 0 ? void 0 : _a.getComputedStyle(node);
+    if (computedStyle) {
+        height += int(computedStyle.borderTopWidth);
+        height += int(computedStyle.borderBottomWidth);
+        return height;
+    }
+    else {
+        return height;
+    }
+};
+export var outerWidth = function (node) {
+    var _a;
+    var width = node.clientWidth;
+    var computedStyle = (_a = node.ownerDocument.defaultView) === null || _a === void 0 ? void 0 : _a.getComputedStyle(node);
+    if (computedStyle) {
+        width += int(computedStyle.borderLeftWidth);
+        width += int(computedStyle.borderRightWidth);
+        return width;
+    }
+    else {
+        return width;
+    }
+};
+export var innerHeight = function (node) {
+    var _a;
+    var height = node.clientHeight;
+    var computedStyle = (_a = node.ownerDocument.defaultView) === null || _a === void 0 ? void 0 : _a.getComputedStyle(node);
+    if (computedStyle) {
+        height -= int(computedStyle.paddingTop);
+        height -= int(computedStyle.paddingBottom);
+        return height;
+    }
+    else {
+        return height;
+    }
+};
+export var innerWidth = function (node) {
+    var _a;
+    var width = node.clientWidth;
+    var computedStyle = (_a = node.ownerDocument.defaultView) === null || _a === void 0 ? void 0 : _a.getComputedStyle(node);
+    if (computedStyle) {
+        width -= int(computedStyle.paddingLeft);
+        width -= int(computedStyle.paddingRight);
+        return width;
+    }
+    else {
+        return width;
+    }
+};
+export var offsetXYFromParent = function (evt, offsetParent, scale) {
+    var isBody = offsetParent.ownerDocument.body;
+    var offsetParentRect = isBody
+        ? { left: 0, top: 0 }
+        : offsetParent.getBoundingClientRect();
+    var x = (evt.clientX + offsetParent.scrollLeft - offsetParentRect.left) / scale;
+    var y = (evt.clientY + offsetParent.scrollTop - offsetParentRect.top) / scale;
+    return { x: x, y: y };
+};
+export var createCSSTransform = function (controlPos, positionOffset) {
+    var _a;
+    var translation = getTranslation(controlPos, "px", positionOffset);
+    return _a = {}, _a[browserPrefixToKey("transform", browserPrefix)] = translation, _a;
+};
+export var createSVGTransform = function (controlPos, positionOffset) {
+    var translation = getTranslation(controlPos, "", positionOffset);
+    return translation;
+};
+export var getTranslation = function (_a, unitSuffix, positionOffset) {
+    var x = _a.x, y = _a.y;
+    var translation = "translate(".concat(x).concat(unitSuffix, ",").concat(y).concat(unitSuffix, ")");
+    if (positionOffset) {
+        var defaultX = "".concat(typeof positionOffset.x === "string"
+            ? positionOffset.x
+            : positionOffset.x + unitSuffix);
+        var defaultY = "".concat(typeof positionOffset.y === "string"
+            ? positionOffset.y
+            : positionOffset.y + unitSuffix);
+        translation = "translate(".concat(defaultX, ", ").concat(defaultY, ")") + translation;
+    }
+    return translation;
+};
+export var getTouch = function (e, identifier) {
+    return ((e.targetTouches &&
+        findInArray(e.targetTouches, function (t) { return identifier === t.identifier; })) ||
+        (e.changedTouches &&
+            findInArray(e.changedTouches, function (t) { return identifier === t.identifier; })));
+};
+export var getTouchIdentifier = function (e) {
+    if (e.targetTouches && e.targetTouches[0]) {
+        return e.targetTouches[0].identifier;
+    }
+    if (e.changedTouches && e.changedTouches[0]) {
+        return e.changedTouches[0].identifier;
+    }
+};
+export var addUserSelectStyles = function (doc) {
+    if (!doc)
+        return;
+    var styleEl = doc.getElementById("react-draggable-style-el");
+    if (!styleEl) {
+        styleEl = doc.createElement("style");
+        styleEl.id = "react-draggable-style-el";
+        styleEl.innerHTML =
+            ".react-draggable-transparent-selection *::-moz-selection {all: inherit;}\n";
+        styleEl.innerHTML +=
+            ".react-draggable-transparent-selection *::selection {all: inherit;}\n";
+        doc.getElementsByTagName("head")[0].appendChild(styleEl);
+    }
+    if (doc.body)
+        addClassName(doc.body, "react-draggable-transparent-selection");
+};
+export var removeUserSelectStyles = function (doc) {
+    var _a;
+    if (!doc)
+        return;
+    if (doc.body) {
+        removeClassName(doc.body, "react-draggable-transparent-selection");
+    }
+    if (doc.getSelection()) {
+        (_a = doc.getSelection()) === null || _a === void 0 ? void 0 : _a.empty();
+    }
+    else {
+        var selection = (doc.defaultView || window).getSelection();
+        if (selection && selection.type !== "Caret") {
+            selection.removeAllRanges();
+        }
+    }
+};
+export var addClassName = function (el, className) {
+    if (el.classList) {
+        el.classList.add(className);
+    }
+    else {
+        if (!el.className.match(new RegExp("(?:^|\\s)".concat(className, "(?!\\S)")))) {
+            el.className += " ".concat(className);
+        }
+    }
+};
+export var removeClassName = function (el, className) {
+    if (el.classList) {
+        el.classList.remove(className);
+    }
+    else {
+        el.className = el.className.replace(new RegExp("(?:^|\\s)".concat(className, "(?!\\S)"), "g"), "");
+    }
+};

package/dist/lib/Draggable/utils/getPrefix.d.ts

@@ -0,0 +1,5 @@
+export declare function getPrefix(prop?: string): string;
+export declare function browserPrefixToKey(prop: string, prefix: string): string;
+export declare function browserPrefixToStyle(prop: string, prefix: string): string;
+declare const _default: string;
+export default _default;

package/dist/lib/Draggable/utils/getPrefix.js

@@ -0,0 +1,41 @@
+var prefixes = ["Moz", "Webkit", "O", "ms"];
+export function getPrefix(prop) {
+    var _a, _b;
+    if (prop === void 0) { prop = "transform"; }
+    if (typeof window === "undefined")
+        return "";
+    var style = (_b = (_a = window.document) === null || _a === void 0 ? void 0 : _a.documentElement) === null || _b === void 0 ? void 0 : _b.style;
+    if (!style)
+        return "";
+    if (prop in style)
+        return "";
+    for (var i = 0; i < prefixes.length; i++) {
+        if (browserPrefixToKey(prop, prefixes[i]) in style)
+            return prefixes[i];
+    }
+    return "";
+}
+export function browserPrefixToKey(prop, prefix) {
+    return prefix ? "".concat(prefix).concat(kebabToTitleCase(prop)) : prop;
+}
+export function browserPrefixToStyle(prop, prefix) {
+    return prefix ? "-".concat(prefix.toLowerCase(), "-").concat(prop) : prop;
+}
+function kebabToTitleCase(str) {
+    var out = "";
+    var shouldCapitalize = true;
+    for (var i = 0; i < str.length; i++) {
+        if (shouldCapitalize) {
+            out += str[i].toUpperCase();
+            shouldCapitalize = false;
+        }
+        else if (str[i] === "-") {
+            shouldCapitalize = true;
+        }
+        else {
+            out += str[i];
+        }
+    }
+    return out;
+}
+export default getPrefix();

package/dist/lib/Draggable/utils/positionHelpers.d.ts

@@ -0,0 +1,7 @@
+import { AxisType, DraggableData, DraggableState } from "./../types";
+import type { Bounds } from "./types";
+export declare function snapToGrid(grid: [number, number], pendingX: number, pendingY: number): [number, number];
+export declare function canDragX(axis: AxisType): boolean;
+export declare function canDragY(axis: AxisType): boolean;
+export declare const cloneBounds: (bounds: Bounds) => Bounds;
+export declare const createDraggableData: (draggableState: DraggableState, scale: number, coreData: DraggableData) => DraggableData;

package/dist/lib/Draggable/utils/positionHelpers.js

@@ -0,0 +1,32 @@
+export function snapToGrid(grid, pendingX, pendingY) {
+    var x = Math.round(pendingX / grid[0]) * grid[0];
+    var y = Math.round(pendingY / grid[1]) * grid[1];
+    return [x, y];
+}
+export function canDragX(axis) {
+    return axis === "both" || axis === "x";
+}
+export function canDragY(axis) {
+    return axis === "both" || axis === "y";
+}
+export var cloneBounds = function (bounds) {
+    return {
+        left: bounds.left,
+        top: bounds.top,
+        right: bounds.right,
+        bottom: bounds.bottom,
+    };
+};
+export var createDraggableData = function (draggableState, scale, coreData) {
+    var deltaX = coreData.deltaX / scale;
+    var deltaY = coreData.deltaY / scale;
+    return {
+        node: coreData.node,
+        x: draggableState.x + deltaX,
+        y: draggableState.y + deltaY,
+        deltaX: deltaX,
+        deltaY: deltaY,
+        lastX: draggableState.x,
+        lastY: draggableState.y,
+    };
+};

package/dist/lib/Draggable/utils/types.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="react" />
+import { DraggableData } from "../types";
+export type DraggableEvent = React.MouseEvent<HTMLElement | SVGElement> | React.TouchEvent<HTMLElement | SVGElement> | MouseEvent | TouchEvent;
+export type DraggableEventHandler = (e: MouseEvent, data: DraggableData, el?: HTMLElement | null) => void | false;
+export type Bounds = {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+};
+export type ControlPosition = {
+    x: number;
+    y: number;
+};
+export type PositionOffsetControlPosition = {
+    x: number | string;
+    y: number | string;
+};
+export type EventHandler<T> = (e: T) => void | false;
+export interface SVGElement extends HTMLElement {
+}
+export interface TouchEvent2 extends TouchEvent {
+    changedTouches: TouchList;
+    targetTouches: TouchList;
+}
+export type MouseTouchEvent = MouseEvent & TouchEvent2;
+export type EventWithOffset = {
+    clientX: number;
+    clientY: number;
+};

package/dist/lib/Draggable/utils/types.js

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

package/dist/lib/Draggable/utils/validationHelpers.d.ts

@@ -0,0 +1,4 @@
+export declare const findInArray: (array: Array<any> | TouchList, callback: Function) => any;
+export declare const isFunction: (func: any) => boolean;
+export declare const isNum: (num: any) => boolean;
+export declare const int: (a: string) => number;

package/dist/lib/Draggable/utils/validationHelpers.js

@@ -0,0 +1,16 @@
+export var findInArray = function (array, callback) {
+    for (var i = 0, length_1 = array.length; i < length_1; i++) {
+        if (callback.apply(callback, [array[i], i, array]))
+            return array[i];
+    }
+};
+export var isFunction = function (func) {
+    return (typeof func === "function" ||
+        Object.prototype.toString.call(func) === "[object Function]");
+};
+export var isNum = function (num) {
+    return typeof num === "number" && !isNaN(num);
+};
+export var int = function (a) {
+    return parseInt(a, 10);
+};

package/dist/lib/GridItem/GridItem.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import { GridItemProps } from "./types";
+import { PropsWithChildren } from "../types";
+declare const GridItem: ({ children, ...props }: PropsWithChildren<GridItemProps>) => React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+export default GridItem;