@nocobase/app-plugin-foundation 0.0.0-stage → 0.1.0-beta.0

package/dist/server/module-manifest.d.ts

@@ -0,0 +1,10 @@
+import type { FoundationModuleSources } from '../shared/foundation.js';
+export declare const MODULE_MANIFEST_FILE: string;
+/** Deployment metadata contains association evidence only, never source text or filesystem locations. */
+export declare function readModuleManifest(rootDir: string, packageName: string): Promise<FoundationModuleSources | undefined>;
+/** Repeat builds converge on the same bytes; replace the artifact only after a complete write. */
+export declare function writeModuleManifest(rootDir: string): Promise<{
+    readonly routes: number;
+    readonly complete: boolean;
+}>;
+//# sourceMappingURL=module-manifest.d.ts.map

package/dist/server/module-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-manifest.d.ts","sourceRoot":"","sources":["../../server/module-manifest.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAEvE,eAAO,MAAM,oBAAoB,EAAE,MAAkC,CAAC;AA0BtE,yGAAyG;AACzG,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,uBAAuB,GAAG,SAAS,CAAC,CAmB9C;AAED,kGAAkG;AAClG,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,MAAM,GACd,OAAO,CAAC;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAAC,CAqBlE"}

package/dist/server/module-manifest.js

@@ -0,0 +1,65 @@
+import { mkdir, readFile, rename, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { z } from 'zod';
+export const MODULE_MANIFEST_FILE = 'foundation-modules.json';
+const manifestSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    packageName: z.string(),
+    sources: z
+        .object({
+        complete: z.boolean(),
+        routes: z
+            .array(z
+            .object({
+            packageName: z.string(),
+            routeName: z.string(),
+            providers: z.array(z.string()),
+            apiProviders: z.array(z.string()).optional(),
+            complete: z.boolean(),
+        })
+            .strict())
+            .max(10000),
+    })
+        .strict(),
+})
+    .strict();
+/** Deployment metadata contains association evidence only, never source text or filesystem locations. */
+export async function readModuleManifest(rootDir, packageName) {
+    const file = path.join(rootDir, 'server', MODULE_MANIFEST_FILE);
+    try {
+        if ((await stat(file)).size > 5_000_000)
+            return undefined;
+        const parsed = manifestSchema.safeParse(JSON.parse(await readFile(file, 'utf8')));
+        if (!parsed.success ||
+            parsed.data.packageName !== packageName ||
+            parsed.data.sources.routes.some((route) => route.packageName !== packageName))
+            return undefined;
+        return parsed.data.sources;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Repeat builds converge on the same bytes; replace the artifact only after a complete write. */
+export async function writeModuleManifest(rootDir) {
+    const { collectModuleSources } = await import('./module-sources.js');
+    const manifest = JSON.parse(await readFile(path.join(rootDir, 'package.json'), 'utf8'));
+    const sources = await collectModuleSources(rootDir);
+    const document = manifestSchema.parse({
+        schemaVersion: 1,
+        packageName: manifest.name,
+        sources,
+    });
+    const file = path.join(rootDir, 'dist', 'server', MODULE_MANIFEST_FILE);
+    const contents = JSON.stringify(document) + '\n';
+    await mkdir(path.dirname(file), { recursive: true });
+    const previous = await readFile(file, 'utf8').catch(() => undefined);
+    if (previous !== contents) {
+        const temporary = `${file}.${process.pid}.tmp`;
+        await writeFile(temporary, contents);
+        await rename(temporary, file);
+    }
+    return { routes: sources.routes.length, complete: sources.complete };
+}
+//# sourceMappingURL=module-manifest.js.map

package/dist/server/module-manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-manifest.js","sourceRoot":"","sources":["../../server/module-manifest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC5E,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,MAAM,CAAC,MAAM,oBAAoB,GAAW,yBAAyB,CAAC;AACtE,MAAM,cAAc,GAAG,CAAC;KACrB,MAAM,CAAC;IACN,aAAa,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;IAC3B,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IACvB,OAAO,EAAE,CAAC;SACP,MAAM,CAAC;QACN,QAAQ,EAAE,CAAC,CAAC,OAAO,EAAE;QACrB,MAAM,EAAE,CAAC;aACN,KAAK,CACJ,CAAC;aACE,MAAM,CAAC;YACN,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;YACvB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;YACrB,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;YAC9B,YAAY,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;YAC5C,QAAQ,EAAE,CAAC,CAAC,OAAO,EAAE;SACtB,CAAC;aACD,MAAM,EAAE,CACZ;aACA,GAAG,CAAC,KAAK,CAAC;KACd,CAAC;SACD,MAAM,EAAE;CACZ,CAAC;KACD,MAAM,EAAE,CAAC;AAEZ,yGAAyG;AACzG,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,OAAe,EACf,WAAmB;IAEnB,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,EAAE,oBAAoB,CAAC,CAAC;IAChE,IAAI,CAAC;QACH,IAAI,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,GAAG,SAAS;YAAE,OAAO,SAAS,CAAC;QAC1D,MAAM,MAAM,GAAG,cAAc,CAAC,SAAS,CACrC,IAAI,CAAC,KAAK,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,CAAY,CACpD,CAAC;QACF,IACE,CAAC,MAAM,CAAC,OAAO;YACf,MAAM,CAAC,IAAI,CAAC,WAAW,KAAK,WAAW;YACvC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAC7B,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,WAAW,KAAK,WAAW,CAC7C;YAED,OAAO,SAAS,CAAC;QACnB,OAAO,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC;IAC7B,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC;AAED,kGAAkG;AAClG,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,OAAe;IAEf,MAAM,EAAE,oBAAoB,EAAE,GAAG,MAAM,MAAM,CAAC,qBAAqB,CAAC,CAAC;IACrE,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CACzB,MAAM,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,cAAc,CAAC,EAAE,MAAM,CAAC,CACvC,CAAC;IACtB,MAAM,OAAO,GAAG,MAAM,oBAAoB,CAAC,OAAO,CAAC,CAAC;IACpD,MAAM,QAAQ,GAAG,cAAc,CAAC,KAAK,CAAC;QACpC,aAAa,EAAE,CAAC;QAChB,WAAW,EAAE,QAAQ,CAAC,IAAI;QAC1B,OAAO;KACR,CAAC,CAAC;IACH,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,oBAAoB,CAAC,CAAC;IACxE,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC;IACjD,MAAM,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACrD,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;IACrE,IAAI,QAAQ,KAAK,QAAQ,EAAE,CAAC;QAC1B,MAAM,SAAS,GAAG,GAAG,IAAI,IAAI,OAAO,CAAC,GAAG,MAAM,CAAC;QAC/C,MAAM,SAAS,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;QACrC,MAAM,MAAM,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IAChC,CAAC;IACD,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,CAAC;AACvE,CAAC"}

package/dist/server/module-sources.d.ts

@@ -0,0 +1,5 @@
+import type { FoundationModuleSources } from '../shared/foundation.js';
+import type { RuntimeProviderEvidence } from './provider-inventory.js';
+/** Reads static declarations and value imports only. Never imports an application module or invokes a loader. */
+export declare function collectModuleSources(rootDir: string, runtime?: readonly RuntimeProviderEvidence[]): Promise<FoundationModuleSources>;
+//# sourceMappingURL=module-sources.d.ts.map

package/dist/server/module-sources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-sources.d.ts","sourceRoot":"","sources":["../../server/module-sources.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAEV,uBAAuB,EACxB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAmBvE,iHAAiH;AACjH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,SAAS,uBAAuB,EAAO,GAC/C,OAAO,CAAC,uBAAuB,CAAC,CAgGlC"}

package/dist/server/module-sources.js

@@ -0,0 +1,535 @@
+import { readFile, realpath, stat } from 'node:fs/promises';
+import path from 'node:path';
+import ts from 'typescript';
+import { SourceEvidence } from './source-evidence.js';
+import { readModuleManifest } from './module-manifest.js';
+const MAX_FILES = 400;
+const MAX_BYTES = 512_000;
+const SOURCE_SUFFIXES = ['.ts', '.tsx', '.js', '.jsx', '.mjs'];
+/** Reads static declarations and value imports only. Never imports an application module or invokes a loader. */
+export async function collectModuleSources(rootDir, runtime = []) {
+    const routes = [];
+    let complete = true;
+    const roots = new Map([['', rootDir]]);
+    let overridden = new Set();
+    for (const entry of runtime)
+        if (entry.rootDir)
+            roots.set(entry.name, entry.rootDir);
+    for (const [name, directory] of roots) {
+        if (!directory || name === '@nocobase/app-plugin-foundation')
+            continue;
+        try {
+            const graph = await SourceGraph.create(directory);
+            if (!name)
+                overridden = await graph.overrides();
+            const packageName = name || graph.packageName;
+            if (!packageName) {
+                complete = false;
+                continue;
+            }
+            const entry = await graph.entry();
+            if (!entry) {
+                const built = !name
+                    ? await readModuleManifest(directory, packageName)
+                    : undefined;
+                if (built) {
+                    routes.push(...built.routes);
+                    complete &&= built.complete;
+                }
+                else
+                    complete = false;
+                continue;
+            }
+            const declarationFiles = await graph.walk(entry, false);
+            await graph.prepare(entry);
+            const endpoints = await graph.apiDependencies();
+            for (const source of declarationFiles.sources) {
+                const declarations = [];
+                const visit = (node) => {
+                    if (ts.isObjectLiteralExpression(node)) {
+                        const routeName = property(node, 'name');
+                        const loader = property(node, 'componentLoader');
+                        if (routeName && ts.isStringLiteralLike(routeName) && loader)
+                            declarations.push({ name: routeName.text, loader });
+                    }
+                    ts.forEachChild(node, visit);
+                };
+                visit(source.ast);
+                for (const declaration of declarations) {
+                    if (overridden.has(`${packageName}:${declaration.name}`)) {
+                        routes.push({
+                            packageName,
+                            routeName: declaration.name,
+                            providers: [],
+                            complete: false,
+                        });
+                        continue;
+                    }
+                    const imports = importsIn(declaration.loader);
+                    const providers = new Set();
+                    const apiProviders = new Set();
+                    let routeComplete = declarationFiles.complete && imports.length > 0;
+                    for (const specifier of imports) {
+                        const target = await graph.local(source.file, specifier);
+                        if (!target) {
+                            if (!isLocal(specifier))
+                                addProvider(providers, specifier);
+                            else
+                                routeComplete = false;
+                            continue;
+                        }
+                        const page = graph.evidence(target);
+                        for (const provider of page.providers)
+                            providers.add(provider);
+                        for (const file of page.sources) {
+                            for (const request of graph.requests(file)) {
+                                for (const endpoint of endpoints)
+                                    if (request.method === endpoint.method &&
+                                        sameApiPath(request.path, endpoint.path))
+                                        for (const provider of endpoint.providers)
+                                            apiProviders.add(provider);
+                            }
+                        }
+                        routeComplete &&= page.complete;
+                    }
+                    routes.push({
+                        packageName,
+                        routeName: declaration.name,
+                        providers: [...providers].sort(),
+                        ...(apiProviders.size
+                            ? { apiProviders: [...apiProviders].sort() }
+                            : {}),
+                        complete: routeComplete,
+                    });
+                }
+            }
+            complete &&= declarationFiles.complete;
+        }
+        catch {
+            complete = false;
+        }
+    }
+    return { routes, complete };
+}
+/** A bounded package-local graph; symlinks, aliases and relative paths cannot escape the owning package. */
+class SourceGraph {
+    root;
+    packageName;
+    aliases;
+    files = new Map();
+    analysis;
+    constructor(root, packageName, aliases) {
+        this.root = root;
+        this.packageName = packageName;
+        this.aliases = aliases;
+    }
+    static async create(root) {
+        const directory = await realpath(root);
+        const manifest = JSON.parse(await readFile(path.join(directory, 'package.json'), 'utf8'));
+        const record = isRecord(manifest) ? manifest : {};
+        return new SourceGraph(directory, typeof record.name === 'string' ? record.name : '', isRecord(record.imports) ? record.imports : {});
+    }
+    async resolve(base) {
+        if (!inside(this.root, path.resolve(base)))
+            return undefined;
+        const extension = path.extname(base);
+        const stem = SOURCE_SUFFIXES.includes(extension)
+            ? base.slice(0, -extension.length)
+            : base;
+        for (const candidate of [
+            ...SOURCE_SUFFIXES.map((suffix) => stem + suffix),
+            base,
+            ...SOURCE_SUFFIXES.map((suffix) => path.join(base, 'index' + suffix)),
+        ]) {
+            try {
+                const file = await realpath(candidate);
+                if (!SOURCE_SUFFIXES.includes(path.extname(file)) ||
+                    !inside(this.root, file) ||
+                    path
+                        .relative(this.root, file)
+                        .split(path.sep)
+                        .includes('node_modules'))
+                    continue;
+                if ((await stat(file)).isFile())
+                    return file;
+            }
+            catch {
+                /* Missing alternatives are expected when resolving compiled .js references to .tsx sources. */
+            }
+        }
+        return undefined;
+    }
+    async entry() {
+        return ((await this.resolve(path.join(this.root, 'client/routes.js'))) ??
+            (await this.resolve(path.join(this.root, 'dist/client/routes.js'))));
+    }
+    async prepare(entry) {
+        await this.walk(entry, true);
+        const server = (await this.resolve(path.join(this.root, 'server/routes/index.js'))) ??
+            (await this.resolve(path.join(this.root, 'server/routes.js')));
+        if (server)
+            await this.walk(server, false);
+        const resolutions = new Map();
+        for (const source of this.files.values()) {
+            if (!source)
+                continue;
+            for (const specifier of [
+                ...source.imports,
+                ...dynamicImports(source.ast),
+            ]) {
+                const target = await this.local(source.file, specifier);
+                if (target)
+                    resolutions.set(`${source.file}\0${specifier}`, target);
+            }
+        }
+        this.analysis = new SourceEvidence([...this.files.values()].filter((source) => Boolean(source)), resolutions);
+    }
+    evidence(file, roots) {
+        const slice = this.analysis?.collect(file, roots);
+        const providers = new Set();
+        for (const reference of slice?.references ?? [])
+            addProvider(providers, reference);
+        return {
+            providers,
+            complete: slice?.complete ?? false,
+            sources: [...(slice?.nodes ?? [])].flatMap(([name, nodes]) => {
+                const source = this.files.get(name);
+                return source ? [{ ...source, nodes }] : [];
+            }),
+        };
+    }
+    requests(source) {
+        return requestPaths(source.ast, source.nodes, (node) => this.analysis?.symbol(node));
+    }
+    async overrides() {
+        const ids = new Set();
+        const entry = await this.resolve(path.join(this.root, 'client/route-overrides.js'));
+        if (!entry)
+            return ids;
+        const graph = await this.walk(entry, false);
+        for (const source of graph.sources) {
+            const visit = (node) => {
+                if (ts.isObjectLiteralExpression(node)) {
+                    const id = property(node, 'routeId');
+                    if (id && ts.isStringLiteralLike(id))
+                        ids.add(id.text);
+                }
+                ts.forEachChild(node, visit);
+            };
+            visit(source.ast);
+        }
+        return ids;
+    }
+    /** Only explicit, root-mounted Hono endpoints and literal API-client requests can establish this bridge. */
+    async apiDependencies() {
+        const entry = (await this.resolve(path.join(this.root, 'server/routes/index.js'))) ??
+            (await this.resolve(path.join(this.root, 'server/routes.js')));
+        if (!entry)
+            return [];
+        const graph = this.evidence(entry);
+        const endpoints = [];
+        for (const source of graph.sources) {
+            if (!source.imports.includes('hono'))
+                continue;
+            const mounts = new Map();
+            const routes = [];
+            const reachableScope = (node) => {
+                for (let parent = node.parent; parent; parent = parent.parent)
+                    if (ts.isFunctionLike(parent))
+                        return source.nodes.has(parent);
+                return true;
+            };
+            const visit = (node) => {
+                if (ts.isCallExpression(node) &&
+                    reachableScope(node) &&
+                    ts.isPropertyAccessExpression(node.expression)) {
+                    const first = node.arguments[0];
+                    if (first && ts.isStringLiteralLike(first)) {
+                        const method = node.expression.name.text;
+                        const child = node.arguments[1];
+                        if (method === 'route' && child && ts.isIdentifier(child))
+                            mounts.set(child.text, [
+                                ...(mounts.get(child.text) ?? []),
+                                first.text,
+                            ]);
+                        if (['get', 'post', 'put', 'patch', 'delete'].includes(method) &&
+                            first.text.startsWith('/') &&
+                            ts.isIdentifier(node.expression.expression))
+                            routes.push({
+                                router: node.expression.expression.text,
+                                path: first.text,
+                                method: method.toUpperCase(),
+                                handlers: node.arguments.slice(1),
+                            });
+                    }
+                }
+                ts.forEachChild(node, visit);
+            };
+            visit(source.ast);
+            if (!routes.length)
+                continue;
+            for (const route of routes) {
+                // Prefixes composed elsewhere, factories and dynamic routing remain unknown rather than guessed.
+                if (!(mounts.get(route.router) ?? []).includes('/'))
+                    continue;
+                endpoints.push({
+                    path: route.path,
+                    method: route.method,
+                    providers: [
+                        ...this.evidence(source.file, route.handlers).providers,
+                    ].sort(),
+                });
+            }
+        }
+        return endpoints;
+    }
+    async local(from, specifier) {
+        if (specifier.startsWith('.'))
+            return this.resolve(path.resolve(path.dirname(from), specifier));
+        if (!specifier.startsWith('#'))
+            return undefined;
+        for (const [alias, value] of Object.entries(this.aliases).sort(([a], [b]) => b.length - a.length)) {
+            const star = alias.indexOf('*');
+            const matches = star < 0
+                ? alias === specifier
+                : specifier.startsWith(alias.slice(0, star)) &&
+                    specifier.endsWith(alias.slice(star + 1));
+            if (!matches)
+                continue;
+            const replacement = star < 0
+                ? ''
+                : specifier.slice(star, specifier.length - (alias.length - star - 1));
+            for (const target of targets(value)) {
+                if (!target.startsWith('./'))
+                    continue;
+                const resolved = await this.resolve(path.resolve(this.root, target.replace('*', replacement)));
+                if (resolved)
+                    return resolved;
+            }
+        }
+        return undefined;
+    }
+    async walk(entry, includePages) {
+        const pending = [entry];
+        const visited = new Set();
+        const sources = [];
+        const providers = new Set();
+        let complete = true;
+        while (pending.length) {
+            const file = pending.shift();
+            if (!file || visited.has(file))
+                continue;
+            visited.add(file);
+            const source = await this.read(file);
+            if (!source) {
+                complete = false;
+                continue;
+            }
+            sources.push(source);
+            for (const specifier of source.imports) {
+                if (!isLocal(specifier)) {
+                    addProvider(providers, specifier);
+                    continue;
+                }
+                const target = await this.local(file, specifier);
+                if (!target) {
+                    complete = false;
+                    continue;
+                }
+                pending.push(target);
+            }
+            if (includePages) {
+                for (const specifier of dynamicImports(source.ast)) {
+                    const target = await this.local(file, specifier);
+                    if (target)
+                        pending.push(target);
+                    else if (isLocal(specifier))
+                        complete = false;
+                    else
+                        addProvider(providers, specifier);
+                }
+            }
+        }
+        return { sources, providers, complete };
+    }
+    async read(file) {
+        if (this.files.has(file))
+            return this.files.get(file);
+        if (this.files.size >= MAX_FILES)
+            return undefined;
+        this.files.set(file, undefined);
+        try {
+            if ((await stat(file)).size > MAX_BYTES)
+                return undefined;
+            const ast = ts.createSourceFile(file, await readFile(file, 'utf8'), ts.ScriptTarget.Latest, true);
+            const source = { file, ast, imports: staticImports(ast) };
+            this.files.set(file, source);
+            return source;
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+function property(object, name) {
+    const entry = object.properties.find((item) => item.name &&
+        (ts.isIdentifier(item.name) || ts.isStringLiteralLike(item.name)) &&
+        item.name.text === name);
+    return entry && ts.isPropertyAssignment(entry)
+        ? entry.initializer
+        : undefined;
+}
+function staticImports(node) {
+    return node.statements.flatMap((statement) => {
+        if (ts.isImportDeclaration(statement) &&
+            ts.isStringLiteralLike(statement.moduleSpecifier)) {
+            const clause = statement.importClause;
+            if (clause?.isTypeOnly)
+                return [];
+            if (clause?.namedBindings &&
+                ts.isNamedImports(clause.namedBindings) &&
+                !clause.name &&
+                clause.namedBindings.elements.length > 0 &&
+                clause.namedBindings.elements.every((element) => element.isTypeOnly))
+                return [];
+            return [statement.moduleSpecifier.text];
+        }
+        if (ts.isExportDeclaration(statement) &&
+            !statement.isTypeOnly &&
+            statement.moduleSpecifier &&
+            ts.isStringLiteralLike(statement.moduleSpecifier)) {
+            if (statement.exportClause &&
+                ts.isNamedExports(statement.exportClause) &&
+                statement.exportClause.elements.length > 0 &&
+                statement.exportClause.elements.every((element) => element.isTypeOnly))
+                return [];
+            return [statement.moduleSpecifier.text];
+        }
+        return [];
+    });
+}
+function dynamicImports(node) {
+    return importsIn(node);
+}
+function requestPaths(source, selected, symbol) {
+    const paths = [];
+    const clients = new Set();
+    const hooks = new Set();
+    for (const statement of source.statements) {
+        if (!ts.isImportDeclaration(statement) ||
+            !ts.isStringLiteralLike(statement.moduleSpecifier) ||
+            statement.moduleSpecifier.text !== '@nocobase/app-client')
+            continue;
+        const bindings = statement.importClause?.namedBindings;
+        if (bindings && ts.isNamedImports(bindings))
+            for (const binding of bindings.elements)
+                if ((binding.propertyName?.text ?? binding.name.text) === 'useApiClient')
+                    hooks.add(symbol(binding.name));
+    }
+    const findClients = (node) => {
+        if (ts.isVariableDeclaration(node) &&
+            ts.isIdentifier(node.name) &&
+            node.initializer &&
+            ts.isCallExpression(node.initializer) &&
+            selected.has(node.initializer) &&
+            ts.isIdentifier(node.initializer.expression) &&
+            symbol(node.initializer.expression) &&
+            hooks.has(symbol(node.initializer.expression)))
+            clients.add(symbol(node.name));
+        ts.forEachChild(node, findClients);
+    };
+    findClients(source);
+    const visit = (node) => {
+        if (ts.isCallExpression(node) &&
+            selected.has(node) &&
+            ts.isPropertyAccessExpression(node.expression) &&
+            node.expression.name.text === 'request' &&
+            ts.isIdentifier(node.expression.expression) &&
+            symbol(node.expression.expression) &&
+            clients.has(symbol(node.expression.expression))) {
+            const argument = node.arguments[0];
+            const value = argument && ts.isObjectLiteralExpression(argument)
+                ? property(argument, 'path')
+                : undefined;
+            const declaredMethod = argument && ts.isObjectLiteralExpression(argument)
+                ? property(argument, 'method')
+                : undefined;
+            const method = declaredMethod === undefined
+                ? 'GET'
+                : ts.isStringLiteralLike(declaredMethod)
+                    ? declaredMethod.text
+                    : undefined;
+            if (!method)
+                return;
+            if (value && ts.isStringLiteralLike(value))
+                paths.push({ path: value.text, method });
+            if (value && ts.isTemplateExpression(value))
+                paths.push({
+                    method,
+                    path: value.head.text +
+                        value.templateSpans
+                            .map((span) => ':dynamic' + span.literal.text)
+                            .join(''),
+                });
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    return paths;
+}
+function sameApiPath(request, endpoint) {
+    const segments = (value) => value.split('?')[0].split('/').filter(Boolean);
+    const left = segments(request), right = segments(endpoint);
+    return (left.length === right.length &&
+        left.every((part, index) => right[index]?.startsWith(':') ? part.length > 0 : part === right[index]));
+}
+function importsIn(node) {
+    const found = [];
+    const visit = (child) => {
+        if (ts.isCallExpression(child) &&
+            child.expression.kind === ts.SyntaxKind.ImportKeyword &&
+            child.arguments[0] &&
+            ts.isStringLiteralLike(child.arguments[0]))
+            found.push(child.arguments[0].text);
+        ts.forEachChild(child, visit);
+    };
+    visit(node);
+    return found;
+}
+function packageOf(specifier) {
+    return specifier
+        .split('/')
+        .slice(0, specifier.startsWith('@') ? 2 : 1)
+        .join('/');
+}
+function addProvider(providers, specifier) {
+    const name = packageOf(specifier);
+    // The server SDK also provides routing and configuration. Those generic imports do not establish use of jobs,
+    // queues, secrets or caching merely because the SDK as a whole provides operational facilities.
+    if (name === '@nocobase/app-server' &&
+        !/^@nocobase\/app-server\/(?:jobs|queue|secrets|caching)(?:\/|$)/.test(specifier))
+        return;
+    providers.add(name);
+}
+function isLocal(specifier) {
+    return (specifier.startsWith('.') ||
+        specifier.startsWith('#') ||
+        specifier.startsWith('/'));
+}
+function inside(root, file) {
+    const relative = path.relative(root, file);
+    return (relative !== '..' &&
+        !relative.startsWith(`..${path.sep}`) &&
+        !path.isAbsolute(relative));
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function targets(value) {
+    if (typeof value === 'string')
+        return [value];
+    if (!isRecord(value))
+        return [];
+    return [value.development, value.import, value.default].flatMap((item) => targets(item));
+}
+//# sourceMappingURL=module-sources.js.map