@veap/plugins 0.0.0-stage → 0.1.0

package/dist/router/router.service.js

@@ -0,0 +1,127 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { CACHE_PROVIDER, CONFIG_SERVICE, Inject, Injectable, } from "@veap/kernel";
+import { NavigationService } from "../navigation/navigation.service";
+import { PluginRegistry } from "../registry";
+import { RouteTree, resolveMagicPrefix } from "./route-tree";
+let RouterService = class RouterService {
+    cache;
+    config;
+    pluginRegistry;
+    navigation;
+    rewrites = new Map();
+    siteLayout;
+    constructor(cache, config, pluginRegistry, navigation) {
+        this.cache = cache;
+        this.config = config;
+        this.pluginRegistry = pluginRegistry;
+        this.navigation = navigation;
+    }
+    setSiteLayout(layout) {
+        this.siteLayout = layout;
+    }
+    getSiteLayout() {
+        return this.siteLayout;
+    }
+    addRewrite(from, to) {
+        this.rewrites.set(from, to);
+    }
+    getRewrites() {
+        return new Map(this.rewrites);
+    }
+    async clearCache() {
+        await this.cache.delete("router:tree");
+    }
+    async getPluginsWithHomepage() {
+        await this.pluginRegistry.init();
+        const plugins = this.pluginRegistry.getEnabledPlugins();
+        const result = [];
+        for (const plugin of plugins) {
+            let hasHomepage = false;
+            if (plugin.routeTree) {
+                const pluginTree = typeof plugin.routeTree === "function"
+                    ? await plugin.routeTree()
+                    : plugin.routeTree;
+                const tempTree = new RouteTree();
+                if (pluginTree instanceof RouteTree) {
+                    tempTree.addTree(pluginTree.getRoot());
+                }
+                else {
+                    tempTree.addTree(pluginTree);
+                }
+                const match = tempTree.match("/");
+                if (match?.isExact) {
+                    hasHomepage = true;
+                }
+            }
+            if (hasHomepage) {
+                result.push({ id: plugin.manifest.id, name: plugin.manifest.name });
+            }
+        }
+        return result;
+    }
+    async _buildRouteTree(_options) {
+        const tree = new RouteTree();
+        tree.setRewrites(this.rewrites);
+        await this.pluginRegistry.init();
+        const plugins = this.pluginRegistry.getEnabledPlugins();
+        const prefix = await this.navigation.getPathPrefix();
+        for (const plugin of plugins) {
+            if (plugin.routeTree) {
+                let pluginTree = typeof plugin.routeTree === "function"
+                    ? await plugin.routeTree()
+                    : plugin.routeTree;
+                if (pluginTree instanceof RouteTree)
+                    pluginTree = pluginTree.getRoot();
+                const resolvedTreeRoot = resolveMagicPrefix(pluginTree, prefix);
+                tree.addTree(resolvedTreeRoot);
+            }
+        }
+        // Attach siteLayout only to the "(site)" route group node
+        if (this.siteLayout) {
+            const rootNode = tree.getRoot();
+            if (!rootNode.children)
+                rootNode.children = [];
+            let siteGroup = rootNode.children.find((c) => c.segment === "(site)");
+            if (!siteGroup) {
+                siteGroup = { segment: "(site)", children: [] };
+                rootNode.children.push(siteGroup);
+            }
+            siteGroup.layout = this.siteLayout;
+        }
+        return tree;
+    }
+    async buildRouteTree(includePrivate = false) {
+        const isProd = this.config.get("NODE_ENV") === "production";
+        if (isProd) {
+            const cached = await this.cache.get("router:tree");
+            if (cached)
+                return cached;
+        }
+        const tree = await this._buildRouteTree({ includePrivate });
+        if (isProd) {
+            await this.cache.set("router:tree", tree);
+        }
+        return tree;
+    }
+};
+RouterService = __decorate([
+    Injectable(),
+    __param(0, Inject(CACHE_PROVIDER)),
+    __param(1, Inject(CONFIG_SERVICE)),
+    __param(2, Inject(PluginRegistry)),
+    __param(3, Inject(NavigationService)),
+    __metadata("design:paramtypes", [Object, Object, PluginRegistry,
+        NavigationService])
+], RouterService);
+export { RouterService };

package/dist/router/scanner.d.ts

@@ -0,0 +1,4 @@
+import type { RouteNode } from "./route-tree";
+export declare function discoverRoutes(appDir: string, dynamicImport?: (relPath: string) => Promise<any>): Promise<RouteNode>;
+export declare function globToTree(globResult: Record<string, () => Promise<any>>, baseDir?: string): Promise<RouteNode>;
+export declare function generateRouteManifest(appDir: string, importPrefix: string): string;

package/dist/router/scanner.js

@@ -0,0 +1,337 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { logger } from "@veap/kernel";
+const debug = (msg, ...args) => logger.debug("veap:scanner", msg, ...args);
+// ---------------------------------------------------------------------------
+// File conventions
+// ---------------------------------------------------------------------------
+const ROUTE_FILES = {
+    page: ["page.tsx", "page.ts", "page.jsx", "page.js"],
+    layout: ["layout.tsx", "layout.ts", "layout.jsx", "layout.js"],
+    loading: ["loading.tsx", "loading.ts", "loading.jsx", "loading.js"],
+    error: ["error.tsx", "error.ts", "error.jsx", "error.js"],
+    notFound: ["not-found.tsx", "not-found.ts", "not-found.jsx", "not-found.js"],
+    default: ["default.tsx", "default.ts", "default.jsx", "default.js"],
+    route: ["route.ts", "route.js"],
+};
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+const IGNORED_DIRS = new Set(["node_modules"]);
+function shouldSkipDir(name) {
+    if (IGNORED_DIRS.has(name))
+        return true;
+    if (name.startsWith("."))
+        return true;
+    if (name.startsWith("_"))
+        return true;
+    return false;
+}
+function dirNameToSegment(dirName) {
+    return dirName;
+}
+function segmentSortOrder(segment) {
+    if (/^\[\[\.\.\./.test(segment))
+        return 4;
+    if (/^\[\.\.\./.test(segment))
+        return 3;
+    if (/^\[[^[\\].]+\]$/.test(segment))
+        return 2;
+    if (segment.startsWith("("))
+        return 1;
+    return 0;
+}
+function findRouteFile(dir, candidates) {
+    for (const candidate of candidates) {
+        const fullPath = path.join(dir, candidate);
+        if (fs.existsSync(fullPath))
+            return fullPath;
+    }
+    return null;
+}
+function sanitizeImportName(dirName) {
+    const optCatchAll = dirName.match(/^\[\[\.\.\.(\w+)\]\]$/);
+    if (optCatchAll)
+        return `_optspread_${optCatchAll[1]}_`;
+    const catchAll = dirName.match(/^\[\.\.\.(\w+)\]$/);
+    if (catchAll)
+        return `_spread_${catchAll[1]}_`;
+    const dynamic = dirName.match(/^\[(\w+)\]$/);
+    if (dynamic)
+        return `_${dynamic[1]}_`;
+    if (dirName.startsWith("(") && dirName.endsWith(")")) {
+        return dirName.slice(1, -1);
+    }
+    if (dirName.startsWith("@")) {
+        return `_at_${dirName.slice(1)}`;
+    }
+    return dirName.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+// ---------------------------------------------------------------------------
+// Runtime route discovery
+// ---------------------------------------------------------------------------
+export async function discoverRoutes(appDir, dynamicImport) {
+    return scanDirectory(appDir, "", appDir, dynamicImport);
+}
+async function scanDirectory(dir, segment, baseAppDir, dynamicImport) {
+    const relPathToDir = path.relative(baseAppDir, dir).split(path.sep).join("/");
+    const nodeId = relPathToDir === "" ? "/" : `/${relPathToDir}`;
+    const node = { segment, id: nodeId };
+    for (const [key, candidates] of Object.entries(ROUTE_FILES)) {
+        const filePath = findRouteFile(dir, candidates);
+        if (filePath) {
+            let mod;
+            if (dynamicImport) {
+                const relPath = path
+                    .relative(baseAppDir, filePath)
+                    .split(path.sep)
+                    .join("/");
+                mod = await dynamicImport(relPath);
+            }
+            else {
+                const isDev = process.env.NODE_ENV === "development";
+                const importPath = isDev ? `${filePath}?v=${Date.now}` : filePath;
+                mod = await import(/* turbopackIgnore: true */ importPath);
+            }
+            const exported = mod.default ?? mod;
+            switch (key) {
+                case "page":
+                    node.page = exported;
+                    break;
+                case "layout":
+                    node.layout = exported;
+                    break;
+                case "loading":
+                    node.loading = exported;
+                    break;
+                case "error":
+                    node.error = exported;
+                    break;
+                case "notFound":
+                    node.notFound = exported;
+                    break;
+                case "default":
+                    node.default = exported;
+                    break;
+                case "route":
+                    node.route = exported;
+                    break;
+            }
+            if ((key === "page" || key === "layout") && mod.generateMetadata) {
+                node.generateMetadata = mod.generateMetadata;
+            }
+            if (key === "page" || key === "layout" || key === "route") {
+                if (mod.auth !== undefined)
+                    node.auth = mod.auth;
+                if (mod.roles !== undefined)
+                    node.roles = mod.roles;
+                if (mod.permissions !== undefined)
+                    node.permissions = mod.permissions;
+                if (mod.middlewares !== undefined)
+                    node.middlewares = mod.middlewares;
+            }
+        }
+    }
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return node;
+    }
+    const childDirs = entries.filter((e) => e.isDirectory() && !shouldSkipDir(e.name));
+    const children = [];
+    const parallelRoutes = {};
+    for (const childDir of childDirs) {
+        const childPath = path.join(dir, childDir.name);
+        if (childDir.name.startsWith("@")) {
+            const slotName = childDir.name.slice(1);
+            parallelRoutes[slotName] = await scanDirectory(childPath, slotName, baseAppDir, dynamicImport);
+        }
+        else {
+            const childSegment = dirNameToSegment(childDir.name);
+            children.push(await scanDirectory(childPath, childSegment, baseAppDir, dynamicImport));
+        }
+    }
+    children.sort((a, b) => {
+        const orderA = segmentSortOrder(a.segment);
+        const orderB = segmentSortOrder(b.segment);
+        if (orderA !== orderB)
+            return orderA - orderB;
+        return a.segment.localeCompare(b.segment);
+    });
+    if (children.length > 0) {
+        node.children = children;
+    }
+    if (Object.keys(parallelRoutes).length > 0) {
+        node.parallelRoutes = parallelRoutes;
+    }
+    return node;
+}
+// ---------------------------------------------------------------------------
+// import.meta.glob support (Next.js 16.3 Turbopack)
+// ---------------------------------------------------------------------------
+export async function globToTree(globResult, baseDir = "./app") {
+    const root = { segment: "" };
+    debug("veap:Router", `Starting with baseDir: ${baseDir}`);
+    for (const [filePath, loader] of Object.entries(globResult)) {
+        const match = filePath.match(/(?:^|\/)app\/(.+)$/);
+        if (!match) {
+            debug("veap:Router", `Skipping ${filePath} (does not contain /app/)`);
+            continue;
+        }
+        const relativePath = match[1];
+        const parts = relativePath.split("/");
+        const fileName = parts.pop() || "";
+        const segments = parts;
+        let current = root;
+        for (const segment of segments) {
+            if (segment.startsWith("@")) {
+                const slotName = segment.slice(1);
+                if (!current.parallelRoutes)
+                    current.parallelRoutes = {};
+                if (!current.parallelRoutes[slotName]) {
+                    current.parallelRoutes[slotName] = { segment: slotName };
+                }
+                current = current.parallelRoutes[slotName];
+            }
+            else {
+                if (!current.children)
+                    current.children = [];
+                let child = current.children.find((c) => c.segment === segment);
+                if (!child) {
+                    child = { segment };
+                    current.children.push(child);
+                }
+                current = child;
+            }
+        }
+        const fileBase = fileName.replace(/\.[^/.]+$/, "");
+        let key;
+        if (fileBase === "page")
+            key = "page";
+        else if (fileBase === "layout")
+            key = "layout";
+        else if (fileBase === "loading")
+            key = "loading";
+        else if (fileBase === "error")
+            key = "error";
+        else if (fileBase === "not-found")
+            key = "notFound";
+        else if (fileBase === "default")
+            key = "default";
+        else if (fileBase === "route")
+            key = "route";
+        if (key) {
+            const mod = await loader();
+            const exported = mod.default ?? mod;
+            current[key] = exported;
+            if ((key === "page" || key === "layout") && mod.generateMetadata) {
+                current.generateMetadata = mod.generateMetadata;
+            }
+            if (key === "page" || key === "layout" || key === "route") {
+                if (mod.auth !== undefined)
+                    current.auth = mod.auth;
+                if (mod.roles !== undefined)
+                    current.roles = mod.roles;
+                if (mod.permissions !== undefined)
+                    current.permissions = mod.permissions;
+                if (mod.middlewares !== undefined)
+                    current.middlewares = mod.middlewares;
+            }
+        }
+    }
+    function sortTree(node) {
+        if (node.children) {
+            node.children.sort((a, b) => {
+                const orderA = segmentSortOrder(a.segment);
+                const orderB = segmentSortOrder(b.segment);
+                if (orderA !== orderB)
+                    return orderA - orderB;
+                return a.segment.localeCompare(b.segment);
+            });
+            for (const child of node.children)
+                sortTree(child);
+        }
+        if (node.parallelRoutes) {
+            for (const child of Object.values(node.parallelRoutes))
+                sortTree(child);
+        }
+    }
+    sortTree(root);
+    return root;
+}
+export function generateRouteManifest(appDir, importPrefix) {
+    const imports = [];
+    const tree = scanDirectoryForManifest(appDir, "", importPrefix, imports, []);
+    const lines = [];
+    for (const entry of imports) {
+        lines.push(`import ${entry.name} from "${entry.path}";`);
+    }
+    if (imports.length > 0) {
+        lines.push("");
+    }
+    lines.push(`import type { RouteNode } from "@veap/plugins/router";`);
+    lines.push("");
+    lines.push(`export const routeTree: RouteNode = ${tree};`);
+    lines.push("");
+    return lines.join("\n");
+}
+function scanDirectoryForManifest(dir, segment, importPrefix, imports, pathParts) {
+    const props = [];
+    props.push(`segment: ${JSON.stringify(segment)}`);
+    const nameSuffix = pathParts.length === 0
+        ? "root"
+        : pathParts.map(sanitizeImportName).join("_");
+    for (const [key, candidates] of Object.entries(ROUTE_FILES)) {
+        const filePath = findRouteFile(dir, candidates);
+        if (filePath) {
+            const fileExt = path.extname(filePath);
+            const fileBase = path.basename(filePath, fileExt);
+            const relativeParts = [...pathParts, fileBase];
+            const importPath = [importPrefix, ...relativeParts].join("/");
+            const capitalizedKey = key.charAt(0).toUpperCase() + key.slice(1);
+            const importName = `${capitalizedKey}_${nameSuffix}`;
+            imports.push({ name: importName, path: importPath });
+            props.push(`${key}: ${importName}`);
+        }
+    }
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return `{ ${props.join(", ")} }`;
+    }
+    const childDirs = entries
+        .filter((e) => e.isDirectory() && !shouldSkipDir(e.name))
+        .sort((a, b) => {
+        const orderA = segmentSortOrder(dirNameToSegment(a.name));
+        const orderB = segmentSortOrder(dirNameToSegment(b.name));
+        if (orderA !== orderB)
+            return orderA - orderB;
+        return a.name.localeCompare(b.name);
+    });
+    const childLiterals = [];
+    const parallelLiterals = [];
+    for (const childDir of childDirs) {
+        const childPath = path.join(dir, childDir.name);
+        if (childDir.name.startsWith("@")) {
+            const slotName = childDir.name.slice(1);
+            const slotLiteral = scanDirectoryForManifest(childPath, slotName, importPrefix, imports, [...pathParts, childDir.name]);
+            parallelLiterals.push(`${JSON.stringify(slotName)}: ${slotLiteral}`);
+        }
+        else {
+            const childSegment = dirNameToSegment(childDir.name);
+            const childLiteral = scanDirectoryForManifest(childPath, childSegment, importPrefix, imports, [...pathParts, childDir.name]);
+            childLiterals.push(childLiteral);
+        }
+    }
+    if (childLiterals.length > 0) {
+        props.push(`children: [\n    ${childLiterals.join(",\n    ")},\n  ]`);
+    }
+    if (parallelLiterals.length > 0) {
+        props.push(`parallelRoutes: {\n    ${parallelLiterals.join(",\n    ")},\n  }`);
+    }
+    return `{\n  ${props.join(",\n  ")},\n}`;
+}

package/dist/router/utils.d.ts

@@ -0,0 +1,10 @@
+import type { UserPermission, UserRole } from "@veap/auth";
+import type { ApiMiddleware, VeapMiddleware } from "../common/types";
+import type { LayoutChainEntry, MatchResult } from "./route-tree";
+export declare function collectMiddlewares(chain: LayoutChainEntry[], node: MatchResult["node"]): VeapMiddleware[];
+export declare function collectApiMiddlewares(chain: LayoutChainEntry[], node: MatchResult["node"]): ApiMiddleware[];
+export declare function collectAuthRequirements(chain: LayoutChainEntry[], node: MatchResult["node"]): {
+    needsAuth: boolean;
+    roles: UserRole[];
+    permissions: UserPermission[];
+};

package/dist/router/utils.js

@@ -0,0 +1,48 @@
+export function collectMiddlewares(chain, node) {
+    const all = [];
+    for (const entry of chain) {
+        if (entry.middlewares) {
+            all.push(...entry.middlewares);
+        }
+    }
+    if (node.middlewares) {
+        all.push(...node.middlewares);
+    }
+    return all;
+}
+export function collectApiMiddlewares(chain, node) {
+    const all = [];
+    for (const entry of chain) {
+        if (entry.middlewares) {
+            all.push(...entry.middlewares);
+        }
+    }
+    if (node.middlewares) {
+        all.push(...node.middlewares);
+    }
+    return all;
+}
+export function collectAuthRequirements(chain, node) {
+    let needsAuth = false;
+    const roles = [];
+    const permissions = [];
+    for (const entry of chain) {
+        if (entry.auth)
+            needsAuth = true;
+        if (entry.roles)
+            roles.push(...entry.roles);
+        if (entry.permissions)
+            permissions.push(...entry.permissions);
+    }
+    if (node.auth)
+        needsAuth = true;
+    if (node.roles)
+        roles.push(...node.roles);
+    if (node.permissions)
+        permissions.push(...node.permissions);
+    return {
+        needsAuth: needsAuth || roles.length > 0 || permissions.length > 0,
+        roles: [...new Set(roles)],
+        permissions: [...new Set(permissions)],
+    };
+}

package/dist/router.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @module @veap/plugins/router
+ * @description Virtual Router API integrated within the Veap Plugin system.
+ */
+export * from "./router";
+export * from "./router/index";

package/dist/router.js

@@ -0,0 +1,6 @@
+/**
+ * @module @veap/plugins/router
+ * @description Virtual Router API integrated within the Veap Plugin system.
+ */
+export * from "./router";
+export * from "./router/index";

package/dist/server.d.ts

@@ -0,0 +1,11 @@
+export * from "./actions";
+export { PluginManifestSchema as ModuleManifestSchema } from "./common/types";
+export * from "./index";
+export * from "./navigation";
+export { getPathPrefix, getPluginBreadcrumbs as getBreadcrumbs, getPluginNavigation as getPublicNavigation, getVeapPluginNavigationGrouped as getVeapModuleNavigationGrouped, } from "./navigation";
+export * from "./registry";
+export { applyPluginFilters as applyFilters, getPluginConfig as getModuleConfig, getPluginStatus as getModule, getPluginStatus as getModuleStatus, getPluginsStatus as getModules, hasPluginExtension as hasExtension, hasPluginHooks as hasHooks, togglePluginState as toggleModuleState, updatePluginConfig as updateModuleConfig, } from "./registry";
+export * from "./router";
+export { ExtensionPoint, PluginExtensionPoint, } from "./widgets/plugin-extension-point";
+export { PluginWidgetArea, WidgetArea, } from "./widgets/plugin-widget-area";
+export { WidgetComposer } from "./widgets/widget-composer";

package/dist/server.js

@@ -0,0 +1,17 @@
+// Server Navigation & Breadcrumbs
+// Server Actions
+export * from "./actions";
+export { PluginManifestSchema as ModuleManifestSchema } from "./common/types";
+export * from "./index";
+export * from "./navigation";
+export { getPathPrefix, getPluginBreadcrumbs as getBreadcrumbs, getPluginNavigation as getPublicNavigation, getVeapPluginNavigationGrouped as getVeapModuleNavigationGrouped, } from "./navigation";
+// Core: Registry
+export * from "./registry";
+// Core: Compatibility Aliases
+export { applyPluginFilters as applyFilters, getPluginConfig as getModuleConfig, getPluginStatus as getModule, getPluginStatus as getModuleStatus, getPluginsStatus as getModules, hasPluginExtension as hasExtension, hasPluginHooks as hasHooks, togglePluginState as toggleModuleState, updatePluginConfig as updateModuleConfig, } from "./registry";
+// Router Server
+export * from "./router";
+// UI (Server versions)
+export { ExtensionPoint, PluginExtensionPoint, } from "./widgets/plugin-extension-point";
+export { PluginWidgetArea, WidgetArea, } from "./widgets/plugin-widget-area";
+export { WidgetComposer } from "./widgets/widget-composer";

package/dist/widgets/index.d.ts

@@ -0,0 +1,8 @@
+export { PathPrefixContext, usePathPrefix, } from "./path-prefix-context";
+export { ExtensionPoint, PluginExtensionPoint, type PluginExtensionPointProps, } from "./plugin-extension-point";
+export { ExtensionPointClient, PluginExtensionPointClient, type PluginExtensionPointClientProps, usePluginExtensions, } from "./plugin-extension-point-client";
+export { PluginWidgetArea, WidgetArea, } from "./plugin-widget-area";
+export { PluginWidgetAreaClient, usePluginWidgets, WidgetAreaClient, } from "./plugin-widget-area-client";
+export { type ConfirmOptions, type ConfirmResult, useConfirmAction, } from "./use-confirm-action";
+export { WidgetComposer } from "./widget-composer";
+export { WidgetComposerClient } from "./widget-composer-client";

package/dist/widgets/index.js

@@ -0,0 +1,8 @@
+export { PathPrefixContext, usePathPrefix, } from "./path-prefix-context";
+export { ExtensionPoint, PluginExtensionPoint, } from "./plugin-extension-point";
+export { ExtensionPointClient, PluginExtensionPointClient, usePluginExtensions, } from "./plugin-extension-point-client";
+export { PluginWidgetArea, WidgetArea, } from "./plugin-widget-area";
+export { PluginWidgetAreaClient, usePluginWidgets, WidgetAreaClient, } from "./plugin-widget-area-client";
+export { useConfirmAction, } from "./use-confirm-action";
+export { WidgetComposer } from "./widget-composer";
+export { WidgetComposerClient } from "./widget-composer-client";

package/dist/widgets/path-prefix-context.d.ts

@@ -0,0 +1,5 @@
+export declare const PathPrefixContext: import("react").Context<string>;
+/**
+ * Hook to get the current Veap path prefix on the client.
+ */
+export declare function usePathPrefix(): string;

package/dist/widgets/path-prefix-context.js

@@ -0,0 +1,9 @@
+"use client";
+import { createContext, useContext } from "react";
+export const PathPrefixContext = createContext("/app");
+/**
+ * Hook to get the current Veap path prefix on the client.
+ */
+export function usePathPrefix() {
+    return useContext(PathPrefixContext);
+}

package/dist/widgets/plugin-extension-point-client.d.ts

@@ -0,0 +1,15 @@
+import type React from "react";
+export interface PluginExtensionPointClientProps {
+    target: string;
+    point: string;
+    mode?: "single" | "multiple";
+    className?: string;
+    props?: any;
+    fallback?: React.ReactNode;
+    children?: React.ReactNode;
+    includeDisabled?: boolean;
+    as?: React.ElementType;
+}
+export declare function usePluginExtensions(target: string, point: string, includeDisabled?: boolean): any[];
+export declare function PluginExtensionPointClient({ target, point, mode, className, props, fallback, children, includeDisabled, as: Container, }: PluginExtensionPointClientProps): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | React.JSX.Element | null | undefined;
+export { PluginExtensionPointClient as ExtensionPointClient };

package/dist/widgets/plugin-extension-point-client.js

@@ -0,0 +1,44 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useEffect, useState } from "react";
+import { getPluginExtensionsAction } from "../actions/index";
+import { onPluginsChanged } from "../common/events";
+export function usePluginExtensions(target, point, includeDisabled = false) {
+    const [extensions, setExtensions] = useState([]);
+    const fetchExtensions = useCallback(() => {
+        getPluginExtensionsAction(target, point, includeDisabled).then(setExtensions);
+    }, [target, point, includeDisabled]);
+    useEffect(() => {
+        fetchExtensions();
+        const unsubscribe = onPluginsChanged(() => {
+            fetchExtensions();
+        });
+        return unsubscribe;
+    }, [fetchExtensions]);
+    return extensions;
+}
+export function PluginExtensionPointClient({ target, point, mode = "multiple", className, props, fallback, children, includeDisabled = false, as: Container, }) {
+    const extensions = usePluginExtensions(target, point, includeDisabled);
+    const fallbackContent = (children ?? fallback ?? null);
+    if (extensions.length === 0)
+        return fallbackContent;
+    if (mode === "single") {
+        const ext = extensions[0];
+        const Component = ext?.component;
+        if (!Component)
+            return fallbackContent;
+        if (Container || className) {
+            const Wrapper = Container || "div";
+            return (_jsx(Wrapper, { className: className, children: _jsx(Component, { ...props }, ext.id) }));
+        }
+        return _jsx(Component, { ...props }, ext.id);
+    }
+    const Wrapper = Container || "div";
+    return (_jsx(Wrapper, { className: className, children: extensions.map((ext) => {
+            const Component = ext.component;
+            if (!Component)
+                return null;
+            return _jsx(Component, { ...props }, ext.id);
+        }) }));
+}
+export { PluginExtensionPointClient as ExtensionPointClient };