@veap/plugins 0.0.0-stage → 0.1.0

package/dist/cli/package-manager.js

@@ -0,0 +1,62 @@
+import fs from "node:fs";
+import path from "node:path";
+import { stubPath } from "./stubs.js";
+const LOCKFILES = [
+    { file: "pnpm-lock.yaml", pm: "pnpm" },
+    { file: "bun.lock", pm: "bun" },
+    { file: "bun.lockb", pm: "bun" },
+    { file: "yarn.lock", pm: "yarn" },
+    { file: "package-lock.json", pm: "npm" },
+];
+/**
+ * Detects the package manager used by the project in `dir`.
+ *
+ * Priority: `packageManager` field in package.json > lockfiles > default (pnpm).
+ * On conflicting lockfiles pnpm wins (framework default).
+ */
+export function detectPackageManager(dir) {
+    const pkgPath = path.join(dir, "package.json");
+    if (fs.existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+            if (typeof pkg.packageManager === "string") {
+                // Handles both "pnpm@11.9.0" and "pnpm@https://..." forms
+                const name = pkg.packageManager.slice(0, pkg.packageManager.indexOf("@"));
+                if (name === "pnpm" ||
+                    name === "npm" ||
+                    name === "yarn" ||
+                    name === "bun") {
+                    return name;
+                }
+            }
+        }
+        catch {
+            // malformed package.json - fall through to lockfiles
+        }
+    }
+    const found = LOCKFILES.filter((l) => fs.existsSync(path.join(dir, l.file)));
+    if (found.length > 0) {
+        return found.find((l) => l.pm === "pnpm")?.pm ?? found[0].pm;
+    }
+    return "pnpm";
+}
+/**
+ * Overwrites the generated pnpm Dockerfile with the variant matching `pm`.
+ * No-op for pnpm (baseline stub), missing variants or missing Dockerfile -
+ * best effort, Docker config is optional.
+ */
+export function applyDockerfileForPackageManager(projectDir, pm) {
+    if (pm === "pnpm")
+        return;
+    try {
+        // Stubs live at the package root of the installed @veap/framework.
+        const variantPath = stubPath("docker", `Dockerfile.${pm}.stub`);
+        const dockerfilePath = path.join(projectDir, "Dockerfile");
+        if (!fs.existsSync(variantPath) || !fs.existsSync(dockerfilePath))
+            return;
+        fs.writeFileSync(dockerfilePath, fs.readFileSync(variantPath, "utf-8"), "utf-8");
+    }
+    catch {
+        // best effort - docker config is optional
+    }
+}

package/dist/cli/stubs.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Locates the package-root `stubs/` directory of the installed @veap/framework.
+ *
+ * Every stub-based CLI command (docker, make:plugin, make:template) resolves
+ * its templates through this resolver instead of hard-coded relative walks.
+ * It anchors on the nearest package.json belonging to @veap/framework, so the
+ * result is correct regardless of how deep the calling module sits in `dist/`
+ * and regardless of the package layout (npm, pnpm's .pnpm store, yarn, bun).
+ *
+ * Convention: `stubs/` lives at the package root next to `bin/` and `dist/`
+ * (the same convention as create-veap) and is shipped in the npm package via
+ * the "files" field in package.json.
+ */
+export declare function findStubsDir(): string;
+/** Resolves a path inside the package-root stubs directory. */
+export declare function stubPath(...segments: string[]): string;

package/dist/cli/stubs.js

@@ -0,0 +1,42 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+/**
+ * Locates the package-root `stubs/` directory of the installed @veap/framework.
+ *
+ * Every stub-based CLI command (docker, make:plugin, make:template) resolves
+ * its templates through this resolver instead of hard-coded relative walks.
+ * It anchors on the nearest package.json belonging to @veap/framework, so the
+ * result is correct regardless of how deep the calling module sits in `dist/`
+ * and regardless of the package layout (npm, pnpm's .pnpm store, yarn, bun).
+ *
+ * Convention: `stubs/` lives at the package root next to `bin/` and `dist/`
+ * (the same convention as create-veap) and is shipped in the npm package via
+ * the "files" field in package.json.
+ */
+export function findStubsDir() {
+    let dir = path.dirname(fileURLToPath(import.meta.url));
+    for (;;) {
+        const pkgPath = path.join(dir, "package.json");
+        if (fs.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+                if (pkg.name === "@veap/framework") {
+                    return path.join(dir, "stubs");
+                }
+            }
+            catch {
+                // Malformed package.json - keep walking up.
+            }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            throw new Error("Unable to locate the @veap/framework package root. The 'stubs' directory ships with the @veap/framework package; reinstall it or run the CLI from a project that depends on it.");
+        }
+        dir = parent;
+    }
+}
+/** Resolves a path inside the package-root stubs directory. */
+export function stubPath(...segments) {
+    return path.join(findStubsDir(), ...segments);
+}

package/dist/cli/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function regeneratePluginsRegistry(rootDir: string): void;
+export declare function findProjectRoot(currentDir: string): string;
+export declare function processStubs(srcDir: string, destDir: string, variables: Record<string, string>): void;

package/dist/cli/utils.js

@@ -0,0 +1,164 @@
+import fs from "node:fs";
+import path from "node:path";
+function getVariableName(pkgName) {
+    const clean = pkgName
+        .replace(/^@/, "")
+        .replace(/\//, "-")
+        .replace(/-plugin$/, "")
+        .replace(/-module$/, "");
+    // Special cases to match original naming if needed
+    if (clean === "blog")
+        return "BlogModulePlugin";
+    if (clean === "panel")
+        return "PanelModulePlugin";
+    if (clean === "devtools")
+        return "DevtoolsModulePlugin";
+    if (clean === "backup")
+        return "BackupModulePlugin";
+    return (clean
+        .split("-")
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join("") + "Plugin");
+}
+export function regeneratePluginsRegistry(rootDir) {
+    const pluginsFound = [];
+    // 1. Scan package.json dependencies
+    const pkgPath = path.join(rootDir, "package.json");
+    if (fs.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        const deps = {
+            ...(pkg.dependencies || {}),
+            ...(pkg.devDependencies || {}),
+        };
+        for (const depName of Object.keys(deps)) {
+            let isPlugin = depName.endsWith("-plugin") && depName !== "@veap/cli";
+            if (!isPlugin) {
+                // Check node_modules package.json
+                const depPkgPath = path.join(rootDir, "node_modules", depName, "package.json");
+                if (fs.existsSync(depPkgPath)) {
+                    try {
+                        const depPkg = JSON.parse(fs.readFileSync(depPkgPath, "utf-8"));
+                        if ((depPkg.veap || depPkg.veap)?.type === "plugin") {
+                            isPlugin = true;
+                        }
+                    }
+                    catch (_) { }
+                }
+                // Check plugins/ and modules/ local folders
+                const cleanName = depName
+                    .replace(/^@veap\//, "")
+                    .replace(/^@veap\//, "")
+                    .replace(/^@contractor\//, "");
+                const localPluginPkgPath = path.join(rootDir, "plugins", cleanName, "package.json");
+                const localModulePkgPath = path.join(rootDir, "modules", cleanName, "package.json");
+                for (const candidatePath of [localPluginPkgPath, localModulePkgPath]) {
+                    if (fs.existsSync(candidatePath)) {
+                        try {
+                            const depPkg = JSON.parse(fs.readFileSync(candidatePath, "utf-8"));
+                            if (depPkg.veap?.type === "plugin" ||
+                                depPkg.veap?.type === "module") {
+                                isPlugin = true;
+                                break;
+                            }
+                        }
+                        catch (_) { }
+                    }
+                }
+            }
+            if (isPlugin) {
+                pluginsFound.push({
+                    name: depName,
+                    varName: getVariableName(depName),
+                });
+            }
+        }
+    }
+    // Generate code for plugins.gen.ts
+    let code = "" +
+        "/**\n * FILE AUTOMATICALLY GENERATED BY veap/cli\n * DO NOT EDIT THIS FILE MANUALLY!\n */\n\n";
+    // Write imports
+    for (const p of pluginsFound) {
+        code += "import { default as " + p.varName + ' } from "' + p.name + '";\n';
+    }
+    code += "\nexport const plugins = [\n";
+    for (const p of pluginsFound) {
+        code += "  " + p.varName + ",\n";
+    }
+    code += "];\n";
+    const pluginsGenPath = path.join(rootDir, "lib", "plugins.gen.ts");
+    // Make sure lib/ directory exists
+    const libDir = path.dirname(pluginsGenPath);
+    if (!fs.existsSync(libDir)) {
+        fs.mkdirSync(libDir, { recursive: true });
+    }
+    fs.writeFileSync(pluginsGenPath, code, "utf-8");
+    console.log("[Veap CLI] Regenerated " +
+        pluginsGenPath +
+        " with " +
+        pluginsFound.length +
+        " plugins.");
+}
+const WORKSPACE_MARKERS = [
+    "pnpm-lock.yaml",
+    "bun.lock",
+    "bun.lockb",
+    "yarn.lock",
+    "package-lock.json",
+    "pnpm-workspace.yaml",
+];
+function hasWorkspacesField(dir) {
+    const pkgPath = path.join(dir, "package.json");
+    if (!fs.existsSync(pkgPath))
+        return false;
+    try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        const workspaces = pkg.workspaces;
+        if (Array.isArray(workspaces) && workspaces.length > 0)
+            return true;
+        return (!!workspaces &&
+            typeof workspaces === "object" &&
+            Array.isArray(workspaces.packages) &&
+            workspaces.packages.length > 0);
+    }
+    catch {
+        return false;
+    }
+}
+export function findProjectRoot(currentDir) {
+    if (WORKSPACE_MARKERS.some((marker) => fs.existsSync(path.join(currentDir, marker))) ||
+        hasWorkspacesField(currentDir)) {
+        return currentDir;
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+        return process.cwd();
+    }
+    return findProjectRoot(parentDir);
+}
+export function processStubs(srcDir, destDir, variables) {
+    if (!fs.existsSync(destDir)) {
+        fs.mkdirSync(destDir, { recursive: true });
+    }
+    const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+    for (const entry of entries) {
+        let destName = entry.name;
+        for (const [key, value] of Object.entries(variables)) {
+            destName = destName.replace(new RegExp("\\{\\{" + key + "\\}\\}", "g"), value);
+        }
+        if (destName.endsWith(".stub")) {
+            destName = destName.slice(0, -5);
+        }
+        const srcPath = path.join(srcDir, entry.name);
+        const destPath = path.join(destDir, destName);
+        if (entry.isDirectory()) {
+            processStubs(srcPath, destPath, variables);
+        }
+        else {
+            let content = fs.readFileSync(srcPath, "utf-8");
+            for (const [key, value] of Object.entries(variables)) {
+                content = content.replace(new RegExp("\\{\\{" + key + "\\}\\}", "g"), value);
+            }
+            fs.writeFileSync(destPath, content);
+        }
+    }
+}

package/dist/client.d.ts

@@ -0,0 +1,6 @@
+export { notifyPluginsChanged, onPluginsChanged } from "./common/events";
+export { PathPrefixContext, usePathPrefix, } from "./widgets/path-prefix-context";
+export { ExtensionPointClient, PluginExtensionPointClient, usePluginExtensions, } from "./widgets/plugin-extension-point-client";
+export { PluginWidgetAreaClient, usePluginWidgets, WidgetAreaClient, } from "./widgets/plugin-widget-area-client";
+export { type ConfirmOptions, type ConfirmResult, useConfirmAction, } from "./widgets/use-confirm-action";
+export { WidgetComposerClient } from "./widgets/widget-composer-client";

package/dist/client.js

@@ -0,0 +1,8 @@
+"use client";
+export { notifyPluginsChanged, onPluginsChanged } from "./common/events";
+export { PathPrefixContext, usePathPrefix, } from "./widgets/path-prefix-context";
+// Compatibility Aliases & Client Widgets
+export { ExtensionPointClient, PluginExtensionPointClient, usePluginExtensions, } from "./widgets/plugin-extension-point-client";
+export { PluginWidgetAreaClient, usePluginWidgets, WidgetAreaClient, } from "./widgets/plugin-widget-area-client";
+export { useConfirmAction, } from "./widgets/use-confirm-action";
+export { WidgetComposerClient } from "./widgets/widget-composer-client";

package/dist/common/context.d.ts

@@ -0,0 +1,26 @@
+import type { NavigationService } from "../navigation/navigation.service";
+import type { PluginRegistry } from "../registry/registry.service";
+import type { RouterService } from "../router/router.service";
+/**
+ * Typed boundary between the plugins use cases and the modules that consume
+ * them (facades, navigation, router, intl, presentation components).
+ */
+export interface PluginsContext {
+    registry: PluginRegistry;
+    navigation: NavigationService;
+    router?: RouterService;
+}
+/**
+ * Binds the resolved plugins services. Called once by the composition root.
+ */
+export declare function bindPluginsContext(context: PluginsContext): void;
+/**
+ * Returns true if the plugins context has been bound by PluginsServiceProvider.
+ */
+export declare function isPluginsContextBound(): boolean;
+/**
+ * Returns the bound plugins services.
+ *
+ * @throws If the plugins service provider has not booted yet.
+ */
+export declare function pluginsContext(): PluginsContext;

package/dist/common/context.js

@@ -0,0 +1,26 @@
+import { AppError } from "@veap/kernel";
+const globalForPluginsContext = globalThis;
+/**
+ * Binds the resolved plugins services. Called once by the composition root.
+ */
+export function bindPluginsContext(context) {
+    globalForPluginsContext.__VEAP_PLUGINS_CONTEXT__ = context;
+}
+/**
+ * Returns true if the plugins context has been bound by PluginsServiceProvider.
+ */
+export function isPluginsContextBound() {
+    return Boolean(globalForPluginsContext.__VEAP_PLUGINS_CONTEXT__);
+}
+/**
+ * Returns the bound plugins services.
+ *
+ * @throws If the plugins service provider has not booted yet.
+ */
+export function pluginsContext() {
+    const context = globalForPluginsContext.__VEAP_PLUGINS_CONTEXT__;
+    if (!context) {
+        throw AppError.Internal("[Plugins] Context is not bound. PluginsServiceProvider must boot before the plugins facades are used.");
+    }
+    return context;
+}

package/dist/common/events.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Client-side events for plugin state changes.
+ *
+ * When a plugin is toggled via the manager, we need a way to
+ * notify all interested client components (ExtensionPointClient,
+ * WidgetAreaClient, etc.) so they can re-fetch their data without
+ * requiring a full page refresh.
+ */
+type Listener = () => void;
+/**
+ * Subscribe to plugin state changes.
+ * Returns an unsubscribe function.
+ */
+export declare function onPluginsChanged(cb: Listener): () => void;
+/**
+ * Notify all subscribers that a plugin was toggled.
+ */
+export declare function notifyPluginsChanged(): void;
+export {};

package/dist/common/events.js

@@ -0,0 +1,26 @@
+/**
+ * Client-side events for plugin state changes.
+ *
+ * When a plugin is toggled via the manager, we need a way to
+ * notify all interested client components (ExtensionPointClient,
+ * WidgetAreaClient, etc.) so they can re-fetch their data without
+ * requiring a full page refresh.
+ */
+const listeners = new Set();
+/**
+ * Subscribe to plugin state changes.
+ * Returns an unsubscribe function.
+ */
+export function onPluginsChanged(cb) {
+    listeners.add(cb);
+    return () => {
+        listeners.delete(cb);
+    };
+}
+/**
+ * Notify all subscribers that a plugin was toggled.
+ */
+export function notifyPluginsChanged() {
+    // biome-ignore lint/suspicious/useIterableCallbackReturn: <ignore>
+    listeners.forEach((cb) => cb());
+}

package/dist/common/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./context";
+export * from "./events";
+export * from "./types";

package/dist/common/index.js

@@ -0,0 +1,3 @@
+export * from "./context";
+export * from "./events";
+export * from "./types";

package/dist/common/types.d.ts

@@ -0,0 +1,195 @@
+import type { UserPermission, UserRole } from "@veap/auth";
+import type { SystemEvent } from "@veap/kernel";
+export type { SystemEvent };
+import type * as React from "react";
+import { z } from "zod";
+export type SidebarGroupType = {
+    title: string;
+    items: SidebarMenuType;
+};
+export type SidebarMenuItemType<T = Record<string, string>> = {
+    id?: string;
+    title: string;
+    icon?: string;
+    url: string;
+    roles?: string[];
+    permissions?: string[];
+    priority?: number;
+    badge?: string | number | null | undefined;
+    badgeVariant?: "default" | "secondary" | "destructive" | "outline" | null | undefined;
+} & T;
+export type SidebarMenuType = SidebarMenuItemType<{
+    items?: SidebarMenuItemType<{
+        items?: SidebarMenuItemType[];
+    }>[];
+}>[];
+export declare const PluginManifestSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    dependencies: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    extends: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    system: z.ZodDefault<z.ZodBoolean>;
+    hasSetup: z.ZodDefault<z.ZodBoolean>;
+    author: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export interface PluginManifest {
+    id: string;
+    name: string;
+    version: string;
+    description?: string;
+    dependencies?: string[];
+    extends?: string[];
+    enabled?: boolean;
+    system?: boolean;
+    hasSetup?: boolean;
+    author?: string;
+    [key: string]: any;
+}
+/**
+ * Shape of the `veap` field in a plugin `package.json`.
+ * This replaces the standalone `manifest.json` file.
+ */
+export interface VeapPackageMetadata {
+    type?: string;
+    id?: string;
+    name?: string;
+    description?: string;
+    enabled?: boolean;
+    system?: boolean;
+    hasSetup?: boolean;
+    dependencies?: string[];
+    extends?: string[];
+    isNpm?: boolean;
+    author?: string;
+    [key: string]: any;
+}
+/**
+ * Shape of the `package.json` for a Veap plugin.
+ */
+export interface VeapPackageJson {
+    name: string;
+    version: string;
+    description?: string;
+    veap?: VeapPackageMetadata;
+    [key: string]: any;
+}
+/**
+ * Helper to build a `PluginManifest` from a `package.json` import.
+ * Eliminates the need for a standalone `manifest.json` file.
+ *
+ * @example
+ * ```ts
+ * import pkg from "../package.json" with { type: "json" };
+ * import { createManifestFromPackageJson } from "@veap/framework/plugins";
+ * const manifest = createManifestFromPackageJson(pkg);
+ * ```
+ */
+export declare function createManifestFromPackageJson(pkg: VeapPackageJson): PluginManifest;
+export interface PluginHook {
+    point: string;
+    handler: (data: any, context?: any) => Promise<any> | any;
+    priority?: number;
+}
+export interface PluginExtension {
+    id: string;
+    target: string;
+    point: string;
+    component: React.ComponentType<any>;
+    priority?: number;
+    metadata?: any;
+    roles?: string[];
+    permissions?: string[];
+}
+export interface PluginWidget {
+    id: string;
+    name: string;
+    area: string;
+    component: React.ComponentType<any>;
+    priority?: number;
+    defaultColSpan?: number;
+    defaultRowSpan?: number;
+    roles?: string[];
+    permissions?: string[];
+}
+export interface PluginPageProps {
+    params: any;
+    searchParams: any;
+    context?: VeapMiddlewareContext;
+}
+export interface VeapMiddlewareContext {
+    params: any;
+    searchParams: any;
+    path: string;
+    roles?: UserRole[];
+    permissions?: UserPermission[];
+    [key: string]: any;
+}
+export type VeapMiddleware = (context: VeapMiddlewareContext, next: () => Promise<React.ReactNode>) => Promise<React.ReactNode>;
+export interface BreadcrumbItem {
+    label: string;
+    href?: string;
+    id?: string;
+}
+export type BreadcrumbValue = string | ((props: PluginPageProps) => Promise<string | BreadcrumbItem | BreadcrumbItem[]> | string | BreadcrumbItem | BreadcrumbItem[]);
+export type PluginNavElement = SidebarMenuItemType<{
+    items?: SidebarMenuItemType<{
+        items?: SidebarMenuItemType[];
+    }>[];
+}>;
+export interface PluginNavigationGroupDefinition {
+    title?: string;
+    priority?: number;
+    items: PluginNavElement[];
+}
+export type PluginNavigationGroupMap = Record<string, PluginNavElement[] | PluginNavigationGroupDefinition>;
+export type ModuleNavigation = PluginNavigation;
+export type ModuleNavElement = PluginNavElement;
+export type ModuleManifest = PluginManifest;
+export type ApiMiddleware = (request: Request, context: any, next: () => Promise<Response>) => Promise<Response>;
+export interface PluginNavigation {
+    public?: PluginNavElement[];
+    admin?: PluginNavigationGroupMap;
+    settings?: PluginNavigationGroupMap;
+}
+export interface IPlugin {
+    locales?: Record<string, () => Promise<{
+        default: any;
+    }>>;
+    manifest: PluginManifest;
+    migrations?: any[];
+    init?: () => Promise<void> | void;
+    onMigrate?: () => Promise<void> | void;
+    onEnable?: (context?: any) => Promise<void> | void;
+    onDisable?: () => Promise<void> | void;
+    hooks?: PluginHook[];
+    extensions?: PluginExtension[];
+    widgets?: PluginWidget[];
+    navigation?: PluginNavigation;
+    plugins?: IPlugin[];
+    /**
+     * App Router-style route tree definition.
+     *
+     * This is the standard way to define routes for a plugin in Veap.
+     * Typically generated dynamically using `discoverRoutes` from the plugin's `app/` directory.
+     *
+     * Can contain nested layouts, loading/error boundaries, route groups,
+     * parallel routes, and dynamic segments.
+     *
+     * @example
+     * ```ts
+     * const plugin: IPlugin = {
+     *   manifest,
+     *   routeTree: async () => {
+     *     const { discoverRoutes } = await import("@veap/framework/router");
+     *     const path = await import("path");
+     *     const appDir = path.join(process.cwd(), "plugins", "my-plugin", "src", "app");
+     *     return discoverRoutes(appDir, (relPath) => import(`../src/app/${relPath}`));
+     *   },
+     * };
+     * ```
+     */
+    routeTree?: import("../router/route-tree").RouteNode | (() => Promise<import("../router/route-tree").RouteNode> | import("../router/route-tree").RouteNode);
+}

package/dist/common/types.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+export const PluginManifestSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    version: z.string(),
+    description: z.string().optional(),
+    dependencies: z.array(z.string()).default([]),
+    extends: z.array(z.string()).default([]),
+    enabled: z.boolean().default(true),
+    system: z.boolean().default(false),
+    hasSetup: z.boolean().default(false),
+    author: z.string().optional(),
+});
+/**
+ * Helper to build a `PluginManifest` from a `package.json` import.
+ * Eliminates the need for a standalone `manifest.json` file.
+ *
+ * @example
+ * ```ts
+ * import pkg from "../package.json" with { type: "json" };
+ * import { createManifestFromPackageJson } from "@veap/framework/plugins";
+ * const manifest = createManifestFromPackageJson(pkg);
+ * ```
+ */
+export function createManifestFromPackageJson(pkg) {
+    const meta = pkg.veap || {};
+    return {
+        id: meta.id || pkg.name.replace(/^@[^/]+\//, ""),
+        name: meta.name || pkg.name,
+        version: pkg.version,
+        description: meta.description || pkg.description,
+        enabled: meta.enabled ?? true,
+        system: meta.system ?? false,
+        hasSetup: meta.hasSetup ?? false,
+        dependencies: meta.dependencies || [],
+        extends: meta.extends || [],
+        isNpm: meta.isNpm ?? true,
+        author: meta.author,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./common";
+export * from "./migrations";
+export * from "./navigation";
+export * from "./providers";
+export * from "./registry";

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from "./common";
+export * from "./migrations";
+export * from "./navigation";
+export * from "./providers";
+export * from "./registry";

package/dist/migrations/0001_create_plugins_tables.d.ts

@@ -0,0 +1,4 @@
+import type { Schema } from "@veap/database";
+export declare const name = "0001_create_plugins_tables";
+export declare function up(_db: any, schema: Schema): Promise<void>;
+export declare function down(_db: any, schema: Schema): Promise<void>;