@hyperfrontend/project-scope 0.2.0 → 0.2.2

package/nx/index.d.ts

@@ -1,4 +1,279 @@
-export * from './detect';
-export * from './devkit-loader';
-export * from './project-config';
-//# sourceMappingURL=index.d.ts.map
+/**
+ * Files indicating NX workspace root.
+ */
+declare const NX_CONFIG_FILES: readonly ["nx.json", "workspace.json"];
+/**
+ * NX-specific project file.
+ */
+declare const NX_PROJECT_FILE = "project.json";
+/**
+ * NX workspace layout configuration.
+ */
+interface NxWorkspaceLayout {
+    /** Applications directory (default: 'apps') */
+    appsDir: string;
+    /** Libraries directory (default: 'libs') */
+    libsDir: string;
+}
+/**
+ * nx.json configuration structure.
+ */
+interface NxJson {
+    /** Default project */
+    defaultProject?: string;
+    /** Workspace layout */
+    workspaceLayout?: Partial<NxWorkspaceLayout>;
+    /** Named inputs for caching */
+    namedInputs?: Record<string, unknown>;
+    /** Target defaults */
+    targetDefaults?: Record<string, unknown>;
+    /** NX Cloud access token */
+    nxCloudAccessToken?: string;
+    /** Plugins configuration */
+    plugins?: unknown[];
+    /** Task runner options */
+    tasksRunnerOptions?: Record<string, unknown>;
+    /** Default base */
+    defaultBase?: string;
+    /** Additional properties */
+    [key: string]: unknown;
+}
+/**
+ * NX workspace information.
+ */
+interface NxWorkspaceInfo {
+    /** Workspace root path */
+    root: string;
+    /** NX version from package.json */
+    version: string | null;
+    /** Parsed nx.json */
+    nxJson: NxJson;
+    /** Whether this is an integrated repo (vs standalone) */
+    isIntegrated: boolean;
+    /** Default project name */
+    defaultProject?: string;
+    /** Workspace layout configuration */
+    workspaceLayout: NxWorkspaceLayout;
+}
+/**
+ * Check if directory is an NX workspace root.
+ *
+ * @param path - Directory path to check
+ * @returns True if the directory contains nx.json or workspace.json
+ *
+ * @example Checking for NX workspace
+ * ```typescript
+ * import { isNxWorkspace } from '@hyperfrontend/project-scope'
+ *
+ * if (isNxWorkspace('./my-project')) {
+ *   console.log('This is an NX monorepo')
+ * }
+ * ```
+ */
+declare function isNxWorkspace(path: string): boolean;
+/**
+ * Check if directory is an NX project.
+ *
+ * @param path - Directory path to check
+ * @returns True if the directory contains project.json
+ *
+ * @example Checking for NX project
+ * ```typescript
+ * import { isNxProject } from '@hyperfrontend/project-scope'
+ *
+ * if (isNxProject('./libs/my-lib')) {
+ *   console.log('This is an NX project')
+ * }
+ * ```
+ */
+declare function isNxProject(path: string): boolean;
+/**
+ * Find NX workspace root from any path.
+ *
+ * @param startPath - Starting path to search from
+ * @returns Workspace root path or null if not found
+ *
+ * @example Finding NX workspace root
+ * ```typescript
+ * import { findNxWorkspaceRoot } from '@hyperfrontend/project-scope'
+ *
+ * const root = findNxWorkspaceRoot('./libs/my-lib/src')
+ * if (root) {
+ *   console.log('Workspace root:', root) // e.g., '/home/user/my-monorepo'
+ * }
+ * ```
+ */
+declare function findNxWorkspaceRoot(startPath: string): string | null;
+/**
+ * Get comprehensive NX workspace information.
+ *
+ * @param workspacePath - Workspace root path
+ * @returns Workspace info or null if not an NX workspace
+ *
+ * @example Getting NX workspace information
+ * ```typescript
+ * import { getNxWorkspaceInfo } from '@hyperfrontend/project-scope'
+ *
+ * const info = getNxWorkspaceInfo('/path/to/monorepo')
+ * if (info) {
+ *   console.log('NX version:', info.version)
+ *   console.log('Apps dir:', info.workspaceLayout.appsDir)
+ * }
+ * ```
+ */
+declare function getNxWorkspaceInfo(workspacePath: string): NxWorkspaceInfo | null;
+
+/**
+ * Object form of an entry in `targets[*].dependsOn`: a target name plus the
+ * project(s) it should be looked up in.
+ */
+interface NxTargetDependency {
+    /** Target name to depend on */
+    target: string;
+    /** Project(s) containing the target */
+    projects: string | string[];
+}
+/**
+ * NX target configuration.
+ */
+interface NxTargetConfig {
+    /** Executor to run */
+    executor?: string;
+    /** Target outputs */
+    outputs?: string[];
+    /** Target options */
+    options?: Record<string, unknown>;
+    /** Target configurations */
+    configurations?: Record<string, Record<string, unknown>>;
+    /** Default configuration */
+    defaultConfiguration?: string;
+    /** Depends on other targets */
+    dependsOn?: Array<string | NxTargetDependency>;
+    /** Target inputs for caching */
+    inputs?: unknown[];
+}
+/**
+ * NX project configuration from project.json.
+ */
+interface NxProjectConfig {
+    /** Project name */
+    name?: string;
+    /** Project root path (relative to workspace root) */
+    root?: string;
+    /** Source root path */
+    sourceRoot?: string;
+    /** Project type */
+    projectType?: 'application' | 'library';
+    /** Project tags for filtering */
+    tags?: string[];
+    /** Implicit dependencies */
+    implicitDependencies?: string[];
+    /** Named inputs for caching */
+    namedInputs?: Record<string, unknown[]>;
+    /** Build targets */
+    targets?: Record<string, NxTargetConfig>;
+    /** Generator defaults */
+    generators?: Record<string, unknown>;
+    /** Additional properties */
+    [key: string]: unknown;
+}
+/**
+ * Simplified project graph node.
+ */
+interface NxProjectGraphNode {
+    /** Project name */
+    name: string;
+    /** Project type */
+    type: string;
+    /** Project configuration */
+    data: NxProjectConfig;
+}
+/**
+ * Simplified project dependency.
+ */
+interface NxProjectDependency {
+    /** Target project name */
+    target: string;
+    /** Dependency type */
+    type: 'implicit' | 'explicit' | 'static';
+}
+/**
+ * Simplified project graph.
+ */
+interface NxProjectGraph {
+    /** Project nodes */
+    nodes: Record<string, NxProjectGraphNode>;
+    /** Project dependencies */
+    dependencies: Record<string, NxProjectDependency[]>;
+}
+/**
+ * Read project.json for an NX project.
+ *
+ * @param projectPath - Project directory path
+ * @returns Parsed project.json or null if not found
+ *
+ * @example Reading NX project.json
+ * ```typescript
+ * import { readProjectJson } from '@hyperfrontend/project-scope'
+ *
+ * const config = readProjectJson('./libs/my-lib')
+ * if (config) {
+ *   console.log('Project:', config.name, 'Type:', config.projectType)
+ * }
+ * ```
+ */
+declare function readProjectJson(projectPath: string): NxProjectConfig | null;
+/**
+ * Get project configuration from project.json or package.json nx field.
+ *
+ * @param projectPath - Project directory path
+ * @param workspacePath - Workspace root path (for relative path calculation)
+ * @returns Project configuration or null if not found
+ *
+ * @example Getting project configuration
+ * ```typescript
+ * import { getProjectConfig } from '@hyperfrontend/project-scope'
+ *
+ * const config = getProjectConfig('./libs/my-lib', '/workspace')
+ * // => { name: 'my-lib', root: 'libs/my-lib', projectType: 'library' }
+ * ```
+ */
+declare function getProjectConfig(projectPath: string, workspacePath: string): NxProjectConfig | null;
+/**
+ * Discover all NX projects in workspace.
+ * Supports both workspace.json (older format) and project.json (newer format).
+ *
+ * @param workspacePath - Workspace root path
+ * @returns Map of project name to configuration
+ *
+ * @example Discovering all NX projects
+ * ```typescript
+ * import { discoverNxProjects } from '@hyperfrontend/project-scope'
+ *
+ * const projects = discoverNxProjects('/workspace')
+ * for (const [name, config] of projects) {
+ *   console.log(`${name}: ${config.projectType} at ${config.root}`)
+ * }
+ * ```
+ */
+declare function discoverNxProjects(workspacePath: string): Map<string, NxProjectConfig>;
+/**
+ * Build a simple project graph from discovered projects.
+ *
+ * @param workspacePath - Workspace root path
+ * @param projects - Existing configuration map to skip auto-discovery
+ * @returns NxProjectGraph with nodes and dependencies
+ *
+ * @example Building a simple project graph
+ * ```typescript
+ * import { buildSimpleProjectGraph } from '@hyperfrontend/project-scope'
+ *
+ * const graph = buildSimpleProjectGraph('/workspace')
+ * console.log('Projects:', Object.keys(graph.nodes))
+ * console.log('Dependencies:', graph.dependencies['my-app'])
+ * ```
+ */
+declare function buildSimpleProjectGraph(workspacePath: string, projects?: Map<string, NxProjectConfig>): NxProjectGraph;
+
+export { NX_CONFIG_FILES, NX_PROJECT_FILE, buildSimpleProjectGraph, discoverNxProjects, findNxWorkspaceRoot, getNxWorkspaceInfo, getProjectConfig, isNxProject, isNxWorkspace, readProjectJson };
+export type { NxJson, NxProjectConfig, NxProjectDependency, NxProjectGraph, NxProjectGraphNode, NxTargetConfig, NxWorkspaceInfo, NxWorkspaceLayout };

package/nx/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../libs/project-scope/src/nx/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,iBAAiB,CAAA;AAC/B,cAAc,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../libs/project-scope/src/nx/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,YAAY,EAAE,MAAM,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAC1E,YAAY,EAAE,eAAe,EAAE,mBAAmB,EAAE,cAAc,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAChI,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,WAAW,EAAE,aAAa,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAChI,OAAO,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA"}