@studiometa/js-toolkit 3.9.0 → 4.0.0-alpha.1

package/dist/autoload/runtime.js

@@ -1,100 +0,0 @@
-import { autoload } from "./autoload.js";
-import { version } from "../version.js";
-const PACKAGE_NAME = "@studiometa/js-toolkit";
-const RUNTIME_KEY = Symbol.for("@studiometa/js-toolkit/autoload/runtime");
-const DIAGNOSTIC_PREFIX = "[@studiometa/js-toolkit/autoload]";
-const EAGER_META_SELECTOR = 'meta[name="js-toolkit:eager"]';
-function resolveOptions(options) {
-  const documentObject = options.document ?? document;
-  return {
-    documentObject,
-    globalObject: options.globalObject ?? globalThis,
-    version: options.version ?? version,
-    root: options.root ?? documentObject,
-    dependencies: options.dependencies,
-    logger: options.console ?? console,
-    scheduleMicrotask: options.scheduleMicrotask ?? ((callback) => queueMicrotask(callback))
-  };
-}
-function readEagerTokens(documentObject) {
-  const metas = [...documentObject.querySelectorAll(EAGER_META_SELECTOR)];
-  return [
-    ...new Set(
-      metas.flatMap((meta) => (meta.getAttribute("content") ?? "").split(",")).map((token) => token.trim()).filter(Boolean)
-    )
-  ];
-}
-function ensureRuntime(resolved) {
-  const host = resolved.globalObject;
-  const existing = host[RUNTIME_KEY];
-  if (existing) {
-    if (existing.packageName === PACKAGE_NAME && existing.version === resolved.version) {
-      return existing;
-    }
-    resolved.logger.warn(
-      `${DIAGNOSTIC_PREFIX} A conflicting runtime (version ${existing.version}) is already active; version ${resolved.version} was ignored.`
-    );
-    return void 0;
-  }
-  const runtime = {
-    packageName: PACKAGE_NAME,
-    version: resolved.version,
-    manifests: [],
-    pending: false
-  };
-  host[RUNTIME_KEY] = runtime;
-  return runtime;
-}
-function flushStart(runtime) {
-  runtime.pending = false;
-  const resolved = runtime.__pendingOptions;
-  if (!resolved) {
-    return;
-  }
-  const manifests = [...runtime.manifests];
-  const eager = readEagerTokens(resolved.documentObject);
-  runtime.handle?.stop();
-  runtime.handle = autoload({
-    manifests,
-    root: resolved.root,
-    eager,
-    dependencies: {
-      document: resolved.documentObject,
-      diagnosticPrefix: DIAGNOSTIC_PREFIX,
-      ...resolved.dependencies
-    }
-  });
-}
-function scheduleStart(runtime, resolved) {
-  runtime.__pendingOptions = resolved;
-  if (runtime.pending) {
-    return;
-  }
-  runtime.pending = true;
-  resolved.scheduleMicrotask(() => flushStart(runtime));
-}
-function registerManifest(manifest, options = {}) {
-  const resolved = resolveOptions(options);
-  const runtime = ensureRuntime(resolved);
-  if (!runtime) {
-    return void 0;
-  }
-  if (!runtime.manifests.includes(manifest)) {
-    runtime.manifests.push(manifest);
-  }
-  scheduleStart(runtime, resolved);
-  return runtime;
-}
-function registerManifests(...manifests) {
-  let runtime;
-  for (const manifest of manifests) {
-    runtime = registerManifest(manifest);
-  }
-  return runtime;
-}
-export {
-  readEagerTokens,
-  registerManifest,
-  registerManifests
-};
-//# sourceMappingURL=runtime.js.map

package/dist/autoload/runtime.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../packages/js-toolkit/autoload/runtime.ts"],
-  "sourcesContent": ["import { autoload, type AutoloadHandle } from './autoload.js';\nimport type { LoaderDependencies } from './loader.js';\nimport type { ComponentManifest } from './types.js';\nimport { version } from '../version.js';\n\n/** The identity every copy of this package advertises on the shared global runtime. */\nconst PACKAGE_NAME = '@studiometa/js-toolkit';\n/**\n * The `globalThis` key the shared runtime is stored under. `Symbol.for` guarantees the same symbol\n * across module graphs and bundle copies, so multiple side-effect entries \u2014 even from duplicated\n * copies of this package \u2014 coordinate through a single runtime object.\n */\nconst RUNTIME_KEY = Symbol.for('@studiometa/js-toolkit/autoload/runtime');\n/** The prefix prepended to every diagnostic message emitted by the shared runtime. */\nconst DIAGNOSTIC_PREFIX = '[@studiometa/js-toolkit/autoload]';\n/** The `<meta>` element carrying the comma-separated list of tokens to mount eagerly. */\nconst EAGER_META_SELECTOR = 'meta[name=\"js-toolkit:eager\"]';\n\n/** Options accepted by {@link registerManifest}; every seam is optional and testability-oriented. */\nexport interface RegisterManifestOptions {\n  /** The document to scan and to read the eager `<meta>` from. Defaults to the global `document`. */\n  document?: Document;\n  /** The object the shared runtime is stored on. Defaults to `globalThis`. */\n  globalObject?: object;\n  /** The identity used by the duplicate/conflict guard. Defaults to this package's version. */\n  version?: string;\n  /** The DOM scope handed to the loader. Defaults to the resolved document. */\n  root?: Document | Element;\n  /** Loader dependency-injection seams, forwarded to {@link autoload}. */\n  dependencies?: Partial<LoaderDependencies>;\n  /** The logger used by the duplicate/conflict guard. Defaults to the global `console`. */\n  console?: Pick<Console, 'warn'>;\n  /** Schedules the single coalesced start. Defaults to `queueMicrotask`. */\n  scheduleMicrotask?: (callback: () => void) => void;\n}\n\n/** The shared, cross-copy runtime object stored on `globalThis` under {@link RUNTIME_KEY}. */\nexport interface AutoloadRuntime {\n  /** The owning package name, used by the conflict guard. */\n  readonly packageName: typeof PACKAGE_NAME;\n  /** The version that first claimed this runtime; conflicting versions are ignored. */\n  readonly version: string;\n  /** Every manifest registered so far, in registration order. */\n  manifests: ComponentManifest[];\n  /** The active autoload handle, present once a start has flushed. */\n  handle?: AutoloadHandle;\n  /** True while a (re)start is scheduled through a microtask but has not flushed yet. */\n  pending: boolean;\n  /**\n   * The resolved options for the next flush. The freshest registration wins so a late import can\n   * refresh the document/root before the coalesced start runs.\n   *\n   * @private\n   */\n  __pendingOptions?: ResolvedOptions;\n}\n\ninterface ResolvedOptions {\n  documentObject: Document;\n  globalObject: object;\n  version: string;\n  root: Document | Element;\n  dependencies?: Partial<LoaderDependencies>;\n  logger: Pick<Console, 'warn'>;\n  scheduleMicrotask: (callback: () => void) => void;\n}\n\nfunction resolveOptions(options: RegisterManifestOptions): ResolvedOptions {\n  const documentObject = options.document ?? document;\n  return {\n    documentObject,\n    globalObject: options.globalObject ?? globalThis,\n    version: options.version ?? version,\n    root: options.root ?? documentObject,\n    dependencies: options.dependencies,\n    logger: options.console ?? console,\n    scheduleMicrotask: options.scheduleMicrotask ?? ((callback) => queueMicrotask(callback)),\n  };\n}\n\n/**\n * Read the eager tokens declared by `<meta name=\"js-toolkit:eager\" content=\"A, B, C\">`.\n *\n * The `content` values of every matching meta (in document order) are concatenated, split on\n * commas, trimmed, stripped of empties and deduplicated. When no such meta exists the list is\n * empty.\n */\nexport function readEagerTokens(documentObject: Document): string[] {\n  const metas = [...documentObject.querySelectorAll(EAGER_META_SELECTOR)];\n  return [\n    ...new Set(\n      metas\n        .flatMap((meta) => (meta.getAttribute('content') ?? '').split(','))\n        .map((token) => token.trim())\n        .filter(Boolean),\n    ),\n  ];\n}\n\nfunction ensureRuntime(resolved: ResolvedOptions): AutoloadRuntime | undefined {\n  const host = resolved.globalObject as Record<PropertyKey, unknown>;\n  const existing = host[RUNTIME_KEY] as AutoloadRuntime | undefined;\n  if (existing) {\n    if (existing.packageName === PACKAGE_NAME && existing.version === resolved.version) {\n      return existing;\n    }\n\n    resolved.logger.warn(\n      `${DIAGNOSTIC_PREFIX} A conflicting runtime (version ${existing.version}) is already active; version ${resolved.version} was ignored.`,\n    );\n    return undefined;\n  }\n\n  const runtime: AutoloadRuntime = {\n    packageName: PACKAGE_NAME,\n    version: resolved.version,\n    manifests: [],\n    pending: false,\n  };\n  host[RUNTIME_KEY] = runtime;\n  return runtime;\n}\n\nfunction flushStart(runtime: AutoloadRuntime): void {\n  runtime.pending = false;\n  const resolved = runtime.__pendingOptions;\n  if (!resolved) {\n    return;\n  }\n\n  const manifests = [...runtime.manifests];\n  const eager = readEagerTokens(resolved.documentObject);\n\n  // A previous flush may already have produced a loader when a manifest is registered late (after\n  // the coalescing microtask fired). Stop it and start a fresh loader over the accumulated set:\n  // js-toolkit's `$register` reuses the instance already mounted on an element, so re-scanning never\n  // double-mounts, while a single active loader keeps exactly one MutationObserver on the DOM.\n  runtime.handle?.stop();\n  runtime.handle = autoload({\n    manifests,\n    root: resolved.root,\n    eager,\n    dependencies: {\n      document: resolved.documentObject,\n      diagnosticPrefix: DIAGNOSTIC_PREFIX,\n      ...resolved.dependencies,\n    },\n  });\n}\n\nfunction scheduleStart(runtime: AutoloadRuntime, resolved: ResolvedOptions): void {\n  // The freshest registration wins so a late import can refresh the document/root before the flush.\n  runtime.__pendingOptions = resolved;\n  if (runtime.pending) {\n    return;\n  }\n  runtime.pending = true;\n  resolved.scheduleMicrotask(() => flushStart(runtime));\n}\n\n/**\n * Register a component manifest with the shared runtime and ensure the autoloader starts.\n *\n * This is the shared engine behind side-effect entries that activate a manifest. It is safe to call\n * from several entries and several bundle copies at once:\n *\n * - The first registration schedules a single start through a microtask. Because every ES module\n *   import in a graph evaluates before microtasks flush, importing several manifest-activating\n *   entries at the top of a module registers every manifest synchronously and results in exactly\n *   ONE {@link autoload} call over the COMPOSED set \u2014 never two loaders both scanning the DOM.\n * - A manifest registered after the start already fired is not dropped: it triggers a fresh start\n *   over the accumulated manifests. The previous loader is stopped first, so a single loader stays\n *   active, and js-toolkit's idempotent `$register` prevents any double-mount.\n * - A conflicting activation \u2014 a different {@link RegisterManifestOptions.version} claiming an\n *   already-owned runtime \u2014 warns and no-ops.\n *\n * Returns the shared runtime, or `undefined` when a conflicting version already owns it.\n */\nexport function registerManifest(\n  manifest: ComponentManifest,\n  options: RegisterManifestOptions = {},\n): AutoloadRuntime | undefined {\n  const resolved = resolveOptions(options);\n  const runtime = ensureRuntime(resolved);\n  if (!runtime) {\n    return undefined;\n  }\n\n  if (!runtime.manifests.includes(manifest)) {\n    runtime.manifests.push(manifest);\n  }\n  scheduleStart(runtime, resolved);\n  return runtime;\n}\n\n/**\n * Register several manifests with the shared runtime in order, then let the single coalesced start\n * flush over the composed set.\n *\n * This is the convenience wrapper an app uses to layer its own components on top of the packaged\n * ones: `registerManifests(baseManifest, custom)`. Because {@link registerManifest} pushes each\n * manifest onto the shared runtime in call order and the loader composes them later-wins, the LAST\n * manifest wins on token collisions \u2014 so a custom manifest passed last can override any component\n * that shares a token.\n *\n * Returns the shared runtime from the final registration, or `undefined` when a conflicting version\n * already owns the runtime (or when no manifest was passed).\n */\nexport function registerManifests(...manifests: ComponentManifest[]): AutoloadRuntime | undefined {\n  let runtime: AutoloadRuntime | undefined;\n  for (const manifest of manifests) {\n    runtime = registerManifest(manifest);\n  }\n  return runtime;\n}\n"],
-  "mappings": "AAAA,SAAS,gBAAqC;AAG9C,SAAS,eAAe;AAGxB,MAAM,eAAe;AAMrB,MAAM,cAAc,OAAO,IAAI,yCAAyC;AAExE,MAAM,oBAAoB;AAE1B,MAAM,sBAAsB;AAmD5B,SAAS,eAAe,SAAmD;AACzE,QAAM,iBAAiB,QAAQ,YAAY;AAC3C,SAAO;AAAA,IACL;AAAA,IACA,cAAc,QAAQ,gBAAgB;AAAA,IACtC,SAAS,QAAQ,WAAW;AAAA,IAC5B,MAAM,QAAQ,QAAQ;AAAA,IACtB,cAAc,QAAQ;AAAA,IACtB,QAAQ,QAAQ,WAAW;AAAA,IAC3B,mBAAmB,QAAQ,sBAAsB,CAAC,aAAa,eAAe,QAAQ;AAAA,EACxF;AACF;AASO,SAAS,gBAAgB,gBAAoC;AAClE,QAAM,QAAQ,CAAC,GAAG,eAAe,iBAAiB,mBAAmB,CAAC;AACtE,SAAO;AAAA,IACL,GAAG,IAAI;AAAA,MACL,MACG,QAAQ,CAAC,UAAU,KAAK,aAAa,SAAS,KAAK,IAAI,MAAM,GAAG,CAAC,EACjE,IAAI,CAAC,UAAU,MAAM,KAAK,CAAC,EAC3B,OAAO,OAAO;AAAA,IACnB;AAAA,EACF;AACF;AAEA,SAAS,cAAc,UAAwD;AAC7E,QAAM,OAAO,SAAS;AACtB,QAAM,WAAW,KAAK,WAAW;AACjC,MAAI,UAAU;AACZ,QAAI,SAAS,gBAAgB,gBAAgB,SAAS,YAAY,SAAS,SAAS;AAClF,aAAO;AAAA,IACT;AAEA,aAAS,OAAO;AAAA,MACd,GAAG,iBAAiB,mCAAmC,SAAS,OAAO,gCAAgC,SAAS,OAAO;AAAA,IACzH;AACA,WAAO;AAAA,EACT;AAEA,QAAM,UAA2B;AAAA,IAC/B,aAAa;AAAA,IACb,SAAS,SAAS;AAAA,IAClB,WAAW,CAAC;AAAA,IACZ,SAAS;AAAA,EACX;AACA,OAAK,WAAW,IAAI;AACpB,SAAO;AACT;AAEA,SAAS,WAAW,SAAgC;AAClD,UAAQ,UAAU;AAClB,QAAM,WAAW,QAAQ;AACzB,MAAI,CAAC,UAAU;AACb;AAAA,EACF;AAEA,QAAM,YAAY,CAAC,GAAG,QAAQ,SAAS;AACvC,QAAM,QAAQ,gBAAgB,SAAS,cAAc;AAMrD,UAAQ,QAAQ,KAAK;AACrB,UAAQ,SAAS,SAAS;AAAA,IACxB;AAAA,IACA,MAAM,SAAS;AAAA,IACf;AAAA,IACA,cAAc;AAAA,MACZ,UAAU,SAAS;AAAA,MACnB,kBAAkB;AAAA,MAClB,GAAG,SAAS;AAAA,IACd;AAAA,EACF,CAAC;AACH;AAEA,SAAS,cAAc,SAA0B,UAAiC;AAEhF,UAAQ,mBAAmB;AAC3B,MAAI,QAAQ,SAAS;AACnB;AAAA,EACF;AACA,UAAQ,UAAU;AAClB,WAAS,kBAAkB,MAAM,WAAW,OAAO,CAAC;AACtD;AAoBO,SAAS,iBACd,UACA,UAAmC,CAAC,GACP;AAC7B,QAAM,WAAW,eAAe,OAAO;AACvC,QAAM,UAAU,cAAc,QAAQ;AACtC,MAAI,CAAC,SAAS;AACZ,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,QAAQ,UAAU,SAAS,QAAQ,GAAG;AACzC,YAAQ,UAAU,KAAK,QAAQ;AAAA,EACjC;AACA,gBAAc,SAAS,QAAQ;AAC/B,SAAO;AACT;AAeO,SAAS,qBAAqB,WAA6D;AAChG,MAAI;AACJ,aAAW,YAAY,WAAW;AAChC,cAAU,iBAAiB,QAAQ;AAAA,EACrC;AACA,SAAO;AACT;",
-  "names": []
-}

package/dist/autoload/types.d.ts

@@ -1,49 +0,0 @@
-import type { BaseConstructor } from '../Base/Base.js';
-/**
- * The load strategy that controls when a component's constructor is imported and registered.
- *
- * These four values are deliberately richer than a plain eager/lazy split: `eager` loads
- * immediately, while `visible`, `idle` and `interaction` defer the import until the matching
- * browser signal fires. A `data-load` attribute may override the default per element.
- */
-export type ComponentLoadStrategy = 'eager' | 'visible' | 'idle' | 'interaction';
-/**
- * A single entry of a component manifest: everything the loader needs to discover a
- * `data-component` token and load its constructor on demand.
- */
-export interface ComponentManifestEntry {
-    /** The `data-component` token that identifies this component in the DOM. */
-    token: string;
-    /**
-     * The npm package the component is exported from. Optional informational metadata: the loader
-     * never reads it, so hand-authored or helper-built manifests may omit it.
-     */
-    packageName?: string;
-    /**
-     * The package subpath the component is exported from. Optional informational metadata never read
-     * by the loader.
-     */
-    subpath?: string;
-    /**
-     * The named export resolved by {@link ComponentManifestEntry.load}. Optional informational
-     * metadata never read by the loader.
-     */
-    exportName?: string;
-    /** The default load strategy for this component, overridable per element with `data-load`. */
-    strategy: ComponentLoadStrategy;
-    /**
-     * A grouping key shared by every component of the same family. Optional informational metadata
-     * never read by the loader.
-     */
-    group?: string;
-    /** The tokens of the constructor's configured child components, for recursive registration. */
-    children?: readonly string[];
-    /** Stylesheet paths associated with this component (informational). */
-    styles?: readonly string[];
-    /** Optional integration keys associated with this component (informational). */
-    integrations?: readonly string[];
-    /** Imports and resolves the component's `Base` constructor. */
-    load: () => Promise<BaseConstructor>;
-}
-/** A map of `data-component` tokens to their manifest entries. */
-export type ComponentManifest = Record<string, ComponentManifestEntry>;

package/dist/autoload/types.js

@@ -1 +0,0 @@
-//# sourceMappingURL=types.js.map

package/dist/autoload/types.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": [],
-  "sourcesContent": [],
-  "mappings": "",
-  "names": []
-}

package/dist/decorators/index.d.ts

@@ -1,15 +0,0 @@
-export { withBreakpointManager } from './withBreakpointManager.js';
-export { withBreakpointObserver, type WithBreakpointObserverInterface, type WithBreakpointObserverProps, } from './withBreakpointObserver.js';
-export { withDrag, type DragDecoratorOptions, type WithDragInterface } from './withDrag.js';
-export { withExtraConfig } from './withExtraConfig.js';
-export { withFreezedOptions, type WithFreezedOptionsInterface } from './withFreezedOptions.js';
-export { withIntersectionObserver, type WithIntersectionObserverInterface, type WithIntersectionObserverProps, } from './withIntersectionObserver.js';
-export { withMountOnMediaQuery, type withMountOnMediaQueryInterface, type withMountOnMediaQueryProps, } from './withMountOnMediaQuery.js';
-export { withMountWhenInView, type WithMountWhenInViewInterface, type WithMountWhenInViewProps, } from './withMountWhenInView.js';
-export { withMountWhenPrefersMotion } from './withMountWhenPrefersMotion.js';
-export { withMutation, type MutationDecoratorOptions, type WithMutationInterface, } from './withMutation.js';
-export { withName } from './withName.js';
-export { withRelativePointer, type RelativePointerDecoratorOptions, type RelativePointerInterface, } from './withRelativePointer.js';
-export { withResponsiveOptions } from './withResponsiveOptions.js';
-export { withScrolledInView, type NormalizedOffset, type OffsetValue, type ScrollInViewProps, type WithScrolledInViewInterface, type WithScrolledInViewOptions, type WithScrolledInViewProps, } from './withScrolledInView/index.js';
-export { getScopedGroups, withGroup, type WithGroupInterface, type WithGroupOptions, type WithGroupProps, } from './withGroup.js';

package/dist/decorators/index.js

@@ -1,51 +0,0 @@
-import { withBreakpointManager } from "./withBreakpointManager.js";
-import {
-  withBreakpointObserver
-} from "./withBreakpointObserver.js";
-import { withDrag } from "./withDrag.js";
-import { withExtraConfig } from "./withExtraConfig.js";
-import { withFreezedOptions } from "./withFreezedOptions.js";
-import {
-  withIntersectionObserver
-} from "./withIntersectionObserver.js";
-import {
-  withMountOnMediaQuery
-} from "./withMountOnMediaQuery.js";
-import {
-  withMountWhenInView
-} from "./withMountWhenInView.js";
-import { withMountWhenPrefersMotion } from "./withMountWhenPrefersMotion.js";
-import {
-  withMutation
-} from "./withMutation.js";
-import { withName } from "./withName.js";
-import {
-  withRelativePointer
-} from "./withRelativePointer.js";
-import { withResponsiveOptions } from "./withResponsiveOptions.js";
-import {
-  withScrolledInView
-} from "./withScrolledInView/index.js";
-import {
-  getScopedGroups,
-  withGroup
-} from "./withGroup.js";
-export {
-  getScopedGroups,
-  withBreakpointManager,
-  withBreakpointObserver,
-  withDrag,
-  withExtraConfig,
-  withFreezedOptions,
-  withGroup,
-  withIntersectionObserver,
-  withMountOnMediaQuery,
-  withMountWhenInView,
-  withMountWhenPrefersMotion,
-  withMutation,
-  withName,
-  withRelativePointer,
-  withResponsiveOptions,
-  withScrolledInView
-};
-//# sourceMappingURL=index.js.map

package/dist/decorators/index.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../packages/js-toolkit/decorators/index.ts"],
-  "sourcesContent": ["export { withBreakpointManager } from './withBreakpointManager.js';\nexport {\n  withBreakpointObserver,\n  type WithBreakpointObserverInterface,\n  type WithBreakpointObserverProps,\n} from './withBreakpointObserver.js';\nexport { withDrag, type DragDecoratorOptions, type WithDragInterface } from './withDrag.js';\nexport { withExtraConfig } from './withExtraConfig.js';\nexport { withFreezedOptions, type WithFreezedOptionsInterface } from './withFreezedOptions.js';\nexport {\n  withIntersectionObserver,\n  type WithIntersectionObserverInterface,\n  type WithIntersectionObserverProps,\n} from './withIntersectionObserver.js';\nexport {\n  withMountOnMediaQuery,\n  type withMountOnMediaQueryInterface,\n  type withMountOnMediaQueryProps,\n} from './withMountOnMediaQuery.js';\nexport {\n  withMountWhenInView,\n  type WithMountWhenInViewInterface,\n  type WithMountWhenInViewProps,\n} from './withMountWhenInView.js';\nexport { withMountWhenPrefersMotion } from './withMountWhenPrefersMotion.js';\nexport {\n  withMutation,\n  type MutationDecoratorOptions,\n  type WithMutationInterface,\n} from './withMutation.js';\nexport { withName } from './withName.js';\nexport {\n  withRelativePointer,\n  type RelativePointerDecoratorOptions,\n  type RelativePointerInterface,\n} from './withRelativePointer.js';\nexport { withResponsiveOptions } from './withResponsiveOptions.js';\nexport {\n  withScrolledInView,\n  type NormalizedOffset,\n  type OffsetValue,\n  type ScrollInViewProps,\n  type WithScrolledInViewInterface,\n  type WithScrolledInViewOptions,\n  type WithScrolledInViewProps,\n} from './withScrolledInView/index.js';\nexport {\n  getScopedGroups,\n  withGroup,\n  type WithGroupInterface,\n  type WithGroupOptions,\n  type WithGroupProps,\n} from './withGroup.js';\n"],
-  "mappings": "AAAA,SAAS,6BAA6B;AACtC;AAAA,EACE;AAAA,OAGK;AACP,SAAS,gBAAmE;AAC5E,SAAS,uBAAuB;AAChC,SAAS,0BAA4D;AACrE;AAAA,EACE;AAAA,OAGK;AACP;AAAA,EACE;AAAA,OAGK;AACP;AAAA,EACE;AAAA,OAGK;AACP,SAAS,kCAAkC;AAC3C;AAAA,EACE;AAAA,OAGK;AACP,SAAS,gBAAgB;AACzB;AAAA,EACE;AAAA,OAGK;AACP,SAAS,6BAA6B;AACtC;AAAA,EACE;AAAA,OAOK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OAIK;",
-  "names": []
-}

package/dist/decorators/withBreakpointManager.d.ts

@@ -1,7 +0,0 @@
-import type { Base, BaseConstructor } from '../Base/Base.js';
-import type { BaseDecorator, BaseInterface } from '../Base/types.js';
-/**
- * BreakpointManager class.
- * @link https://js-toolkit.studiometa.dev/api/decorators/withBreakpointManager.html
- */
-export declare function withBreakpointManager<S extends Base>(BaseClass: typeof Base, breakpoints: Array<[string, BaseConstructor<Base>]>): BaseDecorator<BaseInterface, S>;

package/dist/decorators/withBreakpointManager.js

@@ -1,82 +0,0 @@
-import { useResize } from "../services/ResizeService.js";
-import { isArray, isDev } from "../utils/is.js";
-function testBreakpoints(breakpoints) {
-  const { breakpoint } = useResize().props();
-  for (const [breakpointKeys, instance] of breakpoints) {
-    if (breakpointKeys.includes(breakpoint) && !instance.$isMounted) {
-      setTimeout(() => instance.$mount(), 0);
-    } else if (!breakpointKeys.includes(breakpoint) && instance.$isMounted) {
-      instance.$destroy();
-    }
-  }
-}
-function mountComponents(instance, breakpoints) {
-  return breakpoints.map(([bk, ComponentClass]) => {
-    const child = new ComponentClass(instance.$el);
-    Object.defineProperty(child, "$parent", { get: () => instance.__parent });
-    return [bk.split(" "), child];
-  });
-}
-const instances = /* @__PURE__ */ new WeakMap();
-function withBreakpointManager(BaseClass, breakpoints) {
-  if (!isArray(breakpoints)) {
-    if (isDev) {
-      throw new Error("[withBreakpointManager] The `breakpoints` parameter must be an array.");
-    }
-    return BaseClass;
-  }
-  if (breakpoints.length < 2) {
-    if (isDev) {
-      throw new Error("[withBreakpointManager] You must define at least 2 breakpoints.");
-    }
-    return BaseClass;
-  }
-  const { add, props } = useResize();
-  if (!props().breakpoint) {
-    if (isDev) {
-      throw new Error("The `BreakpointManager` class requires breakpoints to be defined.");
-    }
-    return BaseClass;
-  }
-  class WithBreakpointManager extends BaseClass {
-    /**
-     * Watch for the document resize to test the breakpoints.
-     */
-    constructor(element) {
-      super(element);
-      if (!instances.has(this)) {
-        instances.set(this, mountComponents(this, breakpoints));
-      }
-      add(`BreakpointManager-${this.$id}`, () => {
-        testBreakpoints(instances.get(this));
-      });
-    }
-    /**
-     * Override the default $mount method to prevent component's from being
-     * mounted when they should not.
-     */
-    async $mount() {
-      await super.$mount();
-      testBreakpoints(instances.get(this));
-      return this;
-    }
-    /**
-     * Destroy all instances when the main one is destroyed.
-     */
-    async $destroy() {
-      const promises = [];
-      if (isArray(instances.get(this))) {
-        for (const [, instance] of instances.get(this)) {
-          promises.push(instance.$destroy());
-        }
-      }
-      await Promise.all(promises);
-      return super.$destroy();
-    }
-  }
-  return WithBreakpointManager;
-}
-export {
-  withBreakpointManager
-};
-//# sourceMappingURL=withBreakpointManager.js.map

package/dist/decorators/withBreakpointManager.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../packages/js-toolkit/decorators/withBreakpointManager.ts"],
-  "sourcesContent": ["import type { Base, BaseConstructor, BaseProps } from '../Base/Base.js';\nimport type { BaseDecorator, BaseInterface } from '../Base/types.js';\nimport { useResize } from '../services/ResizeService.js';\nimport { isArray, isDev } from '../utils/is.js';\n\n/**\n * Test the breakpoins of the given Base instance and return the hook to call.\n */\nfunction testBreakpoints(breakpoints: Array<[string[], Base]>) {\n  const { breakpoint } = useResize().props();\n  for (const [breakpointKeys, instance] of breakpoints) {\n    if (breakpointKeys.includes(breakpoint) && !instance.$isMounted) {\n      setTimeout(() => instance.$mount(), 0);\n    } else if (!breakpointKeys.includes(breakpoint) && instance.$isMounted) {\n      instance.$destroy();\n    }\n  }\n}\n\n/**\n * Prepare the components.\n */\nfunction mountComponents(\n  instance: Base,\n  breakpoints: Array<[string, BaseConstructor]>,\n): Array<[string[], Base]> {\n  return breakpoints.map(([bk, ComponentClass]) => {\n    const child = new ComponentClass(instance.$el);\n    Object.defineProperty(child, '$parent', { get: () => instance.__parent });\n    return [bk.split(' '), child];\n  });\n}\n\n/**\n * A cache object to hold each Base sub-instances.\n */\nconst instances: WeakMap<Base, Array<[string[], Base]>> = new WeakMap();\n\n/**\n * BreakpointManager class.\n * @link https://js-toolkit.studiometa.dev/api/decorators/withBreakpointManager.html\n */\nexport function withBreakpointManager<S extends Base>(\n  BaseClass: typeof Base,\n  breakpoints: Array<[string, BaseConstructor<Base>]>,\n): BaseDecorator<BaseInterface, S> {\n  if (!isArray(breakpoints)) {\n    if (isDev) {\n      throw new Error('[withBreakpointManager] The `breakpoints` parameter must be an array.');\n    }\n\n    // @ts-ignore\n    return BaseClass;\n  }\n\n  if (breakpoints.length < 2) {\n    if (isDev) {\n      throw new Error('[withBreakpointManager] You must define at least 2 breakpoints.');\n    }\n\n    // @ts-ignore\n    return BaseClass;\n  }\n\n  const { add, props } = useResize();\n\n  // Do nothing if no breakpoint has been defined.\n  // @link https://js-toolkit.studiometa.dev/api/services/useResize.html#breakpoint\n  if (!props().breakpoint) {\n    if (isDev) {\n      throw new Error('The `BreakpointManager` class requires breakpoints to be defined.');\n    }\n\n    // @ts-ignore\n    return BaseClass;\n  }\n\n  /**\n   * Class.\n   */\n  class WithBreakpointManager<T extends BaseProps = BaseProps> extends BaseClass<T> {\n    /**\n     * Watch for the document resize to test the breakpoints.\n     */\n    constructor(element: HTMLElement) {\n      super(element);\n\n      if (!instances.has(this)) {\n        instances.set(this, mountComponents(this, breakpoints));\n      }\n\n      add(`BreakpointManager-${this.$id}`, () => {\n        testBreakpoints(instances.get(this));\n      });\n    }\n\n    /**\n     * Override the default $mount method to prevent component's from being\n     * mounted when they should not.\n     */\n    async $mount() {\n      await super.$mount();\n\n      testBreakpoints(instances.get(this));\n\n      return this;\n    }\n\n    /**\n     * Destroy all instances when the main one is destroyed.\n     */\n    async $destroy() {\n      const promises = [];\n      if (isArray(instances.get(this))) {\n        for (const [, instance] of instances.get(this)) {\n          promises.push(instance.$destroy());\n        }\n      }\n\n      await Promise.all(promises);\n\n      return super.$destroy();\n    }\n  }\n\n  // @ts-ignore\n  return WithBreakpointManager;\n}\n"],
-  "mappings": "AAEA,SAAS,iBAAiB;AAC1B,SAAS,SAAS,aAAa;AAK/B,SAAS,gBAAgB,aAAsC;AAC7D,QAAM,EAAE,WAAW,IAAI,UAAU,EAAE,MAAM;AACzC,aAAW,CAAC,gBAAgB,QAAQ,KAAK,aAAa;AACpD,QAAI,eAAe,SAAS,UAAU,KAAK,CAAC,SAAS,YAAY;AAC/D,iBAAW,MAAM,SAAS,OAAO,GAAG,CAAC;AAAA,IACvC,WAAW,CAAC,eAAe,SAAS,UAAU,KAAK,SAAS,YAAY;AACtE,eAAS,SAAS;AAAA,IACpB;AAAA,EACF;AACF;AAKA,SAAS,gBACP,UACA,aACyB;AACzB,SAAO,YAAY,IAAI,CAAC,CAAC,IAAI,cAAc,MAAM;AAC/C,UAAM,QAAQ,IAAI,eAAe,SAAS,GAAG;AAC7C,WAAO,eAAe,OAAO,WAAW,EAAE,KAAK,MAAM,SAAS,SAAS,CAAC;AACxE,WAAO,CAAC,GAAG,MAAM,GAAG,GAAG,KAAK;AAAA,EAC9B,CAAC;AACH;AAKA,MAAM,YAAoD,oBAAI,QAAQ;AAM/D,SAAS,sBACd,WACA,aACiC;AACjC,MAAI,CAAC,QAAQ,WAAW,GAAG;AACzB,QAAI,OAAO;AACT,YAAM,IAAI,MAAM,uEAAuE;AAAA,IACzF;AAGA,WAAO;AAAA,EACT;AAEA,MAAI,YAAY,SAAS,GAAG;AAC1B,QAAI,OAAO;AACT,YAAM,IAAI,MAAM,iEAAiE;AAAA,IACnF;AAGA,WAAO;AAAA,EACT;AAEA,QAAM,EAAE,KAAK,MAAM,IAAI,UAAU;AAIjC,MAAI,CAAC,MAAM,EAAE,YAAY;AACvB,QAAI,OAAO;AACT,YAAM,IAAI,MAAM,mEAAmE;AAAA,IACrF;AAGA,WAAO;AAAA,EACT;AAAA,EAKA,MAAM,8BAA+D,UAAa;AAAA;AAAA;AAAA;AAAA,IAIhF,YAAY,SAAsB;AAChC,YAAM,OAAO;AAEb,UAAI,CAAC,UAAU,IAAI,IAAI,GAAG;AACxB,kBAAU,IAAI,MAAM,gBAAgB,MAAM,WAAW,CAAC;AAAA,MACxD;AAEA,UAAI,qBAAqB,KAAK,GAAG,IAAI,MAAM;AACzC,wBAAgB,UAAU,IAAI,IAAI,CAAC;AAAA,MACrC,CAAC;AAAA,IACH;AAAA;AAAA;AAAA;AAAA;AAAA,IAMA,MAAM,SAAS;AACb,YAAM,MAAM,OAAO;AAEnB,sBAAgB,UAAU,IAAI,IAAI,CAAC;AAEnC,aAAO;AAAA,IACT;AAAA;AAAA;AAAA;AAAA,IAKA,MAAM,WAAW;AACf,YAAM,WAAW,CAAC;AAClB,UAAI,QAAQ,UAAU,IAAI,IAAI,CAAC,GAAG;AAChC,mBAAW,CAAC,EAAE,QAAQ,KAAK,UAAU,IAAI,IAAI,GAAG;AAC9C,mBAAS,KAAK,SAAS,SAAS,CAAC;AAAA,QACnC;AAAA,MACF;AAEA,YAAM,QAAQ,IAAI,QAAQ;AAE1B,aAAO,MAAM,SAAS;AAAA,IACxB;AAAA,EACF;AAGA,SAAO;AACT;",
-  "names": []
-}

package/dist/decorators/withBreakpointObserver.d.ts

@@ -1,15 +0,0 @@
-import type { Base, BaseProps } from '../Base/Base.js';
-import type { BaseDecorator, BaseInterface } from '../Base/types.js';
-export interface WithBreakpointObserverProps extends BaseProps {
-    $options: {
-        activeBreakpoints?: string;
-        inactiveBreakpoints?: string;
-    };
-}
-export interface WithBreakpointObserverInterface extends BaseInterface {
-}
-/**
- * BreakpointObserver class.
- * @link https://js-toolkit.studiometa.dev/api/decorators/withBreakpointObserver.html
- */
-export declare function withBreakpointObserver<S extends Base>(BaseClass: typeof Base): BaseDecorator<WithBreakpointObserverInterface, S, WithBreakpointObserverProps>;

package/dist/decorators/withBreakpointObserver.js

@@ -1,112 +0,0 @@
-import { useResize } from "../services/ResizeService.js";
-import { isDev } from "../utils/is.js";
-import { startsWith } from "../utils/string/startsWith.js";
-import { features } from "../Base/features.js";
-function testBreakpoints(instance, breakpoint = useResize().props().breakpoint) {
-  const { activeBreakpoints, inactiveBreakpoints } = instance.$options;
-  const isInActiveBreakpoint = activeBreakpoints && activeBreakpoints.split(" ").includes(breakpoint);
-  const isInInactiveBreakpoint = inactiveBreakpoints && inactiveBreakpoints.split(" ").includes(breakpoint);
-  if (activeBreakpoints && isInActiveBreakpoint || inactiveBreakpoints && !isInInactiveBreakpoint) {
-    return "$mount";
-  }
-  return "$destroy";
-}
-function hasBreakpointConfiguration(instance) {
-  const { activeBreakpoints, inactiveBreakpoints } = instance.$options;
-  return Boolean(activeBreakpoints || inactiveBreakpoints);
-}
-function testConflictingBreakpointConfiguration(instance) {
-  const { activeBreakpoints, inactiveBreakpoints, name } = instance.$options;
-  if (activeBreakpoints && inactiveBreakpoints) {
-    throw new Error(
-      `[${name}] Incorrect configuration: the \`activeBreakpoints\` and \`inactiveBreakpoints\` are not compatible.`
-    );
-  }
-}
-function createResizeCallback(instance) {
-  return ({ breakpoint }) => {
-    const action = testBreakpoints(instance, breakpoint);
-    if (action === "$destroy" && instance.$isMounted) {
-      instance[action]();
-    } else if (action === "$mount" && !instance.$isMounted) {
-      setTimeout(() => instance[action](), 0);
-    }
-  };
-}
-function addToResize(key, instance) {
-  if (isDev) {
-    testConflictingBreakpointConfiguration(instance);
-  }
-  const { add, has, props } = useResize();
-  if (!has(key)) {
-    const callback = createResizeCallback(instance);
-    add(key, callback);
-    callback(props());
-  }
-}
-function withBreakpointObserver(BaseClass) {
-  class WithBreakpointObserver extends BaseClass {
-    /**
-     * Config.
-     */
-    static config = {
-      ...BaseClass.config,
-      options: {
-        activeBreakpoints: String,
-        inactiveBreakpoints: String
-      }
-    };
-    /**
-     * Watch for the document resize to test the breakpoints.
-     */
-    constructor(element) {
-      super(element);
-      const { remove, props } = useResize();
-      const { name } = this.$options;
-      if (!props().breakpoint) {
-        if (isDev) {
-          throw new Error(
-            `[${name}] The \`BreakpointObserver\` class requires breakpoints to be defined.`
-          );
-        }
-        return;
-      }
-      const key = `BreakpointObserver-${this.$id}`;
-      const attributes = features.get("attributes");
-      const mutationObserver = new MutationObserver(([mutation]) => {
-        if (mutation.type === "attributes" && startsWith(mutation.attributeName, `${attributes.option}-`)) {
-          if (!hasBreakpointConfiguration(this)) {
-            this.$mount();
-            remove(key);
-            return;
-          }
-          addToResize(key, this);
-        }
-      });
-      mutationObserver.observe(this.$el, { attributes: true });
-      if (!hasBreakpointConfiguration(this)) {
-        return;
-      }
-      addToResize(key, this);
-    }
-    /**
-     * Override the default $mount method to prevent component's from being
-     * mounted when they should not.
-     */
-    async $mount() {
-      if (!hasBreakpointConfiguration(this)) {
-        return super.$mount();
-      }
-      const action = testBreakpoints(this);
-      if (action === "$mount") {
-        return super.$mount();
-      }
-      return this;
-    }
-  }
-  return WithBreakpointObserver;
-}
-export {
-  withBreakpointObserver
-};
-//# sourceMappingURL=withBreakpointObserver.js.map

package/dist/decorators/withBreakpointObserver.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../packages/js-toolkit/decorators/withBreakpointObserver.ts"],
-  "sourcesContent": ["import type { Base, BaseConfig, BaseProps } from '../Base/Base.js';\nimport type { BaseDecorator, BaseInterface } from '../Base/types.js';\nimport { type ResizeServiceProps, useResize } from '../services/ResizeService.js';\nimport { isDev } from '../utils/is.js';\nimport { startsWith } from '../utils/string/startsWith.js';\nimport { features } from '../Base/features.js';\n\nexport interface WithBreakpointObserverProps extends BaseProps {\n  $options: {\n    activeBreakpoints?: string;\n    inactiveBreakpoints?: string;\n  };\n}\n\nexport interface WithBreakpointObserverInterface extends BaseInterface {}\n\n/**\n * Test the breakpoins of the given Base instance and return the hook to call.\n *\n * @param  {Base<WithBreakpointObserverProps>} instance The component's instance.\n * @param  {string} [breakpoint] The breakpoint to test.\n * @return {string} The action to trigger.\n */\nfunction testBreakpoints(\n  instance: Base<WithBreakpointObserverProps>,\n  breakpoint: string = useResize().props().breakpoint,\n): string {\n  const { activeBreakpoints, inactiveBreakpoints } = instance.$options;\n  const isInActiveBreakpoint =\n    activeBreakpoints && activeBreakpoints.split(' ').includes(breakpoint);\n  const isInInactiveBreakpoint =\n    inactiveBreakpoints && inactiveBreakpoints.split(' ').includes(breakpoint);\n\n  if (\n    (activeBreakpoints && isInActiveBreakpoint) ||\n    (inactiveBreakpoints && !isInInactiveBreakpoint)\n  ) {\n    return '$mount';\n  }\n\n  return '$destroy';\n}\n\n/**\n * Test if the given instance is configured for breakpoints.\n *\n * @param  {Base<WithBreakpointObserverProps>} instance A Base class instance.\n * @return {boolean} True if configured correctly, false otherwise.\n */\nfunction hasBreakpointConfiguration(instance: Base<WithBreakpointObserverProps>): boolean {\n  const { activeBreakpoints, inactiveBreakpoints } = instance.$options;\n  return Boolean(activeBreakpoints || inactiveBreakpoints);\n}\n\n/**\n * Test if the given instance has a conflicting configuration for breakpoints.\n *\n * @param  {Base<WithBreakpointObserverProps>} instance A Base class instance.\n * @return {void}\n */\nfunction testConflictingBreakpointConfiguration(instance: Base<WithBreakpointObserverProps>): void {\n  const { activeBreakpoints, inactiveBreakpoints, name } = instance.$options;\n  if (activeBreakpoints && inactiveBreakpoints) {\n    throw new Error(\n      `[${name}] Incorrect configuration: the \\`activeBreakpoints\\` and \\`inactiveBreakpoints\\` are not compatible.`,\n    );\n  }\n}\n\n/**\n * Callback triggered when the window is resized.\n */\nfunction createResizeCallback(\n  instance: Base<WithBreakpointObserverProps>,\n): (resizeProps: ResizeServiceProps) => void {\n  return ({ breakpoint }) => {\n    const action = testBreakpoints(instance, breakpoint);\n\n    // Always destroy before mounting\n    if (action === '$destroy' && instance.$isMounted) {\n      instance[action]();\n    } else if (action === '$mount' && !instance.$isMounted) {\n      setTimeout(() => instance[action](), 0);\n    }\n  };\n}\n\n/**\n * Add the current instance to the resize service.\n *\n * @param {string} key      The key for the resize service callback.\n * @param {Base}   instance The instance to observe.\n */\nfunction addToResize(key, instance) {\n  if (isDev) {\n    testConflictingBreakpointConfiguration(instance);\n  }\n\n  const { add, has, props } = useResize();\n\n  if (!has(key)) {\n    const callback = createResizeCallback(instance);\n    add(key, callback);\n    callback(props());\n  }\n}\n\n/**\n * BreakpointObserver class.\n * @link https://js-toolkit.studiometa.dev/api/decorators/withBreakpointObserver.html\n */\nexport function withBreakpointObserver<S extends Base>(\n  BaseClass: typeof Base,\n): BaseDecorator<WithBreakpointObserverInterface, S, WithBreakpointObserverProps> {\n  /**\n   * Class.\n   */\n  class WithBreakpointObserver<T extends BaseProps = BaseProps> extends BaseClass<\n    T & WithBreakpointObserverProps\n  > {\n    /**\n     * Config.\n     */\n    static config: BaseConfig = {\n      ...BaseClass.config,\n      options: {\n        activeBreakpoints: String,\n        inactiveBreakpoints: String,\n      },\n    };\n\n    /**\n     * Watch for the document resize to test the breakpoints.\n     */\n    constructor(element: HTMLElement) {\n      super(element);\n\n      const { remove, props } = useResize();\n      const { name } = this.$options;\n\n      // Do nothing if no breakpoint has been defined.\n      // @link https://js-toolkit.studiometa.dev/api/services/useResize.html#breakpoint\n      if (!props().breakpoint) {\n        if (isDev) {\n          throw new Error(\n            `[${name}] The \\`BreakpointObserver\\` class requires breakpoints to be defined.`,\n          );\n        }\n        return;\n      }\n\n      const key = `BreakpointObserver-${this.$id}`;\n      const attributes = features.get('attributes');\n\n      // Watch change on the `data-options` attribute to emit the `set:options` event.\n      const mutationObserver = new MutationObserver(([mutation]) => {\n        if (\n          mutation.type === 'attributes' &&\n          startsWith(mutation.attributeName, `${attributes.option}-`)\n        ) {\n          // Stop here silently when no breakpoint configuration given.\n          if (!hasBreakpointConfiguration(this)) {\n            this.$mount();\n            remove(key);\n            return;\n          }\n\n          addToResize(key, this);\n        }\n      });\n      mutationObserver.observe(this.$el, { attributes: true });\n\n      // Stop here silently when no breakpoint configuration given.\n      if (!hasBreakpointConfiguration(this)) {\n        return;\n      }\n\n      addToResize(key, this);\n    }\n\n    /**\n     * Override the default $mount method to prevent component's from being\n     * mounted when they should not.\n     */\n    async $mount() {\n      // Execute normal behavior when no breakpoint configuration given.\n      if (!hasBreakpointConfiguration(this)) {\n        return super.$mount();\n      }\n\n      const action = testBreakpoints(this);\n      if (action === '$mount') {\n        return super.$mount();\n      }\n\n      return this;\n    }\n  }\n\n  // @ts-ignore\n  return WithBreakpointObserver;\n}\n"],
-  "mappings": "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",
-  "names": []
-}

package/dist/decorators/withDrag.d.ts

@@ -1,14 +0,0 @@
-import type { Base } from '../Base/Base.js';
-import type { BaseDecorator, BaseInterface } from '../Base/types.js';
-import { type DragServiceOptions, type DragServiceProps } from '../services/DragService.js';
-export type DragDecoratorOptions = DragServiceOptions & {
-    target?: (this: Base, instance: Base) => HTMLElement;
-};
-export interface WithDragInterface extends BaseInterface {
-    dragged?(props: DragServiceProps): void;
-}
-/**
- * Add dragging capabilities to a component.
- * @link https://js-toolkit.studiometa.dev/api/decorators/withDrag.html
- */
-export declare function withDrag<S extends Base>(BaseClass: typeof Base, { target, ...options }?: DragDecoratorOptions): BaseDecorator<BaseInterface, S>;

package/dist/decorators/withDrag.js

@@ -1,36 +0,0 @@
-import {
-  useDrag
-} from "../services/DragService.js";
-function withDrag(BaseClass, { target = (instance) => instance.$el, ...options } = {}) {
-  class WithDrag extends BaseClass {
-    /**
-     * Config.
-     */
-    static config = {
-      ...BaseClass.config,
-      emits: ["dragged"]
-    };
-    /**
-     * Class constructor.
-     */
-    constructor(element) {
-      super(element);
-      this.$on("mounted", () => {
-        this.$services.register(
-          "dragged",
-          useDrag.bind(void 0, target.call(this, this), options)
-        );
-        this.$services.enable("dragged");
-      });
-      this.$on("destroyed", () => {
-        this.$services.disable("dragged");
-        this.$services.unregister("dragged");
-      });
-    }
-  }
-  return WithDrag;
-}
-export {
-  withDrag
-};
-//# sourceMappingURL=withDrag.js.map

package/dist/decorators/withDrag.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../packages/js-toolkit/decorators/withDrag.ts"],
-  "sourcesContent": ["import type { Base, BaseConfig, BaseProps } from '../Base/Base.js';\nimport type { BaseDecorator, BaseInterface } from '../Base/types.js';\nimport {\n  type DragServiceOptions,\n  type DragServiceProps,\n  useDrag,\n} from '../services/DragService.js';\n\nexport type DragDecoratorOptions = DragServiceOptions & {\n  target?: (this: Base, instance: Base) => HTMLElement;\n};\n\nexport interface WithDragInterface extends BaseInterface {\n  dragged?(props: DragServiceProps): void;\n}\n\n/**\n * Add dragging capabilities to a component.\n * @link https://js-toolkit.studiometa.dev/api/decorators/withDrag.html\n */\nexport function withDrag<S extends Base>(\n  BaseClass: typeof Base,\n  { target = (instance) => instance.$el, ...options }: DragDecoratorOptions = {},\n): BaseDecorator<BaseInterface, S> {\n  /**\n   * Class.\n   */\n  class WithDrag<T extends BaseProps = BaseProps> extends BaseClass<T & WithDragInterface> {\n    /**\n     * Config.\n     */\n    static config: BaseConfig = {\n      ...BaseClass.config,\n      emits: ['dragged'],\n    };\n\n    /**\n     * Class constructor.\n     */\n    constructor(element: HTMLElement) {\n      super(element);\n\n      this.$on('mounted', () => {\n        this.$services.register(\n          'dragged',\n          useDrag.bind(undefined, target.call(this, this), options),\n        );\n        this.$services.enable('dragged');\n      });\n\n      this.$on('destroyed', () => {\n        this.$services.disable('dragged');\n        this.$services.unregister('dragged');\n      });\n    }\n  }\n\n  // @ts-ignore\n  return WithDrag;\n}\n"],
-  "mappings": "AAEA;AAAA,EAGE;AAAA,OACK;AAcA,SAAS,SACd,WACA,EAAE,SAAS,CAAC,aAAa,SAAS,KAAK,GAAG,QAAQ,IAA0B,CAAC,GAC5C;AAAA,EAIjC,MAAM,iBAAkD,UAAiC;AAAA;AAAA;AAAA;AAAA,IAIvF,OAAO,SAAqB;AAAA,MAC1B,GAAG,UAAU;AAAA,MACb,OAAO,CAAC,SAAS;AAAA,IACnB;AAAA;AAAA;AAAA;AAAA,IAKA,YAAY,SAAsB;AAChC,YAAM,OAAO;AAEb,WAAK,IAAI,WAAW,MAAM;AACxB,aAAK,UAAU;AAAA,UACb;AAAA,UACA,QAAQ,KAAK,QAAW,OAAO,KAAK,MAAM,IAAI,GAAG,OAAO;AAAA,QAC1D;AACA,aAAK,UAAU,OAAO,SAAS;AAAA,MACjC,CAAC;AAED,WAAK,IAAI,aAAa,MAAM;AAC1B,aAAK,UAAU,QAAQ,SAAS;AAChC,aAAK,UAAU,WAAW,SAAS;AAAA,MACrC,CAAC;AAAA,IACH;AAAA,EACF;AAGA,SAAO;AACT;",
-  "names": []
-}

package/dist/decorators/withExtraConfig.d.ts

@@ -1,8 +0,0 @@
-import type { Base, BaseConfig } from '../Base/Base.js';
-import type { Options as DeepmergeOptions } from 'deepmerge';
-import type { BaseDecorator, BaseInterface } from '../Base/types.js';
-/**
- * Extends the configuration of an existing class.
- * @link https://js-toolkit.studiometa.dev/api/decorators/withExtraConfig.html
- */
-export declare function withExtraConfig<S extends Base>(BaseClass: typeof Base, config: Partial<BaseConfig>, options?: DeepmergeOptions): BaseDecorator<BaseInterface, S>;

package/dist/decorators/withExtraConfig.js

@@ -1,18 +0,0 @@
-import merge from "deepmerge";
-function withExtraConfig(BaseClass, config, options = {}) {
-  const newConfig = merge(BaseClass.config, config, options);
-  if (newConfig.name === BaseClass.config.name) {
-    newConfig.name = `${BaseClass.config.name}WithExtraConfig`;
-  }
-  class WithExtraConfig extends BaseClass {
-    /**
-     * Config.
-     */
-    static config = newConfig;
-  }
-  return WithExtraConfig;
-}
-export {
-  withExtraConfig
-};
-//# sourceMappingURL=withExtraConfig.js.map

package/dist/decorators/withExtraConfig.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../packages/js-toolkit/decorators/withExtraConfig.ts"],
-  "sourcesContent": ["import merge from 'deepmerge';\nimport type { Base, BaseConfig, BaseProps } from '../Base/Base.js';\nimport type { Options as DeepmergeOptions } from 'deepmerge';\nimport type { BaseDecorator, BaseInterface } from '../Base/types.js';\n\n/**\n * Extends the configuration of an existing class.\n * @link https://js-toolkit.studiometa.dev/api/decorators/withExtraConfig.html\n */\nexport function withExtraConfig<S extends Base>(\n  BaseClass: typeof Base,\n  config: Partial<BaseConfig>,\n  options: DeepmergeOptions = {},\n): BaseDecorator<BaseInterface, S> {\n  const newConfig = merge(BaseClass.config, config, options);\n\n  if (newConfig.name === BaseClass.config.name) {\n    newConfig.name = `${BaseClass.config.name}WithExtraConfig`;\n  }\n\n  /**\n   * Class.\n   */\n  class WithExtraConfig<T extends BaseProps = BaseProps> extends BaseClass<T> {\n    /**\n     * Config.\n     */\n    static config: BaseConfig = newConfig;\n  }\n\n  // @ts-ignore\n  return WithExtraConfig;\n}\n"],
-  "mappings": "AAAA,OAAO,WAAW;AASX,SAAS,gBACd,WACA,QACA,UAA4B,CAAC,GACI;AACjC,QAAM,YAAY,MAAM,UAAU,QAAQ,QAAQ,OAAO;AAEzD,MAAI,UAAU,SAAS,UAAU,OAAO,MAAM;AAC5C,cAAU,OAAO,GAAG,UAAU,OAAO,IAAI;AAAA,EAC3C;AAAA,EAKA,MAAM,wBAAyD,UAAa;AAAA;AAAA;AAAA;AAAA,IAI1E,OAAO,SAAqB;AAAA,EAC9B;AAGA,SAAO;AACT;",
-  "names": []
-}