stimulus-library 0.7.5 → 0.8.0-beta

package/dist/utilities/events.js

@@ -0,0 +1,10 @@
+import { logEvent } from "./logging";
+export function dispatchEvent(controller, element, eventName, options = {}) {
+    let mergedOptions = Object.assign({}, { bubbles: true, cancelable: true, detail: { target: element } }, options);
+    if (!mergedOptions.detail.target) {
+        mergedOptions.detail.target = element;
+    }
+    let event = new CustomEvent(eventName, mergedOptions);
+    logEvent(controller, eventName, event, element);
+    element.dispatchEvent(event);
+}

package/dist/utilities/fetchRetry.js

@@ -0,0 +1,22 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export function fetchRetry(n, input, init) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return yield fetch(input, init);
+        }
+        catch (err) {
+            if (n === 1) {
+                throw err;
+            }
+            return yield fetchRetry(n - 1, input, init);
+        }
+    });
+}

package/dist/utilities/{index.d.ts → index.js}

@@ -5,4 +5,3 @@ export * from "./turbo";
 export * from "./event_bus";
 export * from "./request_submit";
 export * from "./elements";
-//# sourceMappingURL=index.d.ts.map

package/dist/utilities/logging.js

@@ -0,0 +1,82 @@
+export function logProperty(prop) {
+    switch (prop) {
+        case "application":
+        case "el":
+        case "element":
+        case "constructor":
+        case "initialize":
+        case "log":
+        case "logEvent":
+        case "dispatch":
+        case "data":
+        case "valueDescriptorMap":
+        case "mutate":
+        case "identifier":
+            return false;
+    }
+    if (/^_.*?$/.test(prop)) {
+        return false;
+    }
+    if (/^.*?Target(s)?$/.test(prop)) {
+        return false;
+    }
+    if (/^.*?Value$/.test(prop)) {
+        return false;
+    }
+    if (/^.*?ValueChanged$/.test(prop)) {
+        return false;
+    }
+    if (/^.*?Class$/.test(prop)) {
+        return false;
+    }
+    if (/^.*?Classes$/.test(prop)) {
+        return false;
+    }
+    if (/^.*?ClassesPresent$/.test(prop)) {
+        return false;
+    }
+    return true;
+}
+export function log(controller, functionName, args = {}) {
+    if (!controller.application.debug) {
+        return;
+    }
+    let logger = console;
+    logger.groupCollapsed(...colorize(controller.identifier, "#3B82F6"), `#${functionName}`);
+    logger.log(Object.assign({ element: controller.element, controller: controller }, args));
+    logger.groupEnd();
+}
+export function warn(controller, warning, args = {}) {
+    if (!controller.application.debug) {
+        return;
+    }
+    let logger = console;
+    logger.groupCollapsed(...colorize(controller.identifier, "#F39B1AFF"), `!! ${warning} !!`);
+    logger.warn(Object.assign({ element: controller.element, controller: controller }, args));
+    logger.groupEnd();
+}
+export function logEvent(controller, eventName, event, element) {
+    if (!controller.application.debug) {
+        return;
+    }
+    let logger = console;
+    logger.groupCollapsed(...colorizeMany([
+        { text: controller.identifier, color: "#3B82F6" },
+        { text: eventName, color: "#0be000" },
+    ]), event.detail);
+    logger.log(...colorize("Dispatched on", "#3b82f6"), element);
+    logger.log(...colorize("event", "#3b82f6"), event);
+    logger.log(...colorize("event details", "#3b82f6"), event.detail);
+    logger.groupEnd();
+}
+function colorize(text, color) {
+    return colorizeMany([{ text, color }]);
+}
+function colorizeMany(texts) {
+    let str = "";
+    let colors = texts.flatMap(x => {
+        str += `%c${x.text}%c `;
+        return [`color: ${x.color}`, "color: unset"];
+    });
+    return [str, ...colors];
+}

package/dist/utilities/reactive.js

@@ -0,0 +1,23 @@
+export function reactive(object) {
+    if (object === null || typeof object !== 'object') {
+        return object;
+    }
+    for (const property in object) {
+        if (Object.getOwnPropertyDescriptor(object, property) == undefined) {
+            continue;
+        }
+        // @ts-ignore
+        object[property] = reactive(object[property]);
+    }
+    return new Proxy(object, {
+        get(target, property) {
+            // @ts-ignore
+            return target[property];
+        },
+        set(target, property, value) {
+            // @ts-ignore
+            target[property] = reactive(value);
+            return true;
+        },
+    });
+}

package/dist/utilities/request_submit.js

@@ -0,0 +1,20 @@
+import { insertHiddenButton } from "./elements";
+export function requestSubmit(form) {
+    if (form.requestSubmit) {
+        form.requestSubmit();
+    }
+    else {
+        let button = form.querySelector('button[type="submit"]');
+        if (!button) {
+            button = insertHiddenButton("submit", form, 'beforeend');
+        }
+        button.click();
+    }
+}
+export function requestReset(form) {
+    let button = form.querySelector('button[type="reset"]');
+    if (!button) {
+        button = insertHiddenButton("reset", form, 'beforeend');
+    }
+    button.click();
+}

package/dist/utilities/scroll.js

@@ -0,0 +1,89 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import smoothScroll from 'smoothscroll-polyfill';
+export function scrollToElement(element, { behavior = "smooth", block = "start", inline = "nearest" } = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        smoothScroll.polyfill();
+        element.scrollIntoView({ behavior, block, inline });
+    });
+}
+export function scrollAbsoluteTop(element, { behavior = "smooth" } = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        smoothScroll.polyfill();
+        element.scrollTo({ top: 0, left: 0, behavior });
+    });
+}
+export function scrollAbsoluteBottom(element, { behavior = "smooth" } = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        smoothScroll.polyfill();
+        if (element == window) {
+            element.scrollTo({ top: document.body.scrollHeight, left: 0, behavior });
+        }
+        else {
+            element.scrollTo({ top: element.scrollHeight, left: 0, behavior });
+        }
+    });
+}
+export function scrollAbsoluteLeft(element, { behavior = "smooth" } = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        smoothScroll.polyfill();
+        element.scrollTo({ left: 0, behavior });
+    });
+}
+export function scrollAbsoluteRight(element, { behavior = "smooth" } = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        smoothScroll.polyfill();
+        if (element == window) {
+            element.scrollTo({ left: document.body.scrollWidth, behavior });
+        }
+        else {
+            element.scrollTo({ left: element.scrollWidth, behavior });
+        }
+    });
+}
+export function scrollUp(element, amount, { behavior = "smooth" } = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        smoothScroll.polyfill();
+        element.scrollBy({ top: -amount, left: 0, behavior });
+    });
+}
+export function scrollDown(element, amount, { behavior = "smooth" } = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        smoothScroll.polyfill();
+        element.scrollBy({ top: amount, left: 0, behavior });
+    });
+}
+export function scrollLeft(element, amount, { behavior = "smooth" } = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        smoothScroll.polyfill();
+        element.scrollBy({ top: 0, left: -amount, behavior });
+    });
+}
+export function scrollRight(element, amount, { behavior = "smooth" } = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        smoothScroll.polyfill();
+        element.scrollBy({ top: 0, left: amount, behavior });
+    });
+}
+export function getScrollParent(node) {
+    smoothScroll.polyfill();
+    if (!node) {
+        return null;
+    }
+    if (node == document.body) {
+        return window;
+    }
+    const overflowY = getComputedStyle(node).overflowY;
+    const isScrollable = overflowY !== "visible" && overflowY !== "hidden";
+    if (isScrollable && node.scrollHeight >= node.clientHeight) {
+        return node;
+    }
+    return getScrollParent(node.parentElement) || document.body;
+}

package/dist/utilities/stimulus.js

@@ -0,0 +1,13 @@
+export function controllerMethod(controller, methodName) {
+    // @ts-ignore
+    const method = controller[methodName];
+    if (typeof method == 'function') {
+        return method;
+    }
+    else if (method != undefined) {
+        return () => method;
+    }
+    else {
+        return () => void 0;
+    }
+}

package/dist/utilities/strings.js

@@ -0,0 +1,5 @@
+import camelCase from "lodash-es/camelCase";
+import upperFirst from "lodash-es/upperFirst";
+export function pascalCase(str) {
+    return upperFirst(camelCase(str));
+}

package/dist/utilities/turbo.js

@@ -0,0 +1,3 @@
+export function isTurboFrame(element) {
+    return element.nodeName == "TURBO-FRAME";
+}

package/package.json

@@ -9,7 +9,7 @@
     "ruby on rails",
     "ruby-on-rails"
   ],
-  "version": "0.7.5",
+  "version": "0.8.0-beta",
   "license": "MIT",
   "author": {
     "name": "Sub-Xaero",
@@ -23,39 +23,32 @@
   "files": [
     "dist"
   ],
-  "source": "src/index.ts",
-  "main": "dist/stimulus-library.umd.js",
-  "module": "dist/stimulus-library.es.js",
+  "module": "dist/index.js",
   "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/stimulus-library.es.js",
-      "require": "./dist/stimulus-library.umd.js"
-    }
-  },
   "scripts": {
-    "build": "vite build && tsc --emitDeclarationOnly",
-    "dev": "vite build --watch",
-    "dev:types": "tsc --emitDeclarationOnly --watch",
+    "build": "tsc",
+    "dev": "tsc --watch",
     "prepack": "yarn build",
     "release": "standard-version",
     "test": "cypress run",
-    "test:treeshake": "agadoo dist stimulus-library.js"
+    "test:treeshake": "agadoo dist"
   },
   "dependencies": {
-    "mitt": "^3.0.0"
+    "@babel/runtime": "^7.17.9",
+    "@hotwired/stimulus": "^3.0.1",
+    "date-fns": "^2.28.0",
+    "dialog-polyfill": "^0.5.6",
+    "lodash-es": "^4.17.21",
+    "mitt": "^3.0.0",
+    "smoothscroll-polyfill": "^0.4.4"
   },
   "devDependencies": {
     "@types/lodash-es": "^4.17.6",
     "@types/smoothscroll-polyfill": "^0.3.1",
-    "@hotwired/stimulus": "^3.0.1",
     "agadoo": "^2.0.0",
-    "date-fns": "^2.28.0",
-    "dialog-polyfill": "^0.5.6",
-    "lodash-es": "^4.17.21",
     "cypress": "^9.4.1",
+    "fast-glob": "^3.2.11",
     "rimraf": "^3.0.2",
-    "smoothscroll-polyfill": "^0.4.4",
     "standard-version": "^9.3.2",
     "typescript": "^4.5.5",
     "vite": "^2.7.13"