@living-architecture/riviere-extract-ts 0.1.2 → 0.1.4

package/dist/extractor.d.ts

@@ -1,3 +1,4 @@
+import type { Project } from 'ts-morph';
 import type { ExtractionConfig, ComponentType } from '@living-architecture/riviere-extract-config';
 export interface DraftComponent {
     type: ComponentType;
@@ -8,5 +9,5 @@ export interface DraftComponent {
     };
     domain: string;
 }
-export declare function extractComponents(_sourceFilePaths: string[], _config: ExtractionConfig): DraftComponent[];
+export declare function extractComponents(project: Project, sourceFilePaths: string[], config: ExtractionConfig): DraftComponent[];
 //# sourceMappingURL=extractor.d.ts.map

package/dist/extractor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extractor.d.ts","sourceRoot":"","sources":["../src/extractor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAAE,aAAa,EAChC,MAAM,6CAA6C,CAAA;AAEpD,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,aAAa,CAAA;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAA;QACZ,IAAI,EAAE,MAAM,CAAA;KACb,CAAA;IACD,MAAM,EAAE,MAAM,CAAA;CACf;AAED,wBAAgB,iBAAiB,CAC/B,gBAAgB,EAAE,MAAM,EAAE,EAC1B,OAAO,EAAE,gBAAgB,GACxB,cAAc,EAAE,CAElB"}
+{"version":3,"file":"extractor.d.ts","sourceRoot":"","sources":["../src/extractor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,OAAO,EAER,MAAM,UAAU,CAAA;AAEjB,OAAO,KAAK,EACV,gBAAgB,EAChB,aAAa,EAGd,MAAM,6CAA6C,CAAA;AAGpD,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,aAAa,CAAA;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAA;QACZ,IAAI,EAAE,MAAM,CAAA;KACb,CAAA;IACD,MAAM,EAAE,MAAM,CAAA;CACf;AA4BD,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,OAAO,EAChB,eAAe,EAAE,MAAM,EAAE,EACzB,MAAM,EAAE,gBAAgB,GACvB,cAAc,EAAE,CAElB"}

package/dist/extractor.js

@@ -1,3 +1,130 @@
-export function extractComponents(_sourceFilePaths, _config) {
+import { minimatch } from 'minimatch';
+import { evaluatePredicate } from './predicates';
+const COMPONENT_TYPES = [
+    'api',
+    'useCase',
+    'domainOp',
+    'event',
+    'eventHandler',
+    'ui',
+];
+const FIND_TARGETS = ['classes', 'methods', 'functions'];
+function hasProperty(obj, key) {
+    return key in obj;
+}
+function isDetectionRule(rule) {
+    /* istanbul ignore if -- @preserve: unreachable with typed ExtractionConfig; defensive guard */
+    if (typeof rule !== 'object' || rule === null) {
+        return false;
+    }
+    if (!hasProperty(rule, 'find') || !hasProperty(rule, 'where')) {
+        return false;
+    }
+    return typeof rule.find === 'string' && FIND_TARGETS.includes(rule.find);
+}
+export function extractComponents(project, sourceFilePaths, config) {
+    return sourceFilePaths.flatMap((filePath) => extractFromFile(project, filePath, config));
+}
+function extractFromFile(project, filePath, config) {
+    const sourceFile = project.getSourceFile(filePath);
+    if (sourceFile === undefined) {
+        return [];
+    }
+    const matchingModule = findMatchingModule(filePath, config.modules);
+    if (matchingModule === undefined) {
+        return [];
+    }
+    return extractFromModule(sourceFile, filePath, matchingModule);
+}
+function extractFromModule(sourceFile, filePath, module) {
+    return COMPONENT_TYPES.flatMap((componentType) => extractComponentType(sourceFile, filePath, module, componentType));
+}
+function extractComponentType(sourceFile, filePath, module, componentType) {
+    const rule = module[componentType];
+    if (!isDetectionRule(rule)) {
+        return [];
+    }
+    if (rule.find === 'classes') {
+        return extractClasses(sourceFile, filePath, module.name, componentType, rule);
+    }
+    if (rule.find === 'methods') {
+        return extractMethods(sourceFile, filePath, module.name, componentType, rule);
+    }
+    /* istanbul ignore else -- @preserve: false branch is unreachable; FindTarget is exhaustive */
+    if (rule.find === 'functions') {
+        return extractFunctions(sourceFile, filePath, module.name, componentType, rule);
+    }
+    /* istanbul ignore next -- @preserve: unreachable with valid FindTarget type; defensive fallback */
     return [];
 }
+function extractClasses(sourceFile, filePath, domain, componentType, rule) {
+    return sourceFile
+        .getClasses()
+        .filter((c) => evaluatePredicate(c, rule.where))
+        .flatMap((c) => createClassComponent(c, filePath, domain, componentType));
+}
+function extractMethods(sourceFile, filePath, domain, componentType, rule) {
+    return sourceFile
+        .getClasses()
+        .flatMap((c) => c.getMethods())
+        .filter((m) => evaluatePredicate(m, rule.where))
+        .flatMap((m) => createMethodComponent(m, filePath, domain, componentType));
+}
+function extractFunctions(sourceFile, filePath, domain, componentType, rule) {
+    return sourceFile
+        .getFunctions()
+        .filter((f) => evaluatePredicate(f, rule.where))
+        .flatMap((f) => createFunctionComponent(f, filePath, domain, componentType));
+}
+function createClassComponent(classDecl, filePath, domain, componentType) {
+    const name = classDecl.getName();
+    if (name === undefined) {
+        return [];
+    }
+    return [
+        {
+            type: componentType,
+            name,
+            location: {
+                file: filePath,
+                line: classDecl.getStartLineNumber(),
+            },
+            domain,
+        },
+    ];
+}
+function createMethodComponent(method, filePath, domain, componentType) {
+    const name = method.getName();
+    return [
+        {
+            type: componentType,
+            name,
+            location: {
+                file: filePath,
+                line: method.getStartLineNumber(),
+            },
+            domain,
+        },
+    ];
+}
+function createFunctionComponent(func, filePath, domain, componentType) {
+    const name = func.getName();
+    if (name === undefined) {
+        return [];
+    }
+    return [
+        {
+            type: componentType,
+            name,
+            location: {
+                file: filePath,
+                line: func.getStartLineNumber(),
+            },
+            domain,
+        },
+    ];
+}
+function findMatchingModule(filePath, modules) {
+    const normalized = filePath.replaceAll(/\\+/g, '/');
+    return modules.find((m) => minimatch(normalized, m.path));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@living-architecture/riviere-extract-ts",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -22,7 +22,8 @@
     "!**/*.tsbuildinfo"
   ],
   "dependencies": {
+    "minimatch": "^10.0.1",
     "ts-morph": "^24.0.0",
-    "@living-architecture/riviere-extract-config": "0.1.6"
+    "@living-architecture/riviere-extract-config": "0.1.8"
   }
 }

package/dist/test-fixtures.d.ts

@@ -1,3 +0,0 @@
-import type { ExtractionConfig } from '@living-architecture/riviere-extract-config';
-export declare function createMinimalConfig(): ExtractionConfig;
-//# sourceMappingURL=test-fixtures.d.ts.map

package/dist/test-fixtures.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"test-fixtures.d.ts","sourceRoot":"","sources":["../src/test-fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6CAA6C,CAAA;AAEnF,wBAAgB,mBAAmB,IAAI,gBAAgB,CActD"}

package/dist/test-fixtures.js

@@ -1,15 +0,0 @@
-export function createMinimalConfig() {
-    return {
-        modules: [
-            {
-                path: '**/*.ts',
-                api: { notUsed: true },
-                useCase: { notUsed: true },
-                domainOp: { notUsed: true },
-                event: { notUsed: true },
-                eventHandler: { notUsed: true },
-                ui: { notUsed: true },
-            },
-        ],
-    };
-}