@studiometa/js-toolkit 2.0.0-beta.10 → 2.0.0-beta.14

package/helpers/importWhenIdle.js

@@ -1,19 +1,14 @@
-export default function importWhenIdle(fn, options) {
-  var ResolvedClass;
-
-  var resolver = resolve => {
-    fn().then(module => {
-      ResolvedClass = 'default' in module ? module.default : module;
+function importWhenIdle(fn, options) {
+  let ResolvedClass;
+  const resolver = (resolve) => {
+    fn().then((module) => {
+      ResolvedClass = "default" in module ? module.default : module;
       resolve(ResolvedClass);
     });
   };
-
-  return new Promise(resolve => {
-    var _options$timeout;
-
-    var timeout = (_options$timeout = options === null || options === void 0 ? void 0 : options.timeout) !== null && _options$timeout !== void 0 ? _options$timeout : 1;
-
-    if (!('requestIdleCallback' in window)) {
+  return new Promise((resolve) => {
+    const timeout = options?.timeout ?? 1;
+    if (!("requestIdleCallback" in window)) {
       setTimeout(() => {
         resolver(resolve);
       }, timeout);
@@ -22,9 +17,10 @@ export default function importWhenIdle(fn, options) {
         setTimeout(() => {
           resolver(resolve);
         }, 0);
-      }, {
-        timeout: options === null || options === void 0 ? void 0 : options.timeout
-      });
+      }, { timeout: options?.timeout });
     }
   });
-}
+}
+export {
+  importWhenIdle as default
+};

package/helpers/importWhenVisible.cjs

@@ -0,0 +1,55 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+
+// packages/js-toolkit/helpers/importWhenVisible.js
+var importWhenVisible_exports = {};
+__export(importWhenVisible_exports, {
+  default: () => importWhenVisible
+});
+var import_utils = require("./utils.cjs");
+function importWhenVisible(fn, nameOrSelectorOrElement, parent, observerOptions = {}) {
+  let ResolvedClass;
+  const resolver = (resolve, cb) => {
+    fn().then((module2) => {
+      ResolvedClass = "default" in module2 ? module2.default : module2;
+      resolve(ResolvedClass);
+      if (typeof cb === "function") {
+        cb();
+      }
+    });
+  };
+  return new Promise((resolve) => {
+    const observer = new IntersectionObserver((entries) => {
+      const someEntriesAreVisible = entries.some((entry) => entry.isIntersecting);
+      if (someEntriesAreVisible) {
+        setTimeout(() => {
+          resolver(resolve, () => observer.disconnect());
+        }, 0);
+      }
+    }, observerOptions);
+    const elements = (0, import_utils.getTargetElements)(nameOrSelectorOrElement, parent?.$el);
+    elements.forEach((element) => observer.observe(element));
+  });
+}
+module.exports = __toCommonJS(importWhenVisible_exports);
+if (module.exports.default) module.exports = module.exports.default;

package/helpers/importWhenVisible.js

@@ -1,30 +1,28 @@
-import { getTargetElements } from './utils.js';
-export default function importWhenVisible(fn, nameOrSelectorOrElement, parent) {
-  var observerOptions = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-  var ResolvedClass;
-
-  var resolver = (resolve, cb) => {
-    fn().then(module => {
-      ResolvedClass = 'default' in module ? module.default : module;
+import { getTargetElements } from "./utils.js";
+function importWhenVisible(fn, nameOrSelectorOrElement, parent, observerOptions = {}) {
+  let ResolvedClass;
+  const resolver = (resolve, cb) => {
+    fn().then((module) => {
+      ResolvedClass = "default" in module ? module.default : module;
       resolve(ResolvedClass);
-
-      if (typeof cb === 'function') {
+      if (typeof cb === "function") {
         cb();
       }
     });
   };
-
-  return new Promise(resolve => {
-    var observer = new IntersectionObserver(entries => {
-      var someEntriesAreVisible = entries.some(entry => entry.isIntersecting);
-
+  return new Promise((resolve) => {
+    const observer = new IntersectionObserver((entries) => {
+      const someEntriesAreVisible = entries.some((entry) => entry.isIntersecting);
       if (someEntriesAreVisible) {
         setTimeout(() => {
           resolver(resolve, () => observer.disconnect());
         }, 0);
       }
     }, observerOptions);
-    var elements = getTargetElements(nameOrSelectorOrElement, parent === null || parent === void 0 ? void 0 : parent.$el);
-    elements.forEach(element => observer.observe(element));
+    const elements = getTargetElements(nameOrSelectorOrElement, parent?.$el);
+    elements.forEach((element) => observer.observe(element));
   });
-}
+}
+export {
+  importWhenVisible as default
+};

package/helpers/index.cjs

@@ -0,0 +1,42 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toESM = (module2, isNodeMode) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+
+// packages/js-toolkit/helpers/index.js
+var helpers_exports = {};
+__export(helpers_exports, {
+  createApp: () => import_createApp.default,
+  importOnInteraction: () => import_importOnInteraction.default,
+  importWhenIdle: () => import_importWhenIdle.default,
+  importWhenVisible: () => import_importWhenVisible.default
+});
+var import_createApp = __toESM(require("./createApp.cjs"), 1);
+var import_importOnInteraction = __toESM(require("./importOnInteraction.cjs"), 1);
+var import_importWhenIdle = __toESM(require("./importWhenIdle.cjs"), 1);
+var import_importWhenVisible = __toESM(require("./importWhenVisible.cjs"), 1);
+module.exports = __toCommonJS(helpers_exports);
+if (module.exports.default) module.exports = module.exports.default;

package/helpers/index.js

@@ -1,4 +1,10 @@
-export { default as createApp } from './createApp.js';
-export { default as importOnInteraction } from './importOnInteraction.js';
-export { default as importWhenIdle } from './importWhenIdle.js';
-export { default as importWhenVisible } from './importWhenVisible.js';
+import { default as default2 } from "./createApp.js";
+import { default as default3 } from "./importOnInteraction.js";
+import { default as default4 } from "./importWhenIdle.js";
+import { default as default5 } from "./importWhenVisible.js";
+export {
+  default2 as createApp,
+  default3 as importOnInteraction,
+  default4 as importWhenIdle,
+  default5 as importWhenVisible
+};

package/helpers/utils.cjs

@@ -0,0 +1,40 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+
+// packages/js-toolkit/helpers/utils.js
+var utils_exports = {};
+__export(utils_exports, {
+  getTargetElements: () => getTargetElements
+});
+var import_utils = require("../Base/utils.cjs");
+function getTargetElements(nameOrSelectorOrElement, context) {
+  if (typeof nameOrSelectorOrElement === "string") {
+    return (0, import_utils.getComponentElements)(nameOrSelectorOrElement, context);
+  }
+  if (!Array.isArray(nameOrSelectorOrElement)) {
+    return [nameOrSelectorOrElement];
+  }
+  return nameOrSelectorOrElement;
+}
+module.exports = __toCommonJS(utils_exports);
+if (module.exports.default) module.exports = module.exports.default;

package/helpers/utils.js

@@ -1,12 +1,13 @@
-import { getComponentElements } from '../Base/utils.js';
-export function getTargetElements(nameOrSelectorOrElement, context) {
-  if (typeof nameOrSelectorOrElement === 'string') {
+import { getComponentElements } from "../Base/utils.js";
+function getTargetElements(nameOrSelectorOrElement, context) {
+  if (typeof nameOrSelectorOrElement === "string") {
     return getComponentElements(nameOrSelectorOrElement, context);
   }
-
   if (!Array.isArray(nameOrSelectorOrElement)) {
     return [nameOrSelectorOrElement];
   }
-
   return nameOrSelectorOrElement;
-}
+}
+export {
+  getTargetElements
+};

package/index.cjs

@@ -0,0 +1,39 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toESM = (module2, isNodeMode) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+
+// packages/js-toolkit/index.js
+var js_toolkit_exports = {};
+__export(js_toolkit_exports, {
+  Base: () => import_Base.default
+});
+var import_Base = __toESM(require("./Base/index.cjs"), 1);
+__reExport(js_toolkit_exports, require("./decorators/index.cjs"));
+__reExport(js_toolkit_exports, require("./helpers/index.cjs"));
+__reExport(js_toolkit_exports, require("./services/index.cjs"));
+module.exports = __toCommonJS(js_toolkit_exports);
+if (module.exports.default) module.exports = module.exports.default;

package/index.js

@@ -1,4 +1,7 @@
-export { default as Base } from './Base/index.js';
-export * from './decorators/index.js';
-export * from './helpers/index.js';
-export * from './services/index.js';
+import { default as default2 } from "./Base/index.js";
+export * from "./decorators/index.js";
+export * from "./helpers/index.js";
+export * from "./services/index.js";
+export {
+  default2 as Base
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@studiometa/js-toolkit",
-  "version": "2.0.0-beta.10",
+  "version": "2.0.0-beta.14",
   "description": "A set of useful little bits of JavaScript to boost your project! 🚀",
   "publishConfig": {
     "access": "public"
@@ -17,16 +17,27 @@
   "homepage": "https://github.com/studiometa/js-toolkit#readme",
   "type": "module",
   "sideEffects": false,
-  "unpkg": "./index.umd.js",
   "main": "./index.js",
   "module": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./index.js",
+      "require": "./index.cjs",
+      "types": "./index.d.ts"
+    },
+    "./utils": {
+      "import": "./utils/index.js",
+      "require": "./utils/index.cjs",
+      "types": "./utils/index.d.ts"
+    }
+  },
   "keywords": [
     "js-toolkit",
     "component",
     "studiometa",
     "toolkit"
   ],
-  "types": "index.d.ts",
   "dependencies": {
     "@babel/runtime": "^7.15.4",
     "deepmerge": "^4.2.2"

package/services/Service.cjs

@@ -0,0 +1,76 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+
+// packages/js-toolkit/services/Service.js
+var Service_exports = {};
+__export(Service_exports, {
+  default: () => Service
+});
+var Service = class {
+  constructor() {
+    this.callbacks = /* @__PURE__ */ new Map();
+    this.isInit = false;
+  }
+  props;
+  updateProps(...args) {
+    this.props = args;
+    throw new Error("The `updateProps` method must be implemented.");
+  }
+  init() {
+    throw new Error("The `init` method must be implemented.");
+  }
+  kill() {
+    throw new Error("The `kill` method must be implemented.");
+  }
+  add(key, callback) {
+    if (this.has(key)) {
+      throw new Error(`A callback with the key \`${key}\` has already been registered.`);
+    }
+    if (this.callbacks.size === 0 && !this.isInit) {
+      this.init();
+      this.isInit = true;
+    }
+    this.callbacks.set(key, callback);
+  }
+  has(key) {
+    return this.callbacks.has(key);
+  }
+  get(key) {
+    return this.callbacks.get(key);
+  }
+  remove(key) {
+    this.callbacks.delete(key);
+    if (this.callbacks.size === 0 && this.isInit) {
+      this.kill();
+      this.isInit = false;
+    }
+  }
+  trigger(...args) {
+    this.callbacks.forEach(function forEachCallback(callback) {
+      callback(...args);
+    });
+    return this;
+  }
+};
+module.exports = __toCommonJS(Service_exports);
+if (module.exports.default) module.exports = module.exports.default;

package/services/Service.js

@@ -1,68 +1,49 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-export default class Service {
+class Service {
   constructor() {
-    _defineProperty(this, "props", void 0);
-
-    this.callbacks = new Map();
+    this.callbacks = /* @__PURE__ */ new Map();
     this.isInit = false;
   }
-
-  updateProps() {
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-
+  props;
+  updateProps(...args) {
     this.props = args;
-    throw new Error('The `updateProps` method must be implemented.');
+    throw new Error("The `updateProps` method must be implemented.");
   }
-
   init() {
-    throw new Error('The `init` method must be implemented.');
+    throw new Error("The `init` method must be implemented.");
   }
-
   kill() {
-    throw new Error('The `kill` method must be implemented.');
+    throw new Error("The `kill` method must be implemented.");
   }
-
   add(key, callback) {
     if (this.has(key)) {
-      throw new Error("A callback with the key `".concat(key, "` has already been registered."));
+      throw new Error(`A callback with the key \`${key}\` has already been registered.`);
     }
-
     if (this.callbacks.size === 0 && !this.isInit) {
       this.init();
       this.isInit = true;
     }
-
     this.callbacks.set(key, callback);
   }
-
   has(key) {
     return this.callbacks.has(key);
   }
-
   get(key) {
     return this.callbacks.get(key);
   }
-
   remove(key) {
     this.callbacks.delete(key);
-
     if (this.callbacks.size === 0 && this.isInit) {
       this.kill();
       this.isInit = false;
     }
   }
-
-  trigger() {
-    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-      args[_key2] = arguments[_key2];
-    }
-
+  trigger(...args) {
     this.callbacks.forEach(function forEachCallback(callback) {
       callback(...args);
     });
     return this;
   }
-
-}
+}
+export {
+  Service as default
+};