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

package/dist/Base/types.js

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

package/dist/Base/types.js.map

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

package/dist/Base/utils.d.ts

@@ -1,54 +0,0 @@
-import type { Base, BaseConfig, BaseConstructor } from './Base.js';
-/**
- * Add a task to the main queue.
- */
-export declare function addToQueue(fn: () => unknown): Promise<unknown>;
-/**
- * Get the selector for a given component.
- */
-export declare function getSelector(nameOrSelector: string): string;
-/**
- * Get a list of elements based on the name of a component.
- *
- * @param {string} nameOrSelector
- *   The name or selector to used for this component.
- * @param {HTMLElement|Document} element
- *   The root element on which to query the selector, defaults to `document`.
- * @return {Array<HTMLElement>}
- *   A list of elements on which the component should be mounted.
- */
-export declare function getComponentElements(nameOrSelector: string, element?: HTMLElement | Document): HTMLElement[];
-/**
- * Test if an event is defined in the given config.
- */
-export declare function eventIsDefinedInConfig(event: string, config: BaseConfig): boolean;
-/**
- * Test if an event can be used on the given element.
- */
-export declare function eventIsNative(event: string, element: HTMLElement): boolean;
-/**
- * Get the target of a given event.
- */
-export declare function getEventTarget(instance: Base, event: string, config: BaseConfig): Base['$el'];
-/**
- * Get all mounted instances or the ones from a given component.
- * @link https://js-toolkit.studiometa.dev/api/helpers/getInstances.html
- */
-export declare function getInstances(): ReadonlySet<Base>;
-export declare function getInstances<T extends BaseConstructor = BaseConstructor>(ctor: T): Set<InstanceType<T>>;
-export declare function getElements(): Set<HTMLElement & {
-    __base__: Map<string, Base>;
-}>;
-export declare function addInstance(instance: Base): void;
-export declare function deleteInstance(instance: Base): void;
-/**
- * Test whether an instance is currently registered in the global storage.
- * Membership is added on `before-mounted` and removed on `after-destroyed`,
- * so this is an O(1) check for "is this instance live" without copying the Set.
- */
-export declare function hasInstance(instance: Base): boolean;
-export declare function addToRegistry(nameOrSelector: string, ctor: BaseConstructor): void;
-/**
- * Find the closest instance from the given element in the given set of Base instances.
- */
-export declare function findClosestInstance<T extends Base = Base>(element: HTMLElement, instances: Set<T>): T;

package/dist/Base/utils.js

@@ -1,172 +0,0 @@
-import { isArray, isDefined, isDev } from "../utils/is.js";
-import { SmartQueue } from "../utils/SmartQueue.js";
-import { dashCase } from "../utils/string/changeCase.js";
-import { features } from "./features.js";
-import { useMutation } from "../services/MutationService.js";
-import { getInstanceFromElement } from "../helpers/getInstanceFromElement.js";
-let queue;
-function addToQueue(fn) {
-  if (features.get("blocking")) {
-    fn();
-    return;
-  }
-  if (!queue) {
-    queue = new SmartQueue();
-  }
-  return queue.add(fn);
-}
-const selectors = /* @__PURE__ */ new Map();
-const separator = " ";
-function getSelector(nameOrSelector) {
-  const { component } = features.get("attributes");
-  const prefix = features.get("prefix");
-  const key = prefix + component + nameOrSelector;
-  if (!selectors.has(key)) {
-    const parts = [
-      // Tag select
-      `${prefix}-${dashCase(nameOrSelector)}`,
-      // Single selector
-      `[${component}="${nameOrSelector}"]`,
-      // Selector in the middle of a list of selectors
-      `[${component}*="${separator}${nameOrSelector}${separator}"]`,
-      // Selector at the end of a list of selectors
-      `[${component}$="${separator}${nameOrSelector}"]`,
-      // Selector at the beginning of a list of selectors
-      `[${component}^="${nameOrSelector}${separator}"]`
-    ];
-    selectors.set(key, parts.join(","));
-  }
-  return selectors.get(key);
-}
-function getComponentElements(nameOrSelector, element = document) {
-  const selector = getSelector(nameOrSelector);
-  let elements = [];
-  try {
-    elements = Array.from(element.querySelectorAll(selector));
-  } catch {
-  }
-  if (elements.length === 0 && nameOrSelector[0] === nameOrSelector[0].toLowerCase()) {
-    elements = Array.from(element.querySelectorAll(nameOrSelector));
-  }
-  return elements;
-}
-function eventIsDefinedInConfig(event, config) {
-  return isArray(config.emits) && config.emits.includes(event);
-}
-function eventIsNative(event, element) {
-  return isDefined(element[`on${event}`]);
-}
-function getEventTarget(instance, event, config) {
-  if (eventIsDefinedInConfig(event, config) || eventIsNative(event, instance.$el)) {
-    return instance.$el;
-  }
-}
-function getInstancesStorage() {
-  return globalThis.__JS_TOOLKIT_INSTANCES__ ??= /* @__PURE__ */ new Set();
-}
-function getElementsStorage() {
-  return globalThis.__JS_TOOLKIT_ELEMENTS__ ??= /* @__PURE__ */ new Set();
-}
-function getInstances(ctor) {
-  if (isDefined(ctor)) {
-    const filteredInstances = /* @__PURE__ */ new Set();
-    for (const instance of getInstancesStorage()) {
-      if (instance instanceof ctor) {
-        filteredInstances.add(instance);
-      }
-    }
-    return filteredInstances;
-  }
-  return new Set(getInstancesStorage());
-}
-function getElements() {
-  return new Set(getElementsStorage());
-}
-function addInstance(instance) {
-  getInstancesStorage().add(instance);
-  getElementsStorage().add(instance.$el);
-}
-function deleteInstance(instance) {
-  getInstancesStorage().delete(instance);
-  getElementsStorage().delete(instance.$el);
-}
-function hasInstance(instance) {
-  return getInstancesStorage().has(instance);
-}
-const registryKey = "__JS_TOOLKIT_REGISTRY__";
-function registry() {
-  return globalThis[registryKey] ??= /* @__PURE__ */ new Map();
-}
-function mutationCallback() {
-  addToQueue(() => {
-    for (const [nameOrSelector, ctor] of registry()) {
-      for (const el of getComponentElements(nameOrSelector)) {
-        if (!getInstanceFromElement(el, ctor)) {
-          new ctor(el).$mount();
-        }
-      }
-    }
-  });
-  addToQueue(() => {
-    for (const instance of getInstances()) {
-      if (!instance.$el.isConnected) {
-        instance.$terminate();
-      }
-    }
-  });
-}
-function addToRegistry(nameOrSelector, ctor) {
-  if (registry().has(nameOrSelector)) {
-    if (isDev && registry().get(nameOrSelector) !== ctor) {
-      console.warn(
-        `[${nameOrSelector}] A different component is already registered under this name. Registration is ignored \u2014 like \`customElements.define\`, a name maps to a single component. Give this component a unique \`config.name\` (or use \`withExtraConfig\`, which renames automatically).`
-      );
-    }
-    return;
-  }
-  registry().set(nameOrSelector, ctor);
-  if (ctor.config?.components) {
-    for (const [selector, childConstructor] of Object.entries(ctor.config?.components)) {
-      if ("$isBase" in childConstructor && childConstructor.$isBase) {
-        addToRegistry(selector, childConstructor);
-      }
-    }
-  }
-  const mutation = useMutation(document, { childList: true, subtree: true });
-  if (!mutation.has(registryKey)) {
-    mutation.add(registryKey, mutationCallback);
-  }
-}
-function findClosestInstance(element, instances) {
-  let closest = null;
-  let minDepth = Infinity;
-  for (const instance of instances) {
-    let depth = 0;
-    let el = element;
-    while (el && el !== instance.$el) {
-      depth++;
-      el = el.parentElement;
-    }
-    if (depth < minDepth) {
-      minDepth = depth;
-      closest = instance;
-    }
-  }
-  return closest;
-}
-export {
-  addInstance,
-  addToQueue,
-  addToRegistry,
-  deleteInstance,
-  eventIsDefinedInConfig,
-  eventIsNative,
-  findClosestInstance,
-  getComponentElements,
-  getElements,
-  getEventTarget,
-  getInstances,
-  getSelector,
-  hasInstance
-};
-//# sourceMappingURL=utils.js.map

package/dist/Base/utils.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../packages/js-toolkit/Base/utils.ts"],
-  "sourcesContent": ["import { isArray, isDefined, isDev } from '../utils/is.js';\nimport { SmartQueue } from '../utils/SmartQueue.js';\nimport { dashCase } from '../utils/string/changeCase.js';\nimport type { Base, BaseConfig, BaseConstructor } from './Base.js';\nimport { features } from './features.js';\nimport { useMutation } from '../services/MutationService.js';\nimport { getInstanceFromElement } from '../helpers/getInstanceFromElement.js';\n\nlet queue: SmartQueue;\n\n/**\n * Add a task to the main queue.\n */\nexport function addToQueue(fn: () => unknown) {\n  if (features.get('blocking')) {\n    fn();\n    return;\n  }\n\n  if (!queue) {\n    queue = new SmartQueue();\n  }\n\n  return queue.add(fn);\n}\n\nconst selectors = new Map();\n\n// Separator used for multi-component declaration in `data-component` attributeS.\nconst separator = ' ';\n\n/**\n * Get the selector for a given component.\n */\nexport function getSelector(nameOrSelector: string): string {\n  const { component } = features.get('attributes');\n  const prefix = features.get('prefix');\n  const key = prefix + component + nameOrSelector;\n\n  if (!selectors.has(key)) {\n    const parts = [\n      // Tag select\n      `${prefix}-${dashCase(nameOrSelector)}`,\n      // Single selector\n      `[${component}=\"${nameOrSelector}\"]`,\n      // Selector in the middle of a list of selectors\n      `[${component}*=\"${separator}${nameOrSelector}${separator}\"]`,\n      // Selector at the end of a list of selectors\n      `[${component}$=\"${separator}${nameOrSelector}\"]`,\n      // Selector at the beginning of a list of selectors\n      `[${component}^=\"${nameOrSelector}${separator}\"]`,\n    ];\n    selectors.set(key, parts.join(','));\n  }\n\n  return selectors.get(key);\n}\n\n/**\n * Get a list of elements based on the name of a component.\n *\n * @param {string} nameOrSelector\n *   The name or selector to used for this component.\n * @param {HTMLElement|Document} element\n *   The root element on which to query the selector, defaults to `document`.\n * @return {Array<HTMLElement>}\n *   A list of elements on which the component should be mounted.\n */\nexport function getComponentElements(\n  nameOrSelector: string,\n  element: HTMLElement | Document = document,\n): HTMLElement[] {\n  const selector = getSelector(nameOrSelector);\n  let elements = [];\n\n  try {\n    elements = Array.from(element.querySelectorAll(selector));\n    // eslint-disable-next-line no-empty\n  } catch {}\n\n  // If no child component found with the default selector, and if the selector does not\n  // start with an uppercase letter, matching a component's name, try a classic DOM selector.\n  if (elements.length === 0 && nameOrSelector[0] === nameOrSelector[0].toLowerCase()) {\n    elements = Array.from(element.querySelectorAll(nameOrSelector));\n  }\n\n  return elements;\n}\n\n/**\n * Test if an event is defined in the given config.\n */\nexport function eventIsDefinedInConfig(event: string, config: BaseConfig): boolean {\n  return isArray(config.emits) && config.emits.includes(event);\n}\n\n/**\n * Test if an event can be used on the given element.\n */\nexport function eventIsNative(event: string, element: HTMLElement): boolean {\n  return isDefined(element[`on${event}`]);\n}\n\n/**\n * Get the target of a given event.\n */\nexport function getEventTarget(instance: Base, event: string, config: BaseConfig): Base['$el'] {\n  if (eventIsDefinedInConfig(event, config) || eventIsNative(event, instance.$el)) {\n    return instance.$el;\n  }\n}\n\n/**\n * Get the global instance storage.\n * We attach it to `globalThis` so it can be shared between different\n * instances of the framework.\n */\nfunction getInstancesStorage(): Set<Base> {\n  return (globalThis.__JS_TOOLKIT_INSTANCES__ ??= new Set<Base>());\n}\n\n/**\n * Get the global elements storage.\n * It will hold reference to all elements with at least one component attached to it.\n */\nfunction getElementsStorage(): Set<HTMLElement & { __base__: Map<string, Base> }> {\n  return (globalThis.__JS_TOOLKIT_ELEMENTS__ ??= new Set<\n    HTMLElement & { __base__: Map<string, Base> }\n  >());\n}\n\n/**\n * Get all mounted instances or the ones from a given component.\n * @link https://js-toolkit.studiometa.dev/api/helpers/getInstances.html\n */\nexport function getInstances(): ReadonlySet<Base>;\nexport function getInstances<T extends BaseConstructor = BaseConstructor>(\n  ctor: T,\n): Set<InstanceType<T>>;\nexport function getInstances<T extends BaseConstructor = BaseConstructor>(\n  ctor?: T,\n): ReadonlySet<InstanceType<T>> | ReadonlySet<Base> {\n  if (isDefined(ctor)) {\n    const filteredInstances = new Set<InstanceType<T>>();\n    for (const instance of getInstancesStorage()) {\n      if (instance instanceof ctor) {\n        filteredInstances.add(instance as InstanceType<T>);\n      }\n    }\n    return filteredInstances;\n  }\n\n  return new Set(getInstancesStorage());\n}\n\nexport function getElements() {\n  return new Set(getElementsStorage());\n}\n\nexport function addInstance(instance: Base) {\n  getInstancesStorage().add(instance);\n  getElementsStorage().add(instance.$el as HTMLElement & { __base__: Map<string, Base> });\n}\n\nexport function deleteInstance(instance: Base) {\n  getInstancesStorage().delete(instance);\n  getElementsStorage().delete(instance.$el as HTMLElement & { __base__: Map<string, Base> });\n}\n\n/**\n * Test whether an instance is currently registered in the global storage.\n * Membership is added on `before-mounted` and removed on `after-destroyed`,\n * so this is an O(1) check for \"is this instance live\" without copying the Set.\n */\nexport function hasInstance(instance: Base): boolean {\n  return getInstancesStorage().has(instance);\n}\n\nconst registryKey = '__JS_TOOLKIT_REGISTRY__';\n\nfunction registry() {\n  return (globalThis[registryKey] ??= new Map<string, BaseConstructor>());\n}\n\nfunction mutationCallback() {\n  addToQueue(() => {\n    for (const [nameOrSelector, ctor] of registry()) {\n      for (const el of getComponentElements(nameOrSelector)) {\n        if (!getInstanceFromElement(el, ctor)) {\n          new ctor(el).$mount();\n        }\n      }\n    }\n  });\n\n  addToQueue(() => {\n    for (const instance of getInstances()) {\n      if (!instance.$el.isConnected) {\n        instance.$terminate();\n      }\n    }\n  });\n}\n\nexport function addToRegistry(nameOrSelector: string, ctor: BaseConstructor) {\n  if (registry().has(nameOrSelector)) {\n    if (isDev && registry().get(nameOrSelector) !== ctor) {\n      console.warn(\n        `[${nameOrSelector}] A different component is already registered under this name. ` +\n          'Registration is ignored \u2014 like `customElements.define`, a name maps to a single ' +\n          'component. Give this component a unique `config.name` (or use `withExtraConfig`, ' +\n          'which renames automatically).',\n      );\n    }\n    return;\n  }\n\n  registry().set(nameOrSelector, ctor);\n\n  // Add children components to the registry\n  if (ctor.config?.components) {\n    for (const [selector, childConstructor] of Object.entries(ctor.config?.components)) {\n      if ('$isBase' in childConstructor && childConstructor.$isBase) {\n        addToRegistry(selector, childConstructor);\n      }\n    }\n  }\n\n  const mutation = useMutation(document, { childList: true, subtree: true });\n  if (!mutation.has(registryKey)) {\n    mutation.add(registryKey, mutationCallback);\n  }\n}\n\n/**\n * Find the closest instance from the given element in the given set of Base instances.\n */\nexport function findClosestInstance<T extends Base = Base>(\n  element: HTMLElement,\n  instances: Set<T>,\n): T {\n  let closest = null;\n  let minDepth = Infinity;\n\n  for (const instance of instances) {\n    let depth = 0;\n    let el = element;\n    while (el && el !== instance.$el) {\n      depth++;\n      el = el.parentElement;\n    }\n\n    if (depth < minDepth) {\n      minDepth = depth;\n      closest = instance;\n    }\n  }\n\n  return closest;\n}\n"],
-  "mappings": "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",
-  "names": []
-}

package/dist/autoload/autoload.d.ts

@@ -1,37 +0,0 @@
-import { ComponentLoader, type LoaderDependencies } from './loader.js';
-import type { ComponentManifest } from './types.js';
-export interface AutoloadOptions {
-    /**
-     * One or more manifests to compose into a single lookup table. When two manifests declare the
-     * same token, the entry from the manifest that appears later in the array wins.
-     */
-    manifests: readonly ComponentManifest[];
-    /** The DOM scope to scan and observe for `data-component` elements. Defaults to `document`. */
-    root?: Document | Element;
-    /** Tokens to force-load eagerly regardless of their manifest strategy or `data-load` attribute. */
-    eager?: readonly string[];
-    /** Loader dependency-injection seams, kept for testability. */
-    dependencies?: Partial<LoaderDependencies>;
-}
-/** The runtime handle returned by {@link autoload}. */
-export interface AutoloadHandle {
-    /** The underlying loader instance. */
-    loader: ComponentLoader;
-    /** The composed manifest the loader was started with. */
-    manifest: ComponentManifest;
-    /** Stop discovery and release every scheduled trigger. */
-    stop(): void;
-}
-/**
- * Compose several manifests into one. Later manifests take precedence over earlier ones when they
- * declare the same token, so callers can layer overrides on top of a base manifest.
- */
-export declare function composeManifests(manifests: readonly ComponentManifest[]): ComponentManifest;
-/**
- * Start the declarative autoloader for the given manifests.
- *
- * Calling this function is the only thing that touches the DOM — importing the module does nothing
- * on its own. It composes the manifests, creates a {@link ComponentLoader}, starts discovery and
- * returns a handle that exposes the loader, the composed manifest and a `stop()` method.
- */
-export declare function autoload(options: AutoloadOptions): AutoloadHandle;

package/dist/autoload/autoload.js

@@ -1,29 +0,0 @@
-import { ComponentLoader } from "./loader.js";
-function composeManifests(manifests) {
-  const composed = {};
-  for (const manifest of manifests) {
-    for (const token of Object.keys(manifest)) {
-      composed[token] = manifest[token];
-    }
-  }
-  return composed;
-}
-function autoload(options) {
-  const manifest = composeManifests(options.manifests);
-  const loader = new ComponentLoader({
-    manifest,
-    root: options.root,
-    dependencies: options.dependencies
-  });
-  loader.start({ eagerComponents: options.eager ?? [] });
-  return {
-    loader,
-    manifest,
-    stop: () => loader.stop()
-  };
-}
-export {
-  autoload,
-  composeManifests
-};
-//# sourceMappingURL=autoload.js.map

package/dist/autoload/autoload.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../packages/js-toolkit/autoload/autoload.ts"],
-  "sourcesContent": ["import { ComponentLoader, type LoaderDependencies } from './loader.js';\nimport type { ComponentManifest } from './types.js';\n\nexport interface AutoloadOptions {\n  /**\n   * One or more manifests to compose into a single lookup table. When two manifests declare the\n   * same token, the entry from the manifest that appears later in the array wins.\n   */\n  manifests: readonly ComponentManifest[];\n  /** The DOM scope to scan and observe for `data-component` elements. Defaults to `document`. */\n  root?: Document | Element;\n  /** Tokens to force-load eagerly regardless of their manifest strategy or `data-load` attribute. */\n  eager?: readonly string[];\n  /** Loader dependency-injection seams, kept for testability. */\n  dependencies?: Partial<LoaderDependencies>;\n}\n\n/** The runtime handle returned by {@link autoload}. */\nexport interface AutoloadHandle {\n  /** The underlying loader instance. */\n  loader: ComponentLoader;\n  /** The composed manifest the loader was started with. */\n  manifest: ComponentManifest;\n  /** Stop discovery and release every scheduled trigger. */\n  stop(): void;\n}\n\n/**\n * Compose several manifests into one. Later manifests take precedence over earlier ones when they\n * declare the same token, so callers can layer overrides on top of a base manifest.\n */\nexport function composeManifests(manifests: readonly ComponentManifest[]): ComponentManifest {\n  const composed: ComponentManifest = {};\n  for (const manifest of manifests) {\n    for (const token of Object.keys(manifest)) {\n      composed[token] = manifest[token];\n    }\n  }\n  return composed;\n}\n\n/**\n * Start the declarative autoloader for the given manifests.\n *\n * Calling this function is the only thing that touches the DOM \u2014 importing the module does nothing\n * on its own. It composes the manifests, creates a {@link ComponentLoader}, starts discovery and\n * returns a handle that exposes the loader, the composed manifest and a `stop()` method.\n */\nexport function autoload(options: AutoloadOptions): AutoloadHandle {\n  const manifest = composeManifests(options.manifests);\n  const loader = new ComponentLoader({\n    manifest,\n    root: options.root,\n    dependencies: options.dependencies,\n  });\n  loader.start({ eagerComponents: options.eager ?? [] });\n  return {\n    loader,\n    manifest,\n    stop: () => loader.stop(),\n  };\n}\n"],
-  "mappings": "AAAA,SAAS,uBAAgD;AA+BlD,SAAS,iBAAiB,WAA4D;AAC3F,QAAM,WAA8B,CAAC;AACrC,aAAW,YAAY,WAAW;AAChC,eAAW,SAAS,OAAO,KAAK,QAAQ,GAAG;AACzC,eAAS,KAAK,IAAI,SAAS,KAAK;AAAA,IAClC;AAAA,EACF;AACA,SAAO;AACT;AASO,SAAS,SAAS,SAA0C;AACjE,QAAM,WAAW,iBAAiB,QAAQ,SAAS;AACnD,QAAM,SAAS,IAAI,gBAAgB;AAAA,IACjC;AAAA,IACA,MAAM,QAAQ;AAAA,IACd,cAAc,QAAQ;AAAA,EACxB,CAAC;AACD,SAAO,MAAM,EAAE,iBAAiB,QAAQ,SAAS,CAAC,EAAE,CAAC;AACrD,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,MAAM,MAAM,OAAO,KAAK;AAAA,EAC1B;AACF;",
-  "names": []
-}

package/dist/autoload/define-manifest.d.ts

@@ -1,60 +0,0 @@
-import type { ComponentLoadStrategy, ComponentManifest } from './types.js';
-/**
- * A map of module keys to lazy importers, as produced by bundler glob helpers.
- *
- * This is the shape Vite's `import.meta.glob('./x/*.ts')` returns, and the shape the
- * {@link fromWebpackContext} adapter normalizes a webpack context to. Every value is a function
- * that imports the module and resolves its namespace object.
- */
-export type ModuleRecord = Record<string, () => Promise<Record<string, unknown>>>;
-/**
- * A per-token override applied on top of the values {@link defineManifest} derives from a module
- * key. Every field is optional; an omitted field keeps the derived or option-level default.
- */
-export interface ComponentOverride {
-    /** Replace the token derived from the module key. */
-    token?: string;
-    /** Override the load strategy for this component. */
-    strategy?: ComponentLoadStrategy;
-    /** Override the grouping key for this component. */
-    group?: string;
-    /** The named export to resolve from the module; defaults to the derived token. */
-    exportName?: 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[];
-}
-/** Options accepted by {@link defineManifest}. */
-export interface DefineManifestOptions {
-    /**
-     * The lazy importers to build entries from, keyed by module path. Feed it a bundler glob directly
-     * or normalize one first with {@link fromMetaGlob} / {@link fromWebpackContext}.
-     */
-    modules: ModuleRecord;
-    /** The npm package the components belong to (optional informational metadata). */
-    packageName?: string;
-    /** The default load strategy for every component. Defaults to `'eager'`. */
-    strategy?: ComponentLoadStrategy;
-    /** The default grouping key for every component. Defaults to each component's token. */
-    group?: string;
-    /** Per-token overrides, keyed by the token derived from the module key. */
-    components?: Record<string, ComponentOverride>;
-}
-/**
- * Build a {@link ComponentManifest} from a record of lazy importers — the pure counterpart of a
- * generated per-package manifest, for app developers autoloading their own js-toolkit components.
- *
- * For every `[key, importer]` in `options.modules` it derives a token from the key (see
- * {@link deriveToken}), resolves the named export matching the token (falling back to the module's
- * `default` export), and applies the option-level and per-token defaults. The loader validates that
- * the resolved value is a js-toolkit `Base` constructor and reports an error event otherwise, so no
- * validation happens here.
- *
- * This factory is pure: it never touches the DOM and never registers anything. Pass its result to
- * {@link registerManifests} (or {@link autoload}) to actually start discovery. When two module keys
- * derive the same token a `console.warn` is emitted and the later key wins.
- */
-export declare function defineManifest(options: DefineManifestOptions): ComponentManifest;

package/dist/autoload/define-manifest.js

@@ -1,51 +0,0 @@
-import { DEFAULT_DIAGNOSTIC_PREFIX } from "./loader.js";
-function deriveToken(key) {
-  const segments = key.split("/").filter((segment) => segment && segment !== ".");
-  const last = segments.at(-1) ?? "";
-  const base = last.replace(/\.[^.]+$/, "");
-  if (base === "index" && segments.length >= 2) {
-    return segments.at(-2);
-  }
-  return base;
-}
-function defineManifest(options) {
-  const overrides = options.components ?? {};
-  const defaultStrategy = options.strategy ?? "eager";
-  const manifest = {};
-  for (const [key, importer] of Object.entries(options.modules)) {
-    const derivedToken = deriveToken(key);
-    const override = overrides[derivedToken] ?? {};
-    const token = override.token ?? derivedToken;
-    const exportName = override.exportName ?? token;
-    if (Object.prototype.hasOwnProperty.call(manifest, token)) {
-      console.warn(
-        `${DEFAULT_DIAGNOSTIC_PREFIX} Duplicate component token "${token}" derived from "${key}"; the later module wins.`
-      );
-    }
-    const entry = {
-      token,
-      strategy: override.strategy ?? defaultStrategy,
-      group: override.group ?? options.group ?? token,
-      exportName,
-      load: () => importer().then((module) => module[exportName] ?? module.default)
-    };
-    if (options.packageName !== void 0) {
-      entry.packageName = options.packageName;
-    }
-    if (override.children !== void 0) {
-      entry.children = override.children;
-    }
-    if (override.styles !== void 0) {
-      entry.styles = override.styles;
-    }
-    if (override.integrations !== void 0) {
-      entry.integrations = override.integrations;
-    }
-    manifest[token] = entry;
-  }
-  return manifest;
-}
-export {
-  defineManifest
-};
-//# sourceMappingURL=define-manifest.js.map

package/dist/autoload/define-manifest.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../packages/js-toolkit/autoload/define-manifest.ts"],
-  "sourcesContent": ["import type { BaseConstructor } from '../Base/Base.js';\nimport { DEFAULT_DIAGNOSTIC_PREFIX } from './loader.js';\nimport type { ComponentLoadStrategy, ComponentManifest, ComponentManifestEntry } from './types.js';\n\n/**\n * A map of module keys to lazy importers, as produced by bundler glob helpers.\n *\n * This is the shape Vite's `import.meta.glob('./x/*.ts')` returns, and the shape the\n * {@link fromWebpackContext} adapter normalizes a webpack context to. Every value is a function\n * that imports the module and resolves its namespace object.\n */\nexport type ModuleRecord = Record<string, () => Promise<Record<string, unknown>>>;\n\n/**\n * A per-token override applied on top of the values {@link defineManifest} derives from a module\n * key. Every field is optional; an omitted field keeps the derived or option-level default.\n */\nexport interface ComponentOverride {\n  /** Replace the token derived from the module key. */\n  token?: string;\n  /** Override the load strategy for this component. */\n  strategy?: ComponentLoadStrategy;\n  /** Override the grouping key for this component. */\n  group?: string;\n  /** The named export to resolve from the module; defaults to the derived token. */\n  exportName?: string;\n  /** The tokens of the constructor's configured child components, for recursive registration. */\n  children?: readonly string[];\n  /** Stylesheet paths associated with this component (informational). */\n  styles?: readonly string[];\n  /** Optional integration keys associated with this component (informational). */\n  integrations?: readonly string[];\n}\n\n/** Options accepted by {@link defineManifest}. */\nexport interface DefineManifestOptions {\n  /**\n   * The lazy importers to build entries from, keyed by module path. Feed it a bundler glob directly\n   * or normalize one first with {@link fromMetaGlob} / {@link fromWebpackContext}.\n   */\n  modules: ModuleRecord;\n  /** The npm package the components belong to (optional informational metadata). */\n  packageName?: string;\n  /** The default load strategy for every component. Defaults to `'eager'`. */\n  strategy?: ComponentLoadStrategy;\n  /** The default grouping key for every component. Defaults to each component's token. */\n  group?: string;\n  /** Per-token overrides, keyed by the token derived from the module key. */\n  components?: Record<string, ComponentOverride>;\n}\n\n/**\n * Derive a component token from a module key: the basename without its extension, falling back to\n * the parent directory name when the basename is `index` (so `./a/b/Foo/index.ts` yields `Foo`).\n */\nfunction deriveToken(key: string): string {\n  const segments = key.split('/').filter((segment) => segment && segment !== '.');\n  const last = segments.at(-1) ?? '';\n  const base = last.replace(/\\.[^.]+$/, '');\n  if (base === 'index' && segments.length >= 2) {\n    return segments.at(-2) as string;\n  }\n  return base;\n}\n\n/**\n * Build a {@link ComponentManifest} from a record of lazy importers \u2014 the pure counterpart of a\n * generated per-package manifest, for app developers autoloading their own js-toolkit components.\n *\n * For every `[key, importer]` in `options.modules` it derives a token from the key (see\n * {@link deriveToken}), resolves the named export matching the token (falling back to the module's\n * `default` export), and applies the option-level and per-token defaults. The loader validates that\n * the resolved value is a js-toolkit `Base` constructor and reports an error event otherwise, so no\n * validation happens here.\n *\n * This factory is pure: it never touches the DOM and never registers anything. Pass its result to\n * {@link registerManifests} (or {@link autoload}) to actually start discovery. When two module keys\n * derive the same token a `console.warn` is emitted and the later key wins.\n */\nexport function defineManifest(options: DefineManifestOptions): ComponentManifest {\n  const overrides = options.components ?? {};\n  const defaultStrategy = options.strategy ?? 'eager';\n  const manifest: ComponentManifest = {};\n\n  for (const [key, importer] of Object.entries(options.modules)) {\n    const derivedToken = deriveToken(key);\n    const override = overrides[derivedToken] ?? {};\n    const token = override.token ?? derivedToken;\n    const exportName = override.exportName ?? token;\n\n    if (Object.prototype.hasOwnProperty.call(manifest, token)) {\n      console.warn(\n        `${DEFAULT_DIAGNOSTIC_PREFIX} Duplicate component token \"${token}\" derived from \"${key}\"; the later module wins.`,\n      );\n    }\n\n    const entry: ComponentManifestEntry = {\n      token,\n      strategy: override.strategy ?? defaultStrategy,\n      group: override.group ?? options.group ?? token,\n      exportName,\n      load: () =>\n        importer().then((module) => (module[exportName] ?? module.default) as BaseConstructor),\n    };\n\n    if (options.packageName !== undefined) {\n      entry.packageName = options.packageName;\n    }\n    if (override.children !== undefined) {\n      entry.children = override.children;\n    }\n    if (override.styles !== undefined) {\n      entry.styles = override.styles;\n    }\n    if (override.integrations !== undefined) {\n      entry.integrations = override.integrations;\n    }\n\n    manifest[token] = entry;\n  }\n\n  return manifest;\n}\n"],
-  "mappings": "AACA,SAAS,iCAAiC;AAsD1C,SAAS,YAAY,KAAqB;AACxC,QAAM,WAAW,IAAI,MAAM,GAAG,EAAE,OAAO,CAAC,YAAY,WAAW,YAAY,GAAG;AAC9E,QAAM,OAAO,SAAS,GAAG,EAAE,KAAK;AAChC,QAAM,OAAO,KAAK,QAAQ,YAAY,EAAE;AACxC,MAAI,SAAS,WAAW,SAAS,UAAU,GAAG;AAC5C,WAAO,SAAS,GAAG,EAAE;AAAA,EACvB;AACA,SAAO;AACT;AAgBO,SAAS,eAAe,SAAmD;AAChF,QAAM,YAAY,QAAQ,cAAc,CAAC;AACzC,QAAM,kBAAkB,QAAQ,YAAY;AAC5C,QAAM,WAA8B,CAAC;AAErC,aAAW,CAAC,KAAK,QAAQ,KAAK,OAAO,QAAQ,QAAQ,OAAO,GAAG;AAC7D,UAAM,eAAe,YAAY,GAAG;AACpC,UAAM,WAAW,UAAU,YAAY,KAAK,CAAC;AAC7C,UAAM,QAAQ,SAAS,SAAS;AAChC,UAAM,aAAa,SAAS,cAAc;AAE1C,QAAI,OAAO,UAAU,eAAe,KAAK,UAAU,KAAK,GAAG;AACzD,cAAQ;AAAA,QACN,GAAG,yBAAyB,+BAA+B,KAAK,mBAAmB,GAAG;AAAA,MACxF;AAAA,IACF;AAEA,UAAM,QAAgC;AAAA,MACpC;AAAA,MACA,UAAU,SAAS,YAAY;AAAA,MAC/B,OAAO,SAAS,SAAS,QAAQ,SAAS;AAAA,MAC1C;AAAA,MACA,MAAM,MACJ,SAAS,EAAE,KAAK,CAAC,WAAY,OAAO,UAAU,KAAK,OAAO,OAA2B;AAAA,IACzF;AAEA,QAAI,QAAQ,gBAAgB,QAAW;AACrC,YAAM,cAAc,QAAQ;AAAA,IAC9B;AACA,QAAI,SAAS,aAAa,QAAW;AACnC,YAAM,WAAW,SAAS;AAAA,IAC5B;AACA,QAAI,SAAS,WAAW,QAAW;AACjC,YAAM,SAAS,SAAS;AAAA,IAC1B;AACA,QAAI,SAAS,iBAAiB,QAAW;AACvC,YAAM,eAAe,SAAS;AAAA,IAChC;AAEA,aAAS,KAAK,IAAI;AAAA,EACpB;AAEA,SAAO;AACT;",
-  "names": []
-}

package/dist/autoload/index.d.ts

@@ -1,6 +0,0 @@
-export type { ComponentLoadStrategy, ComponentManifestEntry, ComponentManifest } from './types.js';
-export { ComponentLoader, DEFAULT_DIAGNOSTIC_PREFIX, VISIBLE_ROOT_MARGIN, IDLE_TIMEOUT, type LoaderDependencies, type ComponentLoaderOptions, type ComponentLoaderStartOptions, } from './loader.js';
-export { autoload, composeManifests, type AutoloadOptions, type AutoloadHandle, } from './autoload.js';
-export { registerManifest, registerManifests, readEagerTokens, type AutoloadRuntime, type RegisterManifestOptions, } from './runtime.js';
-export { defineManifest, type ModuleRecord, type ComponentOverride, type DefineManifestOptions, } from './define-manifest.js';
-export { fromMetaGlob, fromWebpackContext, type WebpackContextLike } from './modules.js';

package/dist/autoload/index.js

@@ -1,34 +0,0 @@
-import {
-  ComponentLoader,
-  DEFAULT_DIAGNOSTIC_PREFIX,
-  VISIBLE_ROOT_MARGIN,
-  IDLE_TIMEOUT
-} from "./loader.js";
-import {
-  autoload,
-  composeManifests
-} from "./autoload.js";
-import {
-  registerManifest,
-  registerManifests,
-  readEagerTokens
-} from "./runtime.js";
-import {
-  defineManifest
-} from "./define-manifest.js";
-import { fromMetaGlob, fromWebpackContext } from "./modules.js";
-export {
-  ComponentLoader,
-  DEFAULT_DIAGNOSTIC_PREFIX,
-  IDLE_TIMEOUT,
-  VISIBLE_ROOT_MARGIN,
-  autoload,
-  composeManifests,
-  defineManifest,
-  fromMetaGlob,
-  fromWebpackContext,
-  readEagerTokens,
-  registerManifest,
-  registerManifests
-};
-//# sourceMappingURL=index.js.map

package/dist/autoload/index.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../packages/js-toolkit/autoload/index.ts"],
-  "sourcesContent": ["export type { ComponentLoadStrategy, ComponentManifestEntry, ComponentManifest } from './types.js';\nexport {\n  ComponentLoader,\n  DEFAULT_DIAGNOSTIC_PREFIX,\n  VISIBLE_ROOT_MARGIN,\n  IDLE_TIMEOUT,\n  type LoaderDependencies,\n  type ComponentLoaderOptions,\n  type ComponentLoaderStartOptions,\n} from './loader.js';\nexport {\n  autoload,\n  composeManifests,\n  type AutoloadOptions,\n  type AutoloadHandle,\n} from './autoload.js';\nexport {\n  registerManifest,\n  registerManifests,\n  readEagerTokens,\n  type AutoloadRuntime,\n  type RegisterManifestOptions,\n} from './runtime.js';\nexport {\n  defineManifest,\n  type ModuleRecord,\n  type ComponentOverride,\n  type DefineManifestOptions,\n} from './define-manifest.js';\nexport { fromMetaGlob, fromWebpackContext, type WebpackContextLike } from './modules.js';\n"],
-  "mappings": "AACA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAIK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OAGK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAGK;AACP;AAAA,EACE;AAAA,OAIK;AACP,SAAS,cAAc,0BAAmD;",
-  "names": []
-}

package/dist/autoload/loader.d.ts

@@ -1,108 +0,0 @@
-import type { BaseConstructor } from '../Base/Base.js';
-import type { ComponentLoadStrategy, ComponentManifest, ComponentManifestEntry } from './types.js';
-/** The diagnostic prefix used when the host does not inject its own. */
-export declare const DEFAULT_DIAGNOSTIC_PREFIX = "[@studiometa/js-toolkit/autoload]";
-/** Start loading visible components shortly before they enter the viewport. */
-export declare const VISIBLE_ROOT_MARGIN = "200px 0px";
-/** Ensure idle components eventually load even when the main thread remains busy. */
-export declare const IDLE_TIMEOUT = 2000;
-interface IdleDeadlineLike {
-    readonly didTimeout: boolean;
-    timeRemaining: () => number;
-}
-type IdleHandle = number;
-type RequestIdleCallbackLike = (callback: (deadline: IdleDeadlineLike) => void, options?: {
-    timeout: number;
-}) => IdleHandle;
-type CancelIdleCallbackLike = (handle: IdleHandle) => void;
-type RegisterComponent = (Constructor: BaseConstructor, token: string) => Promise<unknown> | unknown;
-type ComponentState = 'scheduled' | 'loading' | 'registered' | 'failed';
-interface ComponentRecord {
-    state: ComponentState;
-    promise?: Promise<void>;
-    Constructor?: BaseConstructor;
-    cleanups: Set<() => void>;
-    scheduledStrategies: Set<ComponentLoadStrategy>;
-}
-export interface LoaderDependencies {
-    document: Document;
-    MutationObserver?: typeof MutationObserver;
-    IntersectionObserver?: typeof IntersectionObserver;
-    requestIdleCallback?: RequestIdleCallbackLike;
-    cancelIdleCallback?: CancelIdleCallbackLike;
-    setTimeout: typeof globalThis.setTimeout;
-    clearTimeout: typeof globalThis.clearTimeout;
-    registerComponent: RegisterComponent;
-    console: Pick<Console, 'warn' | 'error'>;
-    CustomEvent: typeof CustomEvent;
-    /** The prefix prepended to every diagnostic message emitted by the loader. */
-    diagnosticPrefix: string;
-}
-export interface ComponentLoaderOptions {
-    manifest: ComponentManifest;
-    /** The DOM scope to scan and observe. Defaults to the injected `document`. */
-    root?: Document | Element;
-    dependencies?: Partial<LoaderDependencies>;
-}
-export interface ComponentLoaderStartOptions {
-    eagerComponents?: Iterable<string>;
-}
-/**
- * Discover declarative components and schedule each constructor exactly once.
- *
- * The loader is generic: it knows nothing hard-coded about any component package and works purely
- * from the manifest it is given. Importing this module has no side effects — discovery only starts
- * when {@link ComponentLoader.start} is called.
- */
-export declare class ComponentLoader {
-    /** @private */
-    __manifest: ComponentManifest;
-    /** @private */
-    __dependencies: LoaderDependencies;
-    /** @private */
-    __root: Document | Element;
-    /** @private */
-    __records: Map<string, ComponentRecord>;
-    /** @private */
-    __eagerComponents: Set<string>;
-    /** @private */
-    __elementSchedules: WeakMap<Element, Set<string>>;
-    /** @private */
-    __elementCleanups: WeakMap<Element, Set<() => void>>;
-    /** @private */
-    __mutationObserver?: MutationObserver;
-    /** @private */
-    __started: boolean;
-    constructor({ manifest, root, dependencies }: ComponentLoaderOptions);
-    start({ eagerComponents }?: ComponentLoaderStartOptions): void;
-    stop(): void;
-    /** @private */
-    __scan(root: Document | Element): void;
-    /** @private */
-    __discover(element: Element): void;
-    /** @private */
-    __getEntry(token: string): ComponentManifestEntry | undefined;
-    /** @private */
-    __getStrategy(element: Element, entry: ComponentManifestEntry): ComponentLoadStrategy;
-    /** @private */
-    __getRecord(token: string): ComponentRecord;
-    /** @private */
-    __schedule(token: string, strategy: ComponentLoadStrategy, element?: Element): void;
-    /** @private */
-    __begin(token: string, record: ComponentRecord): void;
-    /** @private */
-    __registerConfiguredChildren(parentToken: string, ParentConstructor: BaseConstructor, visited: Set<string>): Promise<void>;
-    /** @private */
-    __registerConfiguredChild(token: string, Constructor: BaseConstructor, record: ComponentRecord, visited: Set<string>): Promise<void>;
-    /** @private */
-    __addCleanup(record: ComponentRecord, cleanup: () => void, element?: Element): void;
-    /** @private */
-    __cleanSubtree(root: Element): void;
-    /** @private */
-    __clean(record: ComponentRecord): void;
-    /** @private */
-    __warn(message: string): void;
-    /** @private */
-    __reportError(token: string, stage: 'import' | 'registration', error: unknown): void;
-}
-export {};