@stacksjs/utils 0.53.1 → 0.56.23

package/dist/index.mjs

@@ -1,15 +1,401 @@
-export * from "./base.mjs";
-export * from "./config.mjs";
-export * from "./currency.mjs";
-export * from "./debounce.mjs";
-export * from "./delete.mjs";
-export * from "./equal.mjs";
-export * from "./function.mjs";
-export * from "./guards.mjs";
-export * from "./helpers.mjs";
-export * from "./math.mjs";
-export * from "./p.mjs";
-export * from "./promise.mjs";
-export * from "./throttle.mjs";
-export * from "./vendors.mjs";
-export * from "./versions.mjs";
+import { ui, app } from '@stacksjs/config';
+export { loadStacksConfig as config } from '@stacksjs/config';
+export { add, allocate, compare, convert, dinero as currency, dinero, equal, greaterThan, greaterThanOrEqual, hasSubUnits, haveSameAmount, haveSameCurrency, isZero, lessThan, lessThanOrEqual, maximum, minimum, dinero as money, multiply, normalizeScale, subtract, toDecimal, toSnapshot, toUnits, trimScale } from 'dinero.js';
+export { USD } from '@dinero.js/currencies';
+export { debounce } from 'perfect-debounce';
+export { rimraf as del, rimraf } from 'rimraf';
+import { projectPath, frameworkPath } from '@stacksjs/path';
+import { parse } from 'yaml';
+import { spawn, execSync, log, runCommand } from '@stacksjs/cli';
+import * as storage from '@stacksjs/storage';
+import * as semver from 'semver';
+export { semver };
+export { and, createGenericProjection, createProjection, logicNot, logicOr, not, or, useAbs, useAverage, useCeil, useClamp, useFloor, useMath, useMax, useMin, usePrecision, useProjection, useRound, useSum, useTrunc } from '@vueuse/math';
+import pLimit from 'p-limit';
+import { remove } from '@stacksjs/arrays';
+export { asyncComputed, autoResetRef, breakpointsAntDesign, breakpointsBootstrapV5, breakpointsMasterCss, breakpointsQuasar, breakpointsSematic, breakpointsTailwind, breakpointsVuetify, cloneFnJSON, computedAsync, computedEager, computedInject, computedWithControl, controlledComputed, controlledRef, createEventHook, createFetch, createGlobalState, createInjectionState, createReactiveFn, createReusableTemplate, createSharedComposable, createTemplatePromise, createUnrefFn, customStorageEventName, debouncedRef, debouncedWatch, defaultDocument, defaultLocation, defaultNavigator, defaultWindow, eagerComputed, executeTransition, extendRef, formatTimeAgo, getSSRHandler, ignorableWatch, isDefined, mapGamepadToXbox360Controller, onClickOutside, onKeyDown, onKeyPressed, onKeyStroke, onKeyUp, onLongPress, onStartTyping, setSSRHandler, syncRef, syncRefs, templateRef, throttledRef, throttledWatch, toReactive, tryOnBeforeMount, tryOnBeforeUnmount, tryOnMounted, tryOnScopeDispose, tryOnUnmounted, unrefElement, until, useActiveElement, useAnimate, useAsyncQueue, useAsyncState, useBase64, useBattery, useBluetooth, useBreakpoints, useBroadcastChannel, useBrowserLocation, useCached, useClipboard, useCloned, useColorMode, useConfirmDialog, useCssVar, useCurrentElement, useCycleList, useDark, useDateFormat, useDebouncedRefHistory, useDeviceMotion, useDeviceOrientation, useDevicePixelRatio, useDevicesList, useDisplayMedia, useDocumentVisibility, useDraggable, useDropZone, useElementBounding, useElementByPoint, useElementHover, useElementSize, useElementVisibility, useEventBus, useEventListener, useEventSource, useEyeDropper, useFavicon, useFetch, useFileDialog, useFileSystemAccess, useFocus, useFocusWithin, useFps, useFullscreen, useGamepad, useGeolocation, useIdle, useImage, useInfiniteScroll, useIntersectionObserver, useKeyModifier, useLocalStorage, useMagicKeys, useManualRefHistory, useMediaControls, useMediaQuery, useMemoize, useMemory, useMounted, useMouse, useMouseInElement, useMousePressed, useMutationObserver, useNavigatorLanguage, useNetwork, useNow, useObjectUrl, useOffsetPagination, useOnline, usePageLeave, useParallax, useParentElement, usePerformanceObserver, usePermission, usePointer, usePointerLock, usePointerSwipe, usePreferredColorScheme, usePreferredContrast, usePreferredDark, usePreferredLanguages, usePreferredReducedMotion, usePrevious, useRafFn, useRefHistory, useResizeObserver, useScreenOrientation, useScreenSafeArea, useScriptTag, useScroll, useScrollLock, useSessionStorage, useShare, useSorted, useSpeechRecognition, useSpeechSynthesis, useStepper, useStorage, useStorageAsync, useStyleTag, useSupported, useSwipe, useTemplateRefsList, useTextDirection, useTextSelection, useTextareaAutosize, useThrottledRefHistory, useTimeAgo, useTimeoutPoll, useTimestamp, useTitle, useToggle, useTransition, useUrlSearchParams, useUserMedia, useVModel, useVModels, useVibrate, useVirtualList, useWakeLock, useWebNotification, useWebSocket, useWebWorker, useWebWorkerFn, useWindowFocus, useWindowScroll, useWindowSize, watchArray, watchAtMost, watchDebounced, watchDeep, watchIgnorable, watchImmediate, watchOnce, watchPausable, watchThrottled, watchTriggerable, watchWithFilter, whenever } from '@vueuse/core';
+export { Head, HeadVuePlugin, createHead, renderHeadToString } from '@vueuse/head';
+
+function toString(v) {
+  return Object.prototype.toString.call(v);
+}
+function loop(times, callback) {
+  [...Array(times)].forEach((item, i) => callback(i));
+}
+function getTypeName(v) {
+  if (v === null)
+    return "null";
+  const type = toString(v).slice(8, -1).toLowerCase();
+  return typeof v === "object" || typeof v === "function" ? type : typeof v;
+}
+
+function defineApp(config) {
+  return config;
+}
+function defineCache(config) {
+  return config;
+}
+function defineCdn(config) {
+  return config;
+}
+function defineCli(config) {
+  return config;
+}
+function defineCronJobsConfig(config) {
+  return config;
+}
+function defineJobsConfig(config) {
+  return config;
+}
+function defineDatabase(config) {
+  return config;
+}
+function defineDebugConfig(config) {
+  return config;
+}
+function defineDns(config) {
+  return config;
+}
+function defineEmailConfig(config) {
+  return config;
+}
+function defineEvents(config) {
+  return config;
+}
+function defineGit(config) {
+  return config;
+}
+function defineHashing(config) {
+  return config;
+}
+function defineLibrary(config) {
+  return config;
+}
+function defineModel(config) {
+  return config;
+}
+function defineNotification(config) {
+  return config;
+}
+function defineSms(config) {
+  return config;
+}
+function defineEmail(config) {
+  return config;
+}
+function defineChat(config) {
+  return config;
+}
+function definePage(config) {
+  return config;
+}
+function definePayment(config) {
+  return config;
+}
+function defineQueue(config) {
+  return config;
+}
+function defineSearchEngine(config) {
+  return config;
+}
+function defineServices(config) {
+  return config;
+}
+function defineStorage(config) {
+  return config;
+}
+function defineUi(config) {
+  return config;
+}
+
+function isDeepEqual(value1, value2) {
+  const type1 = getTypeName(value1);
+  const type2 = getTypeName(value2);
+  if (type1 !== type2)
+    return false;
+  if (type1 === "array") {
+    if (value1.length !== value2.length)
+      return false;
+    return value1.every((item, i) => {
+      return isDeepEqual(item, value2[i]);
+    });
+  }
+  if (type1 === "object") {
+    const keyArr = Object.keys(value1);
+    if (keyArr.length !== Object.keys(value2).length)
+      return false;
+    return keyArr.every((key) => {
+      return isDeepEqual(value1[key], value2[key]);
+    });
+  }
+  return Object.is(value1, value2);
+}
+
+function batchInvoke(functions) {
+  functions.forEach((fn) => fn && fn());
+}
+function tap(value, callback) {
+  callback(value);
+  return value;
+}
+
+function notNullish(v) {
+  return v != null;
+}
+function noNull(v) {
+  return v !== null;
+}
+function notUndefined(v) {
+  return v !== void 0;
+}
+function isTruthy(v) {
+  return Boolean(v);
+}
+
+async function isProjectCreated() {
+  if (storage.isFile(".env"))
+    return await isAppKeySet();
+  if (storage.isFile(".env.example"))
+    await spawn("cp .env.example .env", { stdio: "inherit", cwd: projectPath() });
+  return await isAppKeySet();
+}
+async function installIfVersionMismatch() {
+  const dependenciesYaml = storage.fs.readFileSync(projectPath("tea.yaml"), "utf8");
+  const dependencies = parseYaml(dependenciesYaml).dependencies;
+  const requiredNodeVersion = dependencies["nodejs.org"];
+  const requiredPnpmVersion = dependencies["pnpm.io"];
+  const installedNodeVersion = process.version;
+  const installedPnpmVersion = execSync("pnpm -v").trim();
+  if (!semver.satisfies(installedNodeVersion, requiredNodeVersion)) {
+    log.error(`Installed Node.js version (${installedNodeVersion}) does not satisfy required version (${requiredNodeVersion}). One moment...`);
+    await runCommand(`tea +nodejs.org${requiredNodeVersion} >/dev/null 2>&1`);
+  }
+  if (!semver.satisfies(installedPnpmVersion, requiredPnpmVersion)) {
+    log.error(`Installed pnpm version (${installedPnpmVersion}) does not satisfy required version (${requiredPnpmVersion}). One moment...`);
+    await runCommand(`tea +pnpm.io${requiredPnpmVersion} >/dev/null 2>&1`);
+  }
+}
+async function frameworkVersion() {
+  return (await storage.readPackageJson(frameworkPath("package.json"))).version;
+}
+async function isAppKeySet() {
+  const env = await storage.readTextFile(".env", projectPath());
+  const lines = env.data.split("\n");
+  const appKey = lines.find((line) => line.startsWith("APP_KEY="));
+  return !!(appKey && appKey.length > 16);
+}
+function determineResetPreset(preset) {
+  if (ui.reset)
+    preset = ui.reset;
+  if (preset === "tailwind")
+    return ["import '@unocss/reset/tailwind.css'"];
+  if (preset === "normalize")
+    return ["import '@unocss/reset/normalize.css'"];
+  if (preset === "sanitize")
+    return ["import '@unocss/reset/sanitize/sanitize.css'", "import '@unocss/reset/sanitize/assets.css"];
+  if (preset === "eric-meyer")
+    return ["import '@unocss/reset/eric-meyer.css'"];
+  if (preset === "antfu")
+    return ["import '@unocss/reset/antfu.css'"];
+  return [];
+}
+function isManifest(obj) {
+  return obj && typeof obj === "object" && isOptionalString(obj.name) && isOptionalString(obj.version) && isOptionalString(obj.description);
+}
+function isOptionalString(value) {
+  const type = typeof value;
+  return value === null || type === "undefined" || type === "string";
+}
+async function setEnvValue(key, value) {
+  const file = await storage.readTextFile(projectPath(".env"));
+  await storage.writeTextFile({
+    path: projectPath(".env"),
+    data: file.data.replace(/APP_KEY=/g, `APP_KEY=${value}`)
+    // todo: do not hardcode the APP_KEY here and instead use the key parameter
+  });
+}
+async function runNpmScript(script, options) {
+  const { data: manifest } = await storage.readJsonFile("package.json", frameworkPath());
+  if (isManifest(manifest) && hasScript(manifest, script))
+    return await runCommand(`pnpm run ${script}`, options);
+  log.error(`The specified npm script "${script}" does not exist in the package.json file`);
+  process.exit();
+}
+function hasScript(manifest, script) {
+  const scripts = manifest.scripts;
+  if (scripts && typeof scripts === "object")
+    return Boolean(scripts[script]);
+  return false;
+}
+function parseYaml(content) {
+  return parse(content);
+}
+function determineDebugLevel(options) {
+  if (options?.verbose === true)
+    return true;
+  return app.debug === true;
+}
+function isIpv6(address) {
+  return address.family === "IPv6" || address.family === 6;
+}
+
+const clamp = (n, min, max) => Math.min(max, Math.max(min, n));
+function rand(min, max) {
+  min = Math.ceil(min);
+  max = Math.floor(max);
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+const VOID = Symbol("p-void");
+class PInstance extends Promise {
+  constructor(items = [], options) {
+    super(() => {
+    });
+    this.items = items;
+    this.options = options;
+    this.promises = /* @__PURE__ */ new Set();
+  }
+  get promise() {
+    let batch;
+    const items = [...Array.from(this.items), ...Array.from(this.promises)];
+    if (this.options?.concurrency) {
+      const limit = pLimit(this.options.concurrency);
+      batch = Promise.all(items.map((p2) => limit(() => p2)));
+    } else {
+      batch = Promise.all(items);
+    }
+    return batch.then((l) => l.filter((i) => i !== VOID));
+  }
+  add(...args) {
+    args.forEach((i) => {
+      this.promises.add(i);
+    });
+  }
+  map(fn) {
+    return new PInstance(
+      Array.from(this.items).map(async (i, idx) => {
+        const v = await i;
+        if (v === VOID)
+          return VOID;
+        return fn(v, idx);
+      }),
+      this.options
+    );
+  }
+  filter(fn) {
+    return new PInstance(
+      Array.from(this.items).map(async (i, idx) => {
+        const v = await i;
+        const r = await fn(v, idx);
+        if (!r)
+          return VOID;
+        return v;
+      }),
+      this.options
+    );
+  }
+  forEach(fn) {
+    return this.map(fn).then();
+  }
+  reduce(fn, initialValue) {
+    return this.promise.then((array) => array.reduce(fn, initialValue));
+  }
+  clear() {
+    this.promises.clear();
+  }
+  then(fn) {
+    const p2 = this.promise;
+    if (fn)
+      return p2.then(fn);
+    return p2;
+  }
+  catch(fn) {
+    return this.promise.catch(fn);
+  }
+  finally(fn) {
+    return this.promise.finally(fn);
+  }
+}
+function p(items, options) {
+  return new PInstance(items, options);
+}
+
+function createSingletonPromise(fn) {
+  let _promise;
+  function wrapper() {
+    if (!_promise)
+      _promise = fn();
+    return _promise;
+  }
+  wrapper.reset = async () => {
+    const _prev = _promise;
+    _promise = void 0;
+    if (_prev)
+      await _prev;
+  };
+  return wrapper;
+}
+function createPromiseLock() {
+  const locks = [];
+  return {
+    async run(fn) {
+      const p = fn();
+      locks.push(p);
+      try {
+        return await p;
+      } finally {
+        remove(locks, p);
+      }
+    },
+    async wait() {
+      await Promise.allSettled(locks);
+    },
+    isWaiting() {
+      return Boolean(locks.length);
+    },
+    clear() {
+      locks.length = 0;
+    }
+  };
+}
+function createControlledPromise() {
+  let resolve, reject;
+  const promise = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  promise.resolve = resolve;
+  promise.reject = reject;
+  return promise;
+}
+function sleep(ms, callback) {
+  return new Promise(
+    (resolve) => setTimeout(async () => {
+      await callback?.();
+      resolve();
+    }, ms)
+  );
+}
+
+function throttle(fn, wait = 300) {
+  let inThrottle;
+  let lastFn;
+  let lastTime;
+  return function(...args) {
+    if (!inThrottle) {
+      fn.apply(this, args);
+      lastTime = Date.now();
+      inThrottle = true;
+    } else {
+      clearTimeout(lastFn);
+      lastFn = setTimeout(() => {
+        if (Date.now() - lastTime >= wait) {
+          fn.apply(this, args);
+          lastTime = Date.now();
+        }
+      }, Math.max(wait - (Date.now() - lastTime), 0));
+    }
+  };
+}
+
+export { batchInvoke, clamp, createControlledPromise, createPromiseLock, createSingletonPromise, defineApp, defineCache, defineCdn, defineChat, defineCli, defineCronJobsConfig, defineDatabase, defineDebugConfig, defineDns, defineEmail, defineEmailConfig, defineEvents, defineGit, defineHashing, defineJobsConfig, defineLibrary, defineModel, defineNotification, definePage, definePayment, defineQueue, defineSearchEngine, defineServices, defineSms, defineStorage, defineUi, determineDebugLevel, determineResetPreset, frameworkVersion, getTypeName, hasScript, installIfVersionMismatch, isAppKeySet, isDeepEqual, isIpv6, isManifest, isOptionalString, isProjectCreated, isTruthy, loop, noNull, notNullish, notUndefined, p, parseYaml, rand, runNpmScript, setEnvValue, sleep, tap, throttle, toString };

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@stacksjs/utils",
   "type": "module",
-  "version": "0.53.1",
-  "packageManager": "pnpm@8.5.1",
+  "version": "0.56.23",
+  "packageManager": "pnpm@8.6.5",
   "description": "The Stacks helper functions.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -43,34 +43,35 @@
     "README.md"
   ],
   "peerDependencies": {
-    "@vueuse/core": "^10.1.2",
+    "@dinero.js/currencies": "2.0.0-alpha.14",
+    "@vueuse/core": "^10.2.1",
     "@vueuse/head": "^1.1.26",
-    "@vueuse/math": "^10.1.2",
-    "@vueuse/shared": "^10.1.2",
+    "@vueuse/math": "^10.2.1",
+    "@vueuse/shared": "^10.2.1",
     "defu": "^6.1.2",
-    "detect-indent": "^7.0.1",
-    "detect-newline": "^4.0.0",
     "dinero.js": "2.0.0-alpha.14",
     "fast-glob": "^3.2.12",
     "kolorist": "1.8.0",
     "p-limit": "^4.0.0",
     "rimraf": "^5.0.1",
-    "semver": "^7.5.1",
-    "yaml": "^2.3.0",
-    "@stacksjs/arrays": "0.53.1",
-    "@stacksjs/cli": "0.53.1",
-    "@stacksjs/config": "0.53.1",
-    "@stacksjs/development": "0.53.1",
-    "@stacksjs/lint": "0.53.1",
-    "@stacksjs/path": "0.53.1",
-    "@stacksjs/storage": "0.53.1",
-    "@stacksjs/types": "0.53.1"
+    "semver": "^7.5.3",
+    "yaml": "^2.3.1",
+    "@stacksjs/arrays": "0.56.23",
+    "@stacksjs/cli": "0.56.23",
+    "@stacksjs/config": "0.56.23",
+    "@stacksjs/development": "0.56.23",
+    "@stacksjs/path": "0.56.23",
+    "@stacksjs/lint": "0.56.23",
+    "@stacksjs/storage": "0.56.23",
+    "@stacksjs/strings": "0.56.23",
+    "@stacksjs/types": "0.56.23"
   },
   "dependencies": {
-    "@vueuse/core": "^10.1.2",
+    "@dinero.js/currencies": "2.0.0-alpha.14",
+    "@vueuse/core": "^10.2.1",
     "@vueuse/head": "^1.1.26",
-    "@vueuse/math": "^10.1.2",
-    "@vueuse/shared": "^10.1.2",
+    "@vueuse/math": "^10.2.1",
+    "@vueuse/shared": "^10.2.1",
     "defu": "^6.1.2",
     "detect-indent": "^7.0.1",
     "detect-newline": "^4.0.0",
@@ -80,18 +81,18 @@
     "p-limit": "^4.0.0",
     "perfect-debounce": "^1.0.0",
     "rimraf": "^5.0.1",
-    "semver": "^7.5.1",
-    "yaml": "^2.3.0",
-    "@stacksjs/arrays": "0.53.1",
-    "@stacksjs/cli": "0.53.1",
-    "@stacksjs/config": "0.53.1",
-    "@stacksjs/lint": "0.53.1",
-    "@stacksjs/path": "0.53.1",
-    "@stacksjs/storage": "0.53.1",
-    "@stacksjs/types": "0.53.1"
+    "semver": "^7.5.3",
+    "yaml": "^2.3.1",
+    "@stacksjs/arrays": "0.56.23",
+    "@stacksjs/cli": "0.56.23",
+    "@stacksjs/config": "0.56.23",
+    "@stacksjs/lint": "0.56.23",
+    "@stacksjs/path": "0.56.23",
+    "@stacksjs/storage": "0.56.23",
+    "@stacksjs/types": "0.56.23"
   },
   "devDependencies": {
-    "@stacksjs/development": "0.53.1"
+    "@stacksjs/development": "0.56.23"
   },
   "scripts": {
     "build": "unbuild",

package/dist/base.d.ts

@@ -1,3 +0,0 @@
-export declare function toString(v: any): any;
-export declare function loop(times: number, callback: any): void;
-export declare function getTypeName(v: any): any;

package/dist/base.mjs

@@ -1,12 +0,0 @@
-export function toString(v) {
-  return Object.prototype.toString.call(v);
-}
-export function loop(times, callback) {
-  [...Array(times)].forEach((item, i) => callback(i));
-}
-export function getTypeName(v) {
-  if (v === null)
-    return "null";
-  const type = toString(v).slice(8, -1).toLowerCase();
-  return typeof v === "object" || typeof v === "function" ? type : typeof v;
-}

package/dist/config.d.ts

@@ -1,23 +0,0 @@
-import type { AppOptions, CacheOptions, CdnOptions, CronJobOptions, DatabaseOptions, DebugOptions, DnsOptions, EmailOptions, Events, GitOptions, HashingOptions, LibraryOptions, Model, NotificationOptions, PagesOption, PaymentOptions, SearchEngineOptions, ServicesOptions, StorageOptions, UiOptions, UserCliOptions } from '@stacksjs/types';
-export declare function env(key: any, _fallback?: any): any;
-export declare function defineApp(options: Partial<AppOptions>): Partial<AppOptions>;
-export declare function defineCache(options: Partial<CacheOptions>): Partial<CacheOptions>;
-export declare function defineCdn(options: Partial<CdnOptions>): Partial<CdnOptions>;
-export declare function defineCli(options: Partial<UserCliOptions>): Partial<UserCliOptions>;
-export declare function defineCronJobsConfig(options: Partial<CronJobOptions>[]): Partial<CronJobOptions>[];
-export declare function defineDatabase(options: Partial<DatabaseOptions>): Partial<DatabaseOptions>;
-export declare function defineDebugConfig(options: Partial<DebugOptions>): Partial<DebugOptions>;
-export declare function defineDns(options: Partial<DnsOptions>): Partial<DnsOptions>;
-export declare function defineEmailConfig(options: Partial<EmailOptions>): Partial<EmailOptions>;
-export declare function defineEvents(options: Partial<Events>): Partial<Events>;
-export declare function defineGit(options: Partial<GitOptions>): Partial<GitOptions>;
-export declare function defineHashing(options: Partial<HashingOptions>): Partial<HashingOptions>;
-export declare function defineLibrary(options: Partial<LibraryOptions>): Partial<LibraryOptions>;
-export declare function defineModel(options: Partial<Model>): Partial<Model>;
-export declare function defineNotification(options: Partial<NotificationOptions>): Partial<NotificationOptions>;
-export declare function definePage(options: Partial<PagesOption>): Partial<PagesOption>;
-export declare function definePayment(options: Partial<PaymentOptions>): Partial<PaymentOptions>;
-export declare function defineSearchEngine(options: Partial<SearchEngineOptions>): Partial<SearchEngineOptions>;
-export declare function defineServices(options: Partial<ServicesOptions>): Partial<ServicesOptions>;
-export declare function defineStorage(options: Partial<StorageOptions>): Partial<StorageOptions>;
-export declare function defineUi(options: Partial<UiOptions>): Partial<UiOptions>;

package/dist/config.mjs

@@ -1,66 +0,0 @@
-export function env(key, _fallback) {
-  return key;
-}
-export function defineApp(options) {
-  return options;
-}
-export function defineCache(options) {
-  return options;
-}
-export function defineCdn(options) {
-  return options;
-}
-export function defineCli(options) {
-  return options;
-}
-export function defineCronJobsConfig(options) {
-  return options;
-}
-export function defineDatabase(options) {
-  return options;
-}
-export function defineDebugConfig(options) {
-  return options;
-}
-export function defineDns(options) {
-  return options;
-}
-export function defineEmailConfig(options) {
-  return options;
-}
-export function defineEvents(options) {
-  return options;
-}
-export function defineGit(options) {
-  return options;
-}
-export function defineHashing(options) {
-  return options;
-}
-export function defineLibrary(options) {
-  return options;
-}
-export function defineModel(options) {
-  return options;
-}
-export function defineNotification(options) {
-  return options;
-}
-export function definePage(options) {
-  return options;
-}
-export function definePayment(options) {
-  return options;
-}
-export function defineSearchEngine(options) {
-  return options;
-}
-export function defineServices(options) {
-  return options;
-}
-export function defineStorage(options) {
-  return options;
-}
-export function defineUi(options) {
-  return options;
-}

package/dist/currency.d.ts

@@ -1 +0,0 @@
-export { add, allocate, compare, convert, equal, greaterThan, greaterThanOrEqual, hasSubUnits, isZero, lessThan, lessThanOrEqual, maximum, minimum, multiply, normalizeScale, dinero, dinero as money, subtract, toSnapshot, toUnits, toDecimal, trimScale, haveSameCurrency, haveSameAmount, } from 'dinero.js';

package/dist/currency.mjs

@@ -1,26 +0,0 @@
-export {
-  add,
-  allocate,
-  compare,
-  convert,
-  equal,
-  greaterThan,
-  greaterThanOrEqual,
-  hasSubUnits,
-  isZero,
-  lessThan,
-  lessThanOrEqual,
-  maximum,
-  minimum,
-  multiply,
-  normalizeScale,
-  dinero,
-  dinero as money,
-  subtract,
-  toSnapshot,
-  toUnits,
-  toDecimal,
-  trimScale,
-  haveSameCurrency,
-  haveSameAmount
-} from "dinero.js";

package/dist/debounce.d.ts

@@ -1 +0,0 @@
-export { debounce } from 'perfect-debounce';

package/dist/debounce.mjs

@@ -1 +0,0 @@
-export { debounce } from "perfect-debounce";

package/dist/delete.d.ts

@@ -1,2 +0,0 @@
-import { rimraf } from 'rimraf';
-export { rimraf, rimraf as del };

package/dist/delete.mjs

@@ -1,2 +0,0 @@
-import { rimraf } from "rimraf";
-export { rimraf, rimraf as del };

package/dist/equal.d.ts

@@ -1 +0,0 @@
-export declare function isDeepEqual(value1: any, value2: any): boolean;