@wabot-dev/framework 0.9.80 → 2.0.0-beta.0

package/dist/src/feature/ui-controller/bundler/navRuntime.js

@@ -0,0 +1,236 @@
+// Generic client runtime for "boosted" navigation between the views of an
+// `app: true` UI controller. Renderer-agnostic: the island hydrate/unmount
+// hooks are injected by the bundled nav entry (which imports them from the
+// renderer's runtime module, so they share the island registry singleton).
+//
+// Flow per in-scope <a> click / popstate:
+//   1. If the URL is cached -> apply it instantly (front-only navigation),
+//      then revalidate in the background unless still "fresh" (swr.maxAge).
+//   2. Otherwise fetch the fragment, apply it, and cache it.
+// Revalidation sends If-None-Match; a 304 means nothing changed (no re-render),
+// a 200 swaps only the changed fragment. Any failure falls back to a hard load,
+// so navigation is always a progressive enhancement over normal links.
+const NAV_HEADER = 'X-Wabot-Nav';
+const NOT_MODIFIED = Symbol('not-modified');
+const normalizePath = (pathname) => '/' + pathname.replace(/^\/+|\/+$/g, '');
+/** Compile an Express-style route pattern (":param" segments, "*") into a matcher. */
+function compileRoute(pattern) {
+    const source = normalizePath(pattern)
+        .split('/')
+        .map((seg) => {
+        if (seg.startsWith(':'))
+            return '[^/]+';
+        if (seg === '*')
+            return '.*';
+        return seg.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    })
+        .join('/');
+    return new RegExp('^' + source + '$');
+}
+/** True when the pathname matches any of the controller's route patterns. */
+function matchesRoute(pathname, patterns) {
+    const p = normalizePath(pathname);
+    return patterns.some((pattern) => compileRoute(pattern).test(p));
+}
+function startNavigation(hooks) {
+    if (typeof window === 'undefined' || typeof document === 'undefined')
+        return;
+    // Soft-navigate only the controller's declared view routes (matched as
+    // patterns so ":param" routes work), so an app mounted at "/" doesn't
+    // intercept links to the rest of the origin.
+    const routes = window.__wabotApp?.routes;
+    if (!routes || routes.length === 0)
+        return;
+    const matchers = routes.map(compileRoute);
+    const cache = new Map();
+    const keyOf = (url) => url.pathname + url.search;
+    const currentKey = () => location.pathname + location.search;
+    const inScope = (url) => url.origin === location.origin && matchers.some((m) => m.test(normalizePath(url.pathname)));
+    history.replaceState({ __wabot: true }, '', location.href);
+    document.addEventListener('click', onClick);
+    window.addEventListener('popstate', () => navigate(location.href, false));
+    // Public hooks for manual revalidation / optimistic updates from island code.
+    window.__wabotNav = {
+        revalidate(url) {
+            const key = url ? keyOf(new URL(url, location.href)) : currentKey();
+            const entry = cache.get(key);
+            if (entry)
+                revalidate(key, location.origin + key, entry);
+            else if (key === currentKey())
+                navigate(location.href, false);
+        },
+        mutate(url, fragment) {
+            const key = keyOf(new URL(url, location.href));
+            if (!fragment) {
+                cache.delete(key);
+                return;
+            }
+            const prev = cache.get(key);
+            const next = {
+                html: '',
+                ...prev,
+                ...fragment,
+                etag: prev?.etag ?? '',
+                ts: Date.now(),
+            };
+            cache.set(key, next);
+            if (key === currentKey())
+                apply(next);
+        },
+    };
+    function onClick(e) {
+        if (e.defaultPrevented || e.button !== 0 || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey)
+            return;
+        const anchor = e.target?.closest?.('a');
+        if (!anchor)
+            return;
+        if (anchor.target === '_blank' ||
+            anchor.hasAttribute('download') ||
+            anchor.getAttribute('rel') === 'external' ||
+            anchor.dataset.wabotReload != null)
+            return;
+        const href = anchor.getAttribute('href');
+        if (!href || href.startsWith('#'))
+            return;
+        const url = new URL(href, location.href);
+        if (!inScope(url))
+            return;
+        e.preventDefault();
+        if (keyOf(url) === currentKey())
+            return;
+        navigate(url.href, true);
+    }
+    async function navigate(href, push) {
+        const url = new URL(href, location.href);
+        // popstate can land on a URL outside the app (e.g. the entry page); hard-load it.
+        if (!inScope(url))
+            return hardNav(href);
+        const key = keyOf(url);
+        const cached = cache.get(key);
+        if (cached) {
+            apply(cached, { scroll: push });
+            if (push)
+                history.pushState({ __wabot: true }, '', href);
+            const fresh = (cached.maxAge ?? 0) > 0 && Date.now() - cached.ts < (cached.maxAge ?? 0) * 1000;
+            if (!fresh)
+                revalidate(key, href, cached);
+            return;
+        }
+        try {
+            const result = await fetchFragment(href, null);
+            if (result === NOT_MODIFIED || !result)
+                return hardNav(href);
+            cache.set(key, result);
+            apply(result, { scroll: push });
+            if (push)
+                history.pushState({ __wabot: true }, '', href);
+        }
+        catch {
+            hardNav(href);
+        }
+    }
+    async function revalidate(key, href, cached) {
+        try {
+            const result = await fetchFragment(href, cached.etag);
+            if (result === NOT_MODIFIED) {
+                cached.ts = Date.now();
+                return;
+            }
+            if (!result)
+                return;
+            cache.set(key, result);
+            if (currentKey() === key)
+                apply(result);
+        }
+        catch {
+            /* keep showing the stale entry on revalidation errors */
+        }
+    }
+    async function fetchFragment(href, etag) {
+        const headers = { [NAV_HEADER]: '1', Accept: 'application/json' };
+        if (etag)
+            headers['If-None-Match'] = etag;
+        const res = await fetch(href, { headers, credentials: 'same-origin' });
+        if (res.status === 304)
+            return NOT_MODIFIED;
+        if (!res.ok)
+            return null;
+        const ct = res.headers.get('Content-Type') ?? '';
+        if (!ct.includes('application/json'))
+            return null;
+        const data = (await res.json());
+        return { ...data, etag: res.headers.get('ETag') ?? '', ts: Date.now() };
+    }
+    async function apply(entry, opts = {}) {
+        ensureStyles(entry.styles ?? []);
+        // With a layout, only the outlet swaps so the shell (and its islands) keep
+        // their state; without one, the fragment is the whole body.
+        const target = document.querySelector('wabot-outlet') ?? document.body;
+        swapContent(target, entry.html);
+        hooks.unmountRemoved();
+        if (entry.title != null)
+            document.title = entry.title;
+        applyMeta(entry.meta ?? null);
+        await Promise.all((entry.scripts ?? []).map((src) => import(src).catch(() => { })));
+        hooks.hydrateAll();
+        if (opts.scroll)
+            window.scrollTo(0, 0);
+    }
+    // Replace the target's content, but preserve live island hosts (their mounted
+    // Preact tree) across the swap when their serialized props are unchanged.
+    // Changed props fall through to a fresh SSR host so revalidated data renders.
+    function swapContent(target, html) {
+        const live = new Map();
+        target.querySelectorAll('wabot-island[data-island]').forEach((el) => {
+            const id = el.getAttribute('data-island');
+            if (id && !live.has(id))
+                live.set(id, el);
+        });
+        target.innerHTML = html;
+        if (live.size === 0)
+            return;
+        target.querySelectorAll('wabot-island[data-island]').forEach((placeholder) => {
+            const id = placeholder.getAttribute('data-island');
+            if (!id)
+                return;
+            const kept = live.get(id);
+            if (!kept)
+                return;
+            if (kept.getAttribute('data-props') === placeholder.getAttribute('data-props')) {
+                placeholder.replaceWith(kept);
+            }
+            live.delete(id);
+        });
+    }
+    function ensureStyles(hrefs) {
+        for (const href of hrefs) {
+            if (document.querySelector(`link[rel="stylesheet"][href="${cssEscape(href)}"]`))
+                continue;
+            const link = document.createElement('link');
+            link.rel = 'stylesheet';
+            link.href = href;
+            document.head.appendChild(link);
+        }
+    }
+    function applyMeta(meta) {
+        if (!meta)
+            return;
+        for (const [name, content] of Object.entries(meta)) {
+            let tag = document.head.querySelector(`meta[name="${cssEscape(name)}"]`);
+            if (!tag) {
+                tag = document.createElement('meta');
+                tag.setAttribute('name', name);
+                document.head.appendChild(tag);
+            }
+            tag.setAttribute('content', content);
+        }
+    }
+    function hardNav(href) {
+        location.href = href;
+    }
+}
+function cssEscape(value) {
+    return value.replace(/["\\]/g, '\\$&');
+}
+
+export { compileRoute, matchesRoute, normalizePath, startNavigation };

package/dist/src/feature/ui-controller/bundler/pageAssets.js

@@ -0,0 +1,30 @@
+/** Map the islands a page rendered to the script/style tags it needs. */
+function pageAssetsFromManifest(manifest, islands, options = {}) {
+    const scripts = [];
+    const styles = [];
+    const seen = new Set();
+    for (const island of islands) {
+        if (seen.has(island.id))
+            continue;
+        seen.add(island.id);
+        const asset = manifest.islands[island.id];
+        if (!asset)
+            continue;
+        scripts.push(asset.js);
+        for (const css of asset.css)
+            if (!styles.includes(css))
+                styles.push(css);
+    }
+    return {
+        scripts,
+        styles,
+        navScript: manifest.nav,
+        bodyEndHtml: options.liveReloadPath ? liveReloadSnippet(options.liveReloadPath) : undefined,
+    };
+}
+function liveReloadSnippet(path) {
+    return (`<script>(function(){try{var s=new EventSource(${JSON.stringify(path)});` +
+        `s.onmessage=function(e){if(e.data==='reload')location.reload()};}catch(_){}})()</script>`);
+}
+
+export { liveReloadSnippet, pageAssetsFromManifest };

package/dist/src/feature/ui-controller/document/escape.js

@@ -0,0 +1,17 @@
+const HTML_ENTITIES = {
+    '&': '&',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#39;',
+};
+/** Escape text for safe interpolation into HTML element content. */
+function escapeHtml(value) {
+    return value.replace(/[&<>"']/g, (c) => HTML_ENTITIES[c]);
+}
+/** Escape a value for safe interpolation into a double-quoted HTML attribute. */
+function escapeAttr(value) {
+    return escapeHtml(value);
+}
+
+export { escapeAttr, escapeHtml };

package/dist/src/feature/ui-controller/document/helpers.js

@@ -0,0 +1,13 @@
+const REDIRECT_MARKER = Symbol.for('wabot.ui.redirect');
+/**
+ * Return this from a @view or @action to send an HTTP redirect instead of
+ * rendering. Used for the post/redirect/get pattern after form actions.
+ */
+function redirect(location, status = 302) {
+    return { [REDIRECT_MARKER]: true, location, status };
+}
+function isRedirect(value) {
+    return typeof value === 'object' && value != null && value[REDIRECT_MARKER] === true;
+}
+
+export { REDIRECT_MARKER, isRedirect, redirect };

package/dist/src/feature/ui-controller/document/renderDocument.js

@@ -0,0 +1,43 @@
+import { escapeHtml, escapeAttr } from './escape.js';
+
+/**
+ * Render the default HTML document shell around a view's body. Kept
+ * renderer-agnostic (plain string templating) so it works with any UiRenderer.
+ */
+function renderDocument(options) {
+    const { bodyHtml, title, meta = {}, styles = [], links = [], scripts = [], headHtml = '', bodyEndHtml = '', lang = 'en', } = options;
+    const titleTag = title ? `<title>${escapeHtml(title)}</title>` : '';
+    const metaTags = Object.entries(meta)
+        .map(([name, content]) => `<meta name="${escapeAttr(name)}" content="${escapeAttr(content)}">`)
+        .join('');
+    // Preload/preconnect first so the browser starts fetching those before CSS.
+    const linkTags = links.map((attrs) => `<link ${renderAttrs(attrs)}>`).join('');
+    const styleTags = styles
+        .map((href) => `<link rel="stylesheet" href="${escapeAttr(href)}">`)
+        .join('');
+    const scriptTags = scripts
+        .map((src) => `<script type="module" src="${escapeAttr(src)}"></script>`)
+        .join('');
+    return (`<!doctype html><html lang="${escapeAttr(lang)}"><head>` +
+        `<meta charset="utf-8">` +
+        `<meta name="viewport" content="width=device-width, initial-scale=1">` +
+        titleTag +
+        metaTags +
+        linkTags +
+        styleTags +
+        headHtml +
+        `</head><body>` +
+        bodyHtml +
+        scriptTags +
+        bodyEndHtml +
+        `</body></html>`);
+}
+/** Render an attribute map: string => key="value", `true` => bare key, false/null skipped. */
+function renderAttrs(attrs) {
+    return Object.entries(attrs)
+        .filter(([, value]) => value !== false && value != null)
+        .map(([key, value]) => value === true ? escapeAttr(key) : `${escapeAttr(key)}="${escapeAttr(String(value))}"`)
+        .join(' ');
+}
+
+export { renderDocument };

package/dist/src/feature/ui-controller/island/IslandRegistry.js

@@ -0,0 +1,68 @@
+import { __decorate } from 'tslib';
+import { createHash } from 'node:crypto';
+import path__default from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { singleton } from '../../../core/injection/index.js';
+import { Logger } from '../../../core/logger/Logger.js';
+import { isIsland, setIslandId } from './island.js';
+
+/** Files matching this are treated as islands (default export wrapped with island()). */
+const ISLAND_FILE_PATTERN = /\.island\.(tsx|jsx)$/;
+/** Deterministic, readable, collision-resistant id from a project-relative path. */
+function toIslandId(relPath) {
+    const base = path__default
+        .basename(relPath)
+        .replace(ISLAND_FILE_PATTERN, '')
+        .replace(/[^a-zA-Z0-9_-]/g, '_') || 'island';
+    const hash = createHash('sha1').update(relPath).digest('hex').slice(0, 8);
+    return `${base}-${hash}`;
+}
+function isIslandFile(file) {
+    return ISLAND_FILE_PATTERN.test(file);
+}
+/**
+ * Discovers `*.island.tsx` modules, assigns each a stable id, and stamps that
+ * id onto the imported island component (ESM module singletons mean the view
+ * renders the same instance, so the renderer can read the id during SSR).
+ */
+let IslandRegistry = class IslandRegistry {
+    islands = new Map();
+    logger = new Logger('wabot:ui:islands');
+    async discover(files, cwd = process.cwd()) {
+        for (const absPath of files.filter(isIslandFile)) {
+            const relPath = path__default.relative(cwd, absPath).split(path__default.sep).join('/');
+            const id = toIslandId(relPath);
+            try {
+                const mod = await import(pathToFileURL(absPath).href);
+                const component = mod.default;
+                if (!isIsland(component)) {
+                    this.logger.warn(`${relPath}: default export is not an island(); skipping`);
+                    continue;
+                }
+                setIslandId(component, id);
+                this.islands.set(id, { id, importPath: absPath, relPath });
+            }
+            catch (err) {
+                this.logger.error(`Failed to load island ${relPath}`, err);
+            }
+        }
+        return this.list();
+    }
+    register(island) {
+        this.islands.set(island.id, island);
+    }
+    list() {
+        return [...this.islands.values()];
+    }
+    get(id) {
+        return this.islands.get(id);
+    }
+    get size() {
+        return this.islands.size;
+    }
+};
+IslandRegistry = __decorate([
+    singleton()
+], IslandRegistry);
+
+export { ISLAND_FILE_PATTERN, IslandRegistry, isIslandFile, toIslandId };

package/dist/src/feature/ui-controller/island/island.js

@@ -0,0 +1,40 @@
+/**
+ * Marker attached to components wrapped with {@link island}. The UI renderer
+ * uses it to decide which components must hydrate on the client; the bundler
+ * uses {@link IslandMeta.id} (assigned from the `*.island.tsx` file location) to
+ * emit a per-island client bundle.
+ */
+const ISLAND_MARKER = Symbol.for('wabot.ui.island');
+/**
+ * Mark a component as an interactive client "island". The component still
+ * renders on the server, but only islands ship JavaScript and hydrate in the
+ * browser. Islands must be the export of a `*.island.tsx` file so the bundler
+ * can give them a stable id.
+ *
+ *   // Counter.island.tsx
+ *   function Counter() { ... }
+ *   export default island(Counter)
+ */
+function island(component, name) {
+    const resolvedName = name ?? component.name ?? 'Island';
+    const wrapped = ((props) => component(props));
+    wrapped[ISLAND_MARKER] = { component, name: resolvedName, id: undefined };
+    wrapped.displayName = resolvedName;
+    return wrapped;
+}
+function getIslandMeta(component) {
+    return typeof component === 'function'
+        ? component[ISLAND_MARKER]
+        : undefined;
+}
+function isIsland(component) {
+    return getIslandMeta(component) != null;
+}
+/** Assign the stable bundle id to an island, done during island discovery. */
+function setIslandId(component, id) {
+    const meta = getIslandMeta(component);
+    if (meta)
+        meta.id = id;
+}
+
+export { ISLAND_MARKER, getIslandMeta, isIsland, island, setIslandId };

package/dist/src/feature/ui-controller/island/serialize.js

@@ -0,0 +1,35 @@
+const SKIP_PROPS = new Set(['children', 'ref', 'key']);
+/**
+ * Serialize the props an island was rendered with so the client can hydrate it
+ * with the same data. Drops `children`/`ref`/`key` and any function-valued
+ * props (event handlers belong inside the island, not in its serialized props).
+ */
+function serializeProps(props) {
+    const out = {};
+    for (const key in props) {
+        if (SKIP_PROPS.has(key))
+            continue;
+        const value = props[key];
+        if (typeof value === 'function')
+            continue;
+        out[key] = value;
+    }
+    try {
+        return JSON.stringify(out);
+    }
+    catch {
+        return '{}';
+    }
+}
+function deserializeProps(raw) {
+    if (!raw)
+        return {};
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+
+export { deserializeProps, serializeProps };

package/dist/src/feature/ui-controller/metadata/@action.js

@@ -0,0 +1,18 @@
+import { container } from '../../../core/injection/index.js';
+import { UiControllerMetadataStore } from './UiControllerMetadataStore.js';
+
+function action(config) {
+    return function (target, propertyKey) {
+        const functionName = propertyKey.toString();
+        const paramsTypes = Reflect.getMetadata('design:paramtypes', target, functionName);
+        const store = container.resolve(UiControllerMetadataStore);
+        store.saveActionMetadata({
+            controllerConstructor: target.constructor,
+            functionName,
+            config: typeof config === 'string' ? { path: config } : config,
+            paramsTypes,
+        });
+    };
+}
+
+export { action };

package/dist/src/feature/ui-controller/metadata/@uiController.js

@@ -0,0 +1,19 @@
+import { container, injectable } from '../../../core/injection/index.js';
+import { UiControllerMetadataStore } from './UiControllerMetadataStore.js';
+
+function uiController(config) {
+    return function (target) {
+        const store = container.resolve(UiControllerMetadataStore);
+        store.saveControllerMetadata({
+            controllerConstructor: target,
+            path: typeof config === 'string' ? config : config.path,
+            middlewares: typeof config === 'string' ? [] : (config.middlewares ?? []),
+            app: typeof config === 'string' ? false : (config.app ?? false),
+            layout: typeof config === 'string' ? undefined : config.layout,
+            head: typeof config === 'string' ? undefined : config.head,
+        });
+        injectable()(target);
+    };
+}
+
+export { uiController };

package/dist/src/feature/ui-controller/metadata/@uiMiddleware.js

@@ -0,0 +1,20 @@
+import { container } from '../../../core/injection/index.js';
+import { UiControllerMetadataStore } from './UiControllerMetadataStore.js';
+
+/**
+ * Attach a middleware (e.g. an auth guard) to a single @view or @action.
+ * Controller-wide middlewares can instead be declared on @uiController({ middlewares }).
+ */
+function uiMiddleware(middlewareConstructor) {
+    return function (target, propertyKey) {
+        const functionName = propertyKey.toString();
+        const store = container.resolve(UiControllerMetadataStore);
+        store.saveMiddlewareMetadata({
+            controllerConstructor: target.constructor,
+            functionName,
+            middlewareConstructor,
+        });
+    };
+}
+
+export { uiMiddleware };

package/dist/src/feature/ui-controller/metadata/@view.js

@@ -0,0 +1,18 @@
+import { container } from '../../../core/injection/index.js';
+import { UiControllerMetadataStore } from './UiControllerMetadataStore.js';
+
+function view(config) {
+    return function (target, propertyKey) {
+        const functionName = propertyKey.toString();
+        const paramsTypes = Reflect.getMetadata('design:paramtypes', target, functionName);
+        const store = container.resolve(UiControllerMetadataStore);
+        store.saveViewMetadata({
+            controllerConstructor: target.constructor,
+            functionName,
+            config: typeof config === 'string' ? { path: config } : config,
+            paramsTypes,
+        });
+    };
+}
+
+export { view };

package/dist/src/feature/ui-controller/metadata/UiControllerMetadataStore.js

@@ -0,0 +1,107 @@
+import { __decorate } from 'tslib';
+import { singleton } from '../../../core/injection/index.js';
+
+function getClassHierarchy(cls) {
+    const classes = [];
+    let proto = Object.getPrototypeOf(cls.prototype);
+    while (proto && proto.constructor !== Object) {
+        classes.push(proto.constructor);
+        proto = Object.getPrototypeOf(proto);
+    }
+    return classes;
+}
+let UiControllerMetadataStore = class UiControllerMetadataStore {
+    controllers = new Map();
+    views = new Map();
+    actions = new Map();
+    middlewares = new Map();
+    saveControllerMetadata(metadata) {
+        this.controllers.set(metadata.controllerConstructor, metadata);
+    }
+    saveViewMetadata(metadata) {
+        let controllerViews = this.views.get(metadata.controllerConstructor);
+        if (!controllerViews) {
+            this.views.set(metadata.controllerConstructor, (controllerViews = new Map()));
+        }
+        controllerViews.set(metadata.functionName, metadata);
+    }
+    saveActionMetadata(metadata) {
+        let controllerActions = this.actions.get(metadata.controllerConstructor);
+        if (!controllerActions) {
+            this.actions.set(metadata.controllerConstructor, (controllerActions = new Map()));
+        }
+        controllerActions.set(metadata.functionName, metadata);
+    }
+    saveMiddlewareMetadata(metadata) {
+        let controllerMiddlewares = this.middlewares.get(metadata.controllerConstructor);
+        if (!controllerMiddlewares) {
+            this.middlewares.set(metadata.controllerConstructor, (controllerMiddlewares = new Map()));
+        }
+        let methodMiddlewares = controllerMiddlewares.get(metadata.functionName);
+        if (!methodMiddlewares) {
+            controllerMiddlewares.set(metadata.functionName, (methodMiddlewares = []));
+        }
+        methodMiddlewares.unshift(metadata);
+    }
+    getAllUiControllerConstructors() {
+        return Array.from(this.controllers.keys());
+    }
+    getController(controllerConstructor) {
+        const controller = this.controllers.get(controllerConstructor);
+        if (!controller) {
+            throw new Error(`${controllerConstructor.name} should be decorated with @uiController`);
+        }
+        return controller;
+    }
+    collectMethodMiddlewares(hierarchy, functionName) {
+        const middlewares = [];
+        for (const cls of [...hierarchy].reverse()) {
+            const classMiddlewares = this.middlewares.get(cls)?.get(functionName);
+            if (classMiddlewares) {
+                middlewares.push(...classMiddlewares);
+            }
+        }
+        return middlewares;
+    }
+    getControllerViewsInfo(controllerConstructor) {
+        const controller = this.getController(controllerConstructor);
+        const hierarchy = [controllerConstructor, ...getClassHierarchy(controllerConstructor)];
+        const viewsMap = new Map();
+        for (const cls of [...hierarchy].reverse()) {
+            const classViews = this.views.get(cls);
+            if (classViews) {
+                for (const [name, view] of classViews)
+                    viewsMap.set(name, view);
+            }
+        }
+        return [...viewsMap.values()].map((view) => ({
+            ...view,
+            controllerConstructor,
+            controller,
+            middlewares: this.collectMethodMiddlewares(hierarchy, view.functionName),
+        }));
+    }
+    getControllerActionsInfo(controllerConstructor) {
+        const controller = this.getController(controllerConstructor);
+        const hierarchy = [controllerConstructor, ...getClassHierarchy(controllerConstructor)];
+        const actionsMap = new Map();
+        for (const cls of [...hierarchy].reverse()) {
+            const classActions = this.actions.get(cls);
+            if (classActions) {
+                for (const [name, action] of classActions)
+                    actionsMap.set(name, action);
+            }
+        }
+        return [...actionsMap.values()].map((action) => ({
+            ...action,
+            controllerConstructor,
+            controller,
+            middlewares: this.collectMethodMiddlewares(hierarchy, action.functionName),
+        }));
+    }
+};
+UiControllerMetadataStore = __decorate([
+    singleton()
+], UiControllerMetadataStore);
+
+export { UiControllerMetadataStore };