@xyd-js/sources 0.0.0-build

package/packages/ts/__fixtures__/references-output.json

@@ -0,0 +1,129 @@
+[
+  {
+    "title": "Interface Props",
+    "canonical": "@xyd-sources-examples/react/interfaces/Props",
+    "description": "The props type for \nTestBasicComponent\n.\n",
+    "context": {
+      "symbolId": "4",
+      "symbolName": "Props",
+      "symbolKind": 256,
+      "packageName": "@xyd-sources-examples/react",
+      "fileName": "TestBasic.tsx",
+      "fileFullPath": "src/TestBasic.tsx",
+      "line": 6,
+      "col": 17,
+      "signatureText": {
+        "code": "export interface Props extends PropsWithChildren {\n}",
+        "lang": "ts"
+      },
+      "sourcecode": {
+        "code": "export interface Props extends PropsWithChildren {\n    /** The name of the person. */\n    name: string\n\n    /** The age of the person. */\n    age: number\n\n    /** Whether the person is active. */\n    isActive: boolean\n\n    /** The date the person was created. */\n    createdAt: Date\n}",
+        "lang": "ts"
+      },
+      "group": [
+        "@xyd-sources-examples",
+        "react",
+        "Interfaces"
+      ]
+    },
+    "examples": {
+      "groups": []
+    },
+    "definitions": [
+      {
+        "title": "Properties",
+        "properties": [
+          {
+            "name": "name",
+            "type": "string",
+            "description": "The name of the person.\n"
+          },
+          {
+            "name": "age",
+            "type": "number",
+            "description": "The age of the person.\n"
+          },
+          {
+            "name": "isActive",
+            "type": "boolean",
+            "description": "Whether the person is active.\n"
+          },
+          {
+            "name": "createdAt",
+            "type": "Date",
+            "description": "The date the person was created.\n"
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "title": "Function TestBasicComponent",
+    "canonical": "@xyd-sources-examples/react/functions/TestBasicComponent",
+    "description": "TestBasicComponent is a React component that uses a basic props type.\n",
+    "context": {
+      "symbolId": "1",
+      "symbolName": "TestBasicComponent",
+      "symbolKind": 64,
+      "packageName": "@xyd-sources-examples/react",
+      "fileName": "TestBasic.tsx",
+      "fileFullPath": "src/TestBasic.tsx",
+      "line": 25,
+      "col": 16,
+      "signatureText": {
+        "code": "export function TestBasicComponent(props: Props): ReactElement;",
+        "lang": "ts"
+      },
+      "sourcecode": {
+        "code": "export function TestBasicComponent(props: Props): ReactElement {\n    return <div>{props.children}</div>;\n}",
+        "lang": "ts"
+      },
+      "category": "Component",
+      "group": [
+        "@xyd-sources-examples",
+        "react",
+        "Component"
+      ]
+    },
+    "examples": {
+      "groups": []
+    },
+    "definitions": [
+      {
+        "title": "Returns",
+        "properties": [
+          {
+            "name": "",
+            "type": "React.ReactElement",
+            "description": ""
+          }
+        ],
+        "meta": [
+          {
+            "name": "type",
+            "value": "returns"
+          }
+        ]
+      },
+      {
+        "title": "Parameters",
+        "properties": [
+          {
+            "name": "props",
+            "type": "Props",
+            "description": "",
+            "symbolDef": {
+              "id": "4"
+            }
+          }
+        ],
+        "meta": [
+          {
+            "name": "type",
+            "value": "parameters"
+          }
+        ]
+      }
+    ]
+  }
+]

package/packages/ts/__tests__/sourcesToUniform.test.ts

@@ -0,0 +1,106 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { SignatureTextLoader, MultiSignatureLoader } from '../SignatureText';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { sourcesToUniformV2 } from '..';
+import { uniformToReactUniform } from '../../react/uniformToReactUniform';
+import { TypeDocReferenceContext } from '@xyd-js/uniform';
+import { Reference } from '@xyd-js/uniform';
+
+describe('SignatureText TODO', () => {
+    it("TODO", async () => {
+        expect(true).toBe(true)
+    })
+})
+
+// describe('SignatureText', () => {
+//     const fixturesBasePath = path.resolve(__dirname, "../__fixtures__")
+
+//     const testFilePath = path.join(fixturesBasePath, 'test-file.ts');
+//     const outputFilePath = path.join(fixturesBasePath, 'references-output.json');
+//     const outputFilePathReact = path.join(fixturesBasePath, 'references-output-react.json');
+//     const outputFilePathProject = path.join(fixturesBasePath, 'references-output-project.json');
+
+//     // Create a temporary test file
+//     beforeAll(() => {
+//         const testContent = `
+// export class TestClass {
+//   constructor() {}
+  
+//   public testMethod(param: string): void {
+//     console.log(param);
+//   }
+// }
+// `;
+//         fs.writeFileSync(testFilePath, testContent);
+//     });
+
+//     // Clean up after tests
+//     afterAll(() => {
+//         if (fs.existsSync(testFilePath)) {
+//             fs.unlinkSync(testFilePath);
+//         }
+//     });
+
+//     describe('sourcesToUniform', () => {
+//         expect(true).toBe(true)
+//         // TODO: finish
+//         return
+//         // it('should return a reference to the test class', async () => {
+//         //     const basePath = path.resolve(fixturesBasePath, "packages2")
+
+//         //     const references = await sourcesToUniformV2(basePath,
+//         //         [
+//         //             path.resolve(basePath, "package-a"),
+//         //             // path.resolve(basePath, "package-b"),
+//         //         ]
+//         //     );
+
+//         //     fs.writeFileSync(outputFilePath, JSON.stringify(references, null, 2));
+//         //     // Save references to a file for inspection
+//         //     console.log(`References saved to: ${outputFilePath}`);
+//         // });
+
+//         it('should return a reference to react component', async () => {
+//             const packagePath = path.resolve(fixturesBasePath, "react/react-a")
+
+//             const resp = await sourcesToUniformV2(packagePath,
+//                 [
+//                     "src/TestBasic.tsx",
+//                 ]
+//             );
+//             if (!resp || !resp.references || !resp.projectJson) {
+//                 throw new Error("Failed to generate documentation.")
+//             }
+
+//             const references = resp.references as Reference<TypeDocReferenceContext>[]
+//             const reactUniform = uniformToReactUniform(references, resp.projectJson)
+
+//             fs.writeFileSync(outputFilePath, JSON.stringify(resp?.references, null, 2));
+//             fs.writeFileSync(outputFilePathProject, JSON.stringify(resp?.projectJson, null, 2));
+
+//             fs.writeFileSync(outputFilePathReact, JSON.stringify(reactUniform, null, 2));
+
+//             // Save references to a file for inspection
+//             console.log(`References saved to: ${outputFilePath}`);
+//             console.log(`React Uniform saved to: ${outputFilePathReact}`);
+//         });
+
+//         it('should return a reference to react component', async () => {
+//             expect(true).toBe(true)
+//                     // TODO: finish
+//             return
+//             const packagePath = path.resolve(fixturesBasePath, "packages3")
+
+//             const resp = await sourcesToUniformV2(packagePath,
+//                 [
+//                     path.join(packagePath, "package-a"),
+//                 ]
+//             );
+
+//             fs.writeFileSync(outputFilePath, JSON.stringify(resp?.references, null, 2));
+//             fs.writeFileSync(outputFilePathProject, JSON.stringify(resp?.projectJson, null, 2));
+//         });
+//     });
+
+// }); 

package/packages/ts/index.ts

@@ -0,0 +1,129 @@
+import * as path from 'node:path';
+import {resolve} from "path";
+import ts from "typescript";
+
+import * as TypeDoc from 'typedoc';
+import type {NormalizedPath, TypeDocOptions} from "typedoc";
+
+import type {Reference, ReferenceContext} from "@xyd-js/uniform";
+import {
+    typedocToUniform
+} from "./TypeDocTransformer"
+
+export {
+    uniformToMiniUniform
+} from "./uniformToMiniUniform"
+
+const importedFiles = new Set<string>();
+
+// TODO: SUPPORT GET FROM URL + VIRTUAL FS (OR NO FS JUST SET NEEDED OPTIONS VIA CODE)
+// TODO: in the future typedoc options?
+export async function sourcesToUniformV2(
+    root: string,
+    entryPoints: string[]
+): Promise<{
+    references: Reference<ReferenceContext>[];
+    projectJson: TypeDoc.JSONOutput.ProjectReflection;
+} | undefined> {
+    // TODO: support another strategies
+    // TODO: support entry points from github?
+    const commonOptions: Partial<TypeDocOptions> = {
+        // entryPoints,
+        // entryPointStrategy: TypeDoc.EntryPointStrategy.Packages,
+        exclude: ["**/*.test.ts", "**/*.test.tsx"],
+        // @ts-ignore // TODO: for some reason on build types mismatch
+        excludePrivate: true,
+        // @ts-ignore
+        excludeProtected: true,
+        // @ts-ignore
+        excludeExternals: true,
+        // @ts-ignore
+        includeVersion: true,
+        // @ts-ignore
+        // hideGenerator: true,
+        // @ts-ignore
+        skipErrorChecking: true,
+
+        // @ts-ignore
+        sort: ['source-order'],
+        // @ts-ignore
+        sortEntryPoints: false,
+    }
+
+    const options = {
+        ...commonOptions,
+    }
+    const everySingleFile = entryPoints?.every(ep => !!path.extname(ep))
+
+    if (everySingleFile) {
+        entryPoints.map(ep => {
+            findImports(root, path.resolve(root, ep));
+        })
+        const fileImported = Array.from(importedFiles) || []
+        options.entryPoints = [
+            ...[
+                ...entryPoints,
+                ...fileImported
+            ]?.map(ep => path.resolve(root, ep))
+        ]
+    } else {
+        options.entryPointStrategy = TypeDoc.EntryPointStrategy.Packages
+        options.entryPoints = entryPoints
+        options.packageOptions = {
+            ...commonOptions,
+        }
+    }
+
+    // TOOD: if react will not work then add []
+    const app = await TypeDoc.Application.bootstrapWithPlugins(options);
+    const project = await app.convert()
+    if (!project) {
+        console.error('Failed to generate documentation.');
+        return
+    }
+
+    const jsonOutput = await app.serializer.projectToObject(project, root as NormalizedPath);
+    const projectJson = jsonOutput as unknown as TypeDoc.JSONOutput.ProjectReflection;
+
+    if (!projectJson.schemaVersion || !projectJson.children || !projectJson.children.length) {
+        console.error('Failed to generate documentation.');
+        return
+    }
+
+    const references = typedocToUniform(root, projectJson)
+    if (!references) {
+        console.error('Failed to generate documentation.');
+        return
+    }
+    return {
+        references,
+        projectJson
+    }
+}
+
+// TODO: nested strategy
+// TODO: better mechanism?
+function findImports(root: string, file: string, seen = new Set()) {
+    if (seen.has(file)) return;
+    seen.add(file);
+
+    const source = ts.createSourceFile(
+        file,
+        ts.sys.readFile(file) || "",
+        ts.ScriptTarget.Latest,
+        true
+    );
+
+    for (const stmt of source.statements) {
+        if (ts.isImportDeclaration(stmt) && stmt.moduleSpecifier) {
+            const importPath = stmt.moduleSpecifier.getText().replace(/['"]/g, "");
+            if (importPath.startsWith(".")) {
+                const resolved = resolve(file, "..", importPath + ".ts"); // TODO: support .tsx also + aliases
+                const relativePath = path.relative(root, resolved);
+                importedFiles.add(relativePath);
+                findImports(root, resolved, seen);
+            }
+        }
+    }
+}
+