@m4l/gclick 0.0.2

package/not_recognized/index.js

@@ -0,0 +1,406 @@
+const isObject$1 = (value) => typeof value === "object" && value !== null;
+const isObjectCustom = (value) => isObject$1(value) && !(value instanceof RegExp) && !(value instanceof Error) && !(value instanceof Date);
+const mapObjectSkip = Symbol("mapObjectSkip");
+const _mapObject = (object, mapper, options, isSeen = /* @__PURE__ */ new WeakMap()) => {
+  options = {
+    deep: false,
+    target: {},
+    ...options
+  };
+  if (isSeen.has(object)) {
+    return isSeen.get(object);
+  }
+  isSeen.set(object, options.target);
+  const { target } = options;
+  delete options.target;
+  const mapArray = (array) => array.map((element) => isObjectCustom(element) ? _mapObject(element, mapper, options, isSeen) : element);
+  if (Array.isArray(object)) {
+    return mapArray(object);
+  }
+  for (const [key, value] of Object.entries(object)) {
+    const mapResult = mapper(key, value, object);
+    if (mapResult === mapObjectSkip) {
+      continue;
+    }
+    let [newKey, newValue, { shouldRecurse = true } = {}] = mapResult;
+    if (newKey === "__proto__") {
+      continue;
+    }
+    if (options.deep && shouldRecurse && isObjectCustom(newValue)) {
+      newValue = Array.isArray(newValue) ? mapArray(newValue) : _mapObject(newValue, mapper, options, isSeen);
+    }
+    target[newKey] = newValue;
+  }
+  return target;
+};
+function mapObject(object, mapper, options) {
+  if (!isObject$1(object)) {
+    throw new TypeError(`Expected an object, got \`${object}\` (${typeof object})`);
+  }
+  return _mapObject(object, mapper, options);
+}
+const UPPERCASE = /[\p{Lu}]/u;
+const LOWERCASE = /[\p{Ll}]/u;
+const LEADING_CAPITAL = /^[\p{Lu}](?![\p{Lu}])/gu;
+const IDENTIFIER = /([\p{Alpha}\p{N}_]|$)/u;
+const SEPARATORS = /[_.\- ]+/;
+const LEADING_SEPARATORS = new RegExp("^" + SEPARATORS.source);
+const SEPARATORS_AND_IDENTIFIER = new RegExp(SEPARATORS.source + IDENTIFIER.source, "gu");
+const NUMBERS_AND_IDENTIFIER = new RegExp("\\d+" + IDENTIFIER.source, "gu");
+const preserveCamelCase = (string, toLowerCase, toUpperCase, preserveConsecutiveUppercase2) => {
+  let isLastCharLower = false;
+  let isLastCharUpper = false;
+  let isLastLastCharUpper = false;
+  let isLastLastCharPreserved = false;
+  for (let index = 0; index < string.length; index++) {
+    const character = string[index];
+    isLastLastCharPreserved = index > 2 ? string[index - 3] === "-" : true;
+    if (isLastCharLower && UPPERCASE.test(character)) {
+      string = string.slice(0, index) + "-" + string.slice(index);
+      isLastCharLower = false;
+      isLastLastCharUpper = isLastCharUpper;
+      isLastCharUpper = true;
+      index++;
+    } else if (isLastCharUpper && isLastLastCharUpper && LOWERCASE.test(character) && (!isLastLastCharPreserved || preserveConsecutiveUppercase2)) {
+      string = string.slice(0, index - 1) + "-" + string.slice(index - 1);
+      isLastLastCharUpper = isLastCharUpper;
+      isLastCharUpper = false;
+      isLastCharLower = true;
+    } else {
+      isLastCharLower = toLowerCase(character) === character && toUpperCase(character) !== character;
+      isLastLastCharUpper = isLastCharUpper;
+      isLastCharUpper = toUpperCase(character) === character && toLowerCase(character) !== character;
+    }
+  }
+  return string;
+};
+const preserveConsecutiveUppercase = (input, toLowerCase) => {
+  LEADING_CAPITAL.lastIndex = 0;
+  return input.replaceAll(LEADING_CAPITAL, (match) => toLowerCase(match));
+};
+const postProcess = (input, toUpperCase) => {
+  SEPARATORS_AND_IDENTIFIER.lastIndex = 0;
+  NUMBERS_AND_IDENTIFIER.lastIndex = 0;
+  return input.replaceAll(NUMBERS_AND_IDENTIFIER, (match, pattern, offset) => ["_", "-"].includes(input.charAt(offset + match.length)) ? match : toUpperCase(match)).replaceAll(SEPARATORS_AND_IDENTIFIER, (_, identifier) => toUpperCase(identifier));
+};
+function camelCase(input, options) {
+  if (!(typeof input === "string" || Array.isArray(input))) {
+    throw new TypeError("Expected the input to be `string | string[]`");
+  }
+  options = {
+    pascalCase: false,
+    preserveConsecutiveUppercase: false,
+    ...options
+  };
+  if (Array.isArray(input)) {
+    input = input.map((x) => x.trim()).filter((x) => x.length).join("-");
+  } else {
+    input = input.trim();
+  }
+  if (input.length === 0) {
+    return "";
+  }
+  const toLowerCase = options.locale === false ? (string) => string.toLowerCase() : (string) => string.toLocaleLowerCase(options.locale);
+  const toUpperCase = options.locale === false ? (string) => string.toUpperCase() : (string) => string.toLocaleUpperCase(options.locale);
+  if (input.length === 1) {
+    if (SEPARATORS.test(input)) {
+      return "";
+    }
+    return options.pascalCase ? toUpperCase(input) : toLowerCase(input);
+  }
+  const hasUpperCase = input !== toLowerCase(input);
+  if (hasUpperCase) {
+    input = preserveCamelCase(input, toLowerCase, toUpperCase, options.preserveConsecutiveUppercase);
+  }
+  input = input.replace(LEADING_SEPARATORS, "");
+  input = options.preserveConsecutiveUppercase ? preserveConsecutiveUppercase(input, toLowerCase) : toLowerCase(input);
+  if (options.pascalCase) {
+    input = toUpperCase(input.charAt(0)) + input.slice(1);
+  }
+  return postProcess(input, toUpperCase);
+}
+class QuickLRU extends Map {
+  constructor(options = {}) {
+    super();
+    if (!(options.maxSize && options.maxSize > 0)) {
+      throw new TypeError("`maxSize` must be a number greater than 0");
+    }
+    if (typeof options.maxAge === "number" && options.maxAge === 0) {
+      throw new TypeError("`maxAge` must be a number greater than 0");
+    }
+    this.maxSize = options.maxSize;
+    this.maxAge = options.maxAge || Number.POSITIVE_INFINITY;
+    this.onEviction = options.onEviction;
+    this.cache = /* @__PURE__ */ new Map();
+    this.oldCache = /* @__PURE__ */ new Map();
+    this._size = 0;
+  }
+  // TODO: Use private class methods when targeting Node.js 16.
+  _emitEvictions(cache2) {
+    if (typeof this.onEviction !== "function") {
+      return;
+    }
+    for (const [key, item] of cache2) {
+      this.onEviction(key, item.value);
+    }
+  }
+  _deleteIfExpired(key, item) {
+    if (typeof item.expiry === "number" && item.expiry <= Date.now()) {
+      if (typeof this.onEviction === "function") {
+        this.onEviction(key, item.value);
+      }
+      return this.delete(key);
+    }
+    return false;
+  }
+  _getOrDeleteIfExpired(key, item) {
+    const deleted = this._deleteIfExpired(key, item);
+    if (deleted === false) {
+      return item.value;
+    }
+  }
+  _getItemValue(key, item) {
+    return item.expiry ? this._getOrDeleteIfExpired(key, item) : item.value;
+  }
+  _peek(key, cache2) {
+    const item = cache2.get(key);
+    return this._getItemValue(key, item);
+  }
+  _set(key, value) {
+    this.cache.set(key, value);
+    this._size++;
+    if (this._size >= this.maxSize) {
+      this._size = 0;
+      this._emitEvictions(this.oldCache);
+      this.oldCache = this.cache;
+      this.cache = /* @__PURE__ */ new Map();
+    }
+  }
+  _moveToRecent(key, item) {
+    this.oldCache.delete(key);
+    this._set(key, item);
+  }
+  *_entriesAscending() {
+    for (const item of this.oldCache) {
+      const [key, value] = item;
+      if (!this.cache.has(key)) {
+        const deleted = this._deleteIfExpired(key, value);
+        if (deleted === false) {
+          yield item;
+        }
+      }
+    }
+    for (const item of this.cache) {
+      const [key, value] = item;
+      const deleted = this._deleteIfExpired(key, value);
+      if (deleted === false) {
+        yield item;
+      }
+    }
+  }
+  get(key) {
+    if (this.cache.has(key)) {
+      const item = this.cache.get(key);
+      return this._getItemValue(key, item);
+    }
+    if (this.oldCache.has(key)) {
+      const item = this.oldCache.get(key);
+      if (this._deleteIfExpired(key, item) === false) {
+        this._moveToRecent(key, item);
+        return item.value;
+      }
+    }
+  }
+  set(key, value, { maxAge = this.maxAge } = {}) {
+    const expiry = typeof maxAge === "number" && maxAge !== Number.POSITIVE_INFINITY ? Date.now() + maxAge : void 0;
+    if (this.cache.has(key)) {
+      this.cache.set(key, {
+        value,
+        expiry
+      });
+    } else {
+      this._set(key, { value, expiry });
+    }
+    return this;
+  }
+  has(key) {
+    if (this.cache.has(key)) {
+      return !this._deleteIfExpired(key, this.cache.get(key));
+    }
+    if (this.oldCache.has(key)) {
+      return !this._deleteIfExpired(key, this.oldCache.get(key));
+    }
+    return false;
+  }
+  peek(key) {
+    if (this.cache.has(key)) {
+      return this._peek(key, this.cache);
+    }
+    if (this.oldCache.has(key)) {
+      return this._peek(key, this.oldCache);
+    }
+  }
+  delete(key) {
+    const deleted = this.cache.delete(key);
+    if (deleted) {
+      this._size--;
+    }
+    return this.oldCache.delete(key) || deleted;
+  }
+  clear() {
+    this.cache.clear();
+    this.oldCache.clear();
+    this._size = 0;
+  }
+  resize(newSize) {
+    if (!(newSize && newSize > 0)) {
+      throw new TypeError("`maxSize` must be a number greater than 0");
+    }
+    const items = [...this._entriesAscending()];
+    const removeCount = items.length - newSize;
+    if (removeCount < 0) {
+      this.cache = new Map(items);
+      this.oldCache = /* @__PURE__ */ new Map();
+      this._size = items.length;
+    } else {
+      if (removeCount > 0) {
+        this._emitEvictions(items.slice(0, removeCount));
+      }
+      this.oldCache = new Map(items.slice(removeCount));
+      this.cache = /* @__PURE__ */ new Map();
+      this._size = 0;
+    }
+    this.maxSize = newSize;
+  }
+  *keys() {
+    for (const [key] of this) {
+      yield key;
+    }
+  }
+  *values() {
+    for (const [, value] of this) {
+      yield value;
+    }
+  }
+  *[Symbol.iterator]() {
+    for (const item of this.cache) {
+      const [key, value] = item;
+      const deleted = this._deleteIfExpired(key, value);
+      if (deleted === false) {
+        yield [key, value.value];
+      }
+    }
+    for (const item of this.oldCache) {
+      const [key, value] = item;
+      if (!this.cache.has(key)) {
+        const deleted = this._deleteIfExpired(key, value);
+        if (deleted === false) {
+          yield [key, value.value];
+        }
+      }
+    }
+  }
+  *entriesDescending() {
+    let items = [...this.cache];
+    for (let i = items.length - 1; i >= 0; --i) {
+      const item = items[i];
+      const [key, value] = item;
+      const deleted = this._deleteIfExpired(key, value);
+      if (deleted === false) {
+        yield [key, value.value];
+      }
+    }
+    items = [...this.oldCache];
+    for (let i = items.length - 1; i >= 0; --i) {
+      const item = items[i];
+      const [key, value] = item;
+      if (!this.cache.has(key)) {
+        const deleted = this._deleteIfExpired(key, value);
+        if (deleted === false) {
+          yield [key, value.value];
+        }
+      }
+    }
+  }
+  *entriesAscending() {
+    for (const [key, value] of this._entriesAscending()) {
+      yield [key, value.value];
+    }
+  }
+  get size() {
+    if (!this._size) {
+      return this.oldCache.size;
+    }
+    let oldCacheSize = 0;
+    for (const key of this.oldCache.keys()) {
+      if (!this.cache.has(key)) {
+        oldCacheSize++;
+      }
+    }
+    return Math.min(this._size + oldCacheSize, this.maxSize);
+  }
+  entries() {
+    return this.entriesAscending();
+  }
+  forEach(callbackFunction, thisArgument = this) {
+    for (const [key, value] of this.entriesAscending()) {
+      callbackFunction.call(thisArgument, value, key, this);
+    }
+  }
+  get [Symbol.toStringTag]() {
+    return JSON.stringify([...this.entriesAscending()]);
+  }
+}
+const has = (array, key) => array.some((element) => {
+  if (typeof element === "string") {
+    return element === key;
+  }
+  element.lastIndex = 0;
+  return element.test(key);
+});
+const cache = new QuickLRU({ maxSize: 1e5 });
+const isObject = (value) => typeof value === "object" && value !== null && !(value instanceof RegExp) && !(value instanceof Error) && !(value instanceof Date);
+const transform = (input, options = {}) => {
+  if (!isObject(input)) {
+    return input;
+  }
+  const {
+    exclude,
+    pascalCase = false,
+    stopPaths,
+    deep = false,
+    preserveConsecutiveUppercase: preserveConsecutiveUppercase2 = false
+  } = options;
+  const stopPathsSet = new Set(stopPaths);
+  const makeMapper = (parentPath) => (key, value) => {
+    if (deep && isObject(value)) {
+      const path = parentPath === void 0 ? key : `${parentPath}.${key}`;
+      if (!stopPathsSet.has(path)) {
+        value = mapObject(value, makeMapper(path));
+      }
+    }
+    if (!(exclude && has(exclude, key))) {
+      const cacheKey = pascalCase ? `${key}_` : key;
+      if (cache.has(cacheKey)) {
+        key = cache.get(cacheKey);
+      } else {
+        const returnValue = camelCase(key, { pascalCase, locale: false, preserveConsecutiveUppercase: preserveConsecutiveUppercase2 });
+        if (key.length < 100) {
+          cache.set(cacheKey, returnValue);
+        }
+        key = returnValue;
+      }
+    }
+    return [key, value];
+  };
+  return mapObject(input, makeMapper(void 0));
+};
+function camelcaseKeys(input, options) {
+  if (Array.isArray(input)) {
+    return Object.keys(input).map((key) => transform(input[key], options));
+  }
+  return transform(input, options);
+}
+export {
+  camelcaseKeys as c
+};

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@m4l/gclick",
+  "version": "0.0.2",
+  "license": "UNLICENSED",
+  "lint-staged": {
+    "*.{js,ts,tsx}": "eslint --fix --max-warnings 0"
+  },
+  "dependencies": {
+    "@geoman-io/leaflet-geoman-free": "^2.14.2",
+    "@googlemaps/js-api-loader": "^1.16.6",
+    "@hookform/resolvers": "2.9.11",
+    "@microlink/react-json-view": "^1.23.3",
+    "@mui/x-charts": "^8.10.0",
+    "@types/lodash-es": "^4.17.12",
+    "atmosphere.js": "^4.0.0",
+    "chart.js": "^4.4.0",
+    "chartjs-chart-error-bars": "^4.3.3",
+    "fast-equals": "^5.0.1",
+    "history": "5.3.0",
+    "install": "^0.13.0",
+    "jwt-decode": "^4.0.0",
+    "leaflet": "^1.9.4",
+    "leaflet-polylinedecorator": "^1.6.0",
+    "leaflet.markercluster": "^1.5.3",
+    "lodash-es": "^4.17.21",
+    "qrcode.react": "^3.1.0",
+    "react": "18.3.1",
+    "react-chartjs-2": "^5.2.0",
+    "react-color": "^2.19.3",
+    "react-data-grid": "7.0.0-beta.13",
+    "react-dom": "18.3.1",
+    "react-leaflet": "^4.2.1",
+    "react-resizable": "^3.0.4",
+    "react-router-dom": "6.3.0",
+    "react-spinners": "^0.13.8",
+    "react-transition-group": "^4.4.5",
+    "simplebar-react": "3.2.6",
+    "storybook-multilevel-sort": "^2.0.1",
+    "yup": "0.32.11",
+    "zustand": "4.3.6"
+  },
+  "peerDependencies": {
+    "@m4l/components": "^9.0.0",
+    "@m4l/core": "^2.0.0",
+    "@m4l/graphics": "^7.0.0",
+    "@m4l/styles": "^7.1.18"
+  },
+  "resolutions": {
+    "react": "18.3.1",
+    "@types/react": "18.3.23",
+    "@types/react-dom": "18.3.7",
+    "react-dom": "18.3.1",
+    "storybook": "^8.3.4",
+    "attr-accept": "2.2.2",
+    "@vitejs/plugin-react": "^4.0.0"
+  },
+  "overrides": {
+    "glob": "^10.4.5",
+    "eslint": "9.28.0",
+    "react": "18.3.1",
+    "@types/react": "18.3.23",
+    "@types/react-dom": "18.3.7",
+    "react-dom": "18.3.1",
+    "attr-accept": "2.2.2"
+  },
+  "files": [
+    "*"
+  ],
+  "source": "./index.js",
+  "main": "./dist/index.js",
+  "module": "./index.js",
+  "type": "module",
+  "types": "./index.d.ts",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "packageManager": "yarn@4.5.0",
+  "msw": {
+    "workerDirectory": [
+      "public"
+    ]
+  },
+  "private": false,
+  "exports": {
+    ".": {
+      "import": "./index.js"
+    }
+  }
+}

package/test/HostThemeProviderMock.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+interface HostThemeProviderMockProps {
+    dataTestId?: string;
+    children: React.ReactNode;
+}
+/**
+ * TODO: Documentar
+ */
+declare const HostThemeProviderMock: (props: HostThemeProviderMockProps) => import("react/jsx-runtime").JSX.Element;
+export default HostThemeProviderMock;

package/test/TestAppWrapper.d.ts

@@ -0,0 +1,29 @@
+import { FC, ReactNode } from 'react';
+import { DeviceType } from '@m4l/graphics';
+interface TestAppWrapperProps {
+    forcedDeviceType?: DeviceType;
+    children: ReactNode;
+}
+/**
+ * TestWrapper is a React functional component that provides a consistent testing environment
+ * for components that rely on various context providers.
+ *
+ * It wraps the children components with the following contexts:
+ * - ModuleSkeletonContext: Provides the skeleton loading state for components that require it.
+ * - HostThemeProviderMock: Mocks the theme provider to ensure components are styled correctly during tests.
+ * - AppearanceComponentProvider: Supplies the necessary context for appearance-related components.
+ *
+ * This wrapper is useful for reducing redundancy in tests by encapsulating common providers,
+ * allowing for cleaner and more maintainable test code.
+ * @param {Object} props - The properties passed to the component.
+ * @param {ReactNode} props.children - The child components that will be rendered within the context providers.
+ * @example
+ * // Usage example
+ * render(
+ *   <TestWrapper>
+ *     <MyComponent />
+ *   </TestWrapper>
+ * );
+ */
+export declare const TestAppWrapper: FC<TestAppWrapperProps>;
+export default TestAppWrapper;

package/test/TestFormAutoValidation.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Envoltorio para el estado de error
+ */
+export declare const TestFormAutoValidation: () => import("react/jsx-runtime").JSX.Element;

package/test/constants.d.ts

@@ -0,0 +1,69 @@
+import { Formatters } from '@m4l/graphics';
+import { HostToolsType, Toaster } from '@m4l/core';
+import { BaseDataForTesting } from './types';
+export declare const moduleIdForTesting = "testing";
+export declare const moduleNameForTesting = "label_for_module_name";
+export declare const dictionaryDataForTesting: {
+    data: {
+        module_name: string;
+        label1: string;
+    };
+    comp1: {
+        key1: string;
+    };
+};
+export declare const queryPrivilegesForTesting: string[];
+export declare const resultpPrivilegesForTesting: {
+    data: {
+        priv1: boolean;
+    };
+};
+export declare const domainDataForTesting: {
+    data: {
+        name: string;
+        company_logo_small_url: string;
+        company_logo_normal_url: string;
+    };
+};
+export declare const domainCountry1DataForTesting: {
+    id: number;
+    currency: string;
+    currency_decimal_digits: number;
+    decimal_symbol: string;
+    thousands_symbol: string;
+};
+export declare const domainCountry2DataForTesting: {
+    id: number;
+    currency: string;
+    currency_decimal_digits: number;
+    decimal_symbol: string;
+    thousands_symbol: string;
+};
+export declare const resultAxiosOperationForTesting: {
+    data: {
+        a: number;
+        b: string;
+    };
+};
+export declare const networkPropsForTesting: {
+    method: string;
+    endPoint: string;
+    parms: {};
+};
+export declare const environmentDataForTesting: {
+    isLocalhost: boolean;
+    host: string;
+    database: string;
+    domain_token: string;
+    host_api_local: string;
+    host_api_remote: string;
+    host_static_assets: string;
+    environment_assets: string;
+    isIsolatation: boolean;
+    isMicroFrontend: boolean;
+    getModuleUrlIconAsset: () => string;
+};
+export declare const baseDataForTesting: BaseDataForTesting;
+export declare const mock_toaster: Toaster;
+export declare const hostToolsDataForTesting: HostToolsType;
+export declare const formatterValues: Formatters;

package/test/constants_no_mock.d.ts

@@ -0,0 +1 @@
+export declare const TEST_PROP_ID = "data-testid";

package/test/getNameDataTestId.d.ts

@@ -0,0 +1,15 @@
+/**
+ * TODO: Documentar
+ */
+export declare const getNameDataTestId: (componentName: string, slotKey: string, instaceId?: string) => string;
+/**
+ * Utilidad que permite generar el nombre único que sirve para realizar las pruebas unitarias y de integración.
+ * Genera el atributo data-testid
+ * @param componentName -
+ * @param slotKey
+ */
+export declare function getPropDataTestId(componentName: string, slotKey: string, instaceId?: string): {
+    "data-testid": string;
+} | {
+    "data-testid"?: undefined;
+};

package/test/getNameDataTestId.js

@@ -0,0 +1,16 @@
+const getNameDataTestId = (componentName, slotKey, instaceId) => {
+  if (instaceId) {
+    return `${componentName}-${[slotKey]}-${instaceId}`;
+  }
+  return `${componentName}-${[slotKey]}`;
+};
+function getPropDataTestId(componentName, slotKey, instaceId) {
+  if (process.env.NODE_ENV !== "production" && componentName && slotKey) {
+    return { ["data-testid"]: getNameDataTestId(componentName, slotKey, instaceId) };
+  } else {
+    return {};
+  }
+}
+export {
+  getPropDataTestId as g
+};

package/test/index.d.ts

@@ -0,0 +1,4 @@
+export * from './constants';
+export * from './types';
+export * from './utils';
+export * from './mocks';

package/test/mocks.d.ts

@@ -0,0 +1,27 @@
+import * as core from '@m4l/core';
+import * as graphics from '@m4l/graphics';
+export declare const mock_addFlag: import('vitest').Mock<(...args: any[]) => any>;
+export declare const mock_networkOperation: import('vitest').Mock<(...args: any[]) => any>;
+export declare const mock_useFormatter: import('vitest').Mock<(...args: any[]) => any>;
+export declare const mock_events_add_listener: import('vitest').Mock<(...args: any[]) => any>;
+export declare const mock_events_remove_listener: import('vitest').Mock<(...args: any[]) => any>;
+export declare const mock_events_emit: import('vitest').Mock<(...args: any[]) => any>;
+export declare const mock_startProgress: import('vitest').Mock<(...args: any[]) => any>;
+export declare const mock_stopProgress: import('vitest').Mock<(...args: any[]) => any>;
+export declare const mock_useModuleDictionary: import('vitest').Mock<(...args: any[]) => any>;
+export declare const mock_useEnvironment: {
+    host_static_assets: string;
+    environment_assets: string;
+    domain_token: string;
+};
+export declare const mockedGraphics: {
+    useFormatter: import('vitest').MockInstance<() => graphics.Formatters>;
+};
+export declare function restoreGraphicsMocked(): void;
+/**
+ * TODO: Documentar
+ */
+export declare const coreImplementation: typeof core;
+export declare const graphicsImplementation: {
+    useFormatter: import('vitest').MockInstance<() => graphics.Formatters>;
+};

package/test/types.d.ts

@@ -0,0 +1,4 @@
+export interface BaseDataForTesting {
+    a: string;
+    b: number;
+}