@relevate/katachi 0.1.0

package/dist/core/build.js

@@ -0,0 +1,107 @@
+import { mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseTemplateFile } from "./parser.js";
+import { outputTargets } from "../targets/index.js";
+/**
+ * Recursively finds all Katachi template files.
+ */
+function collectTemplateFiles(directory) {
+    const entries = readdirSync(directory, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = resolve(directory, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...collectTemplateFiles(fullPath));
+            continue;
+        }
+        if (entry.isFile() && entry.name.endsWith(".template.tsx")) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function toRelativeModulePath(fromRelativePath, toRelativePathWithoutExtension) {
+    const fromDir = dirname(fromRelativePath);
+    const relativePath = relative(fromDir, toRelativePathWithoutExtension).replaceAll("\\", "/");
+    if (!relativePath || !relativePath.startsWith(".")) {
+        return `./${relativePath}`;
+    }
+    return relativePath;
+}
+function toRelativeIncludePath(fromRelativePath, importedRelativePath) {
+    const fromDir = dirname(fromRelativePath);
+    const includeTarget = join("includes", dirname(importedRelativePath), `${basename(importedRelativePath).replace(/\.template\.tsx$/, "")}.html`);
+    const relativePath = relative(fromDir, includeTarget).replaceAll("\\", "/");
+    if (!relativePath || !relativePath.startsWith(".")) {
+        return `./${relativePath}`;
+    }
+    return relativePath;
+}
+/**
+ * Builds the current project and writes all configured outputs to `dist/`.
+ */
+export function buildProject(options = {}) {
+    const projectRoot = options.projectRoot ?? process.cwd();
+    const distDir = options.distDir ?? resolve(projectRoot, "dist");
+    const templatesDir = options.templatesDir ?? resolve(projectRoot, "src/templates");
+    const logger = options.logger ?? console;
+    const writtenFiles = [];
+    mkdirSync(distDir, { recursive: true });
+    const templateFiles = collectTemplateFiles(templatesDir);
+    const parsedTemplates = templateFiles.map((filePath) => {
+        const source = readFileSync(filePath, "utf8");
+        const relativePath = relative(templatesDir, filePath);
+        const fileName = basename(relativePath).replace(/\.template\.tsx$/, "");
+        return {
+            ...parseTemplateFile(source),
+            sourcePath: filePath,
+            relativePath,
+            fileName,
+            componentRegistry: {},
+        };
+    });
+    const templateByPath = new Map(parsedTemplates.map((template) => [template.sourcePath, template]));
+    for (const template of parsedTemplates) {
+        const componentRegistry = {};
+        for (const entry of template.imports ?? []) {
+            if (!entry.source.includes(".template")) {
+                continue;
+            }
+            const importPath = entry.source.endsWith(".tsx")
+                ? entry.source
+                : `${entry.source}.tsx`;
+            const resolvedPath = resolve(dirname(template.sourcePath), importPath);
+            const importedTemplate = templateByPath.get(resolvedPath);
+            if (!importedTemplate) {
+                throw new Error(`Could not resolve imported component ${entry.localName} from ${template.sourcePath}: ${entry.source}`);
+            }
+            componentRegistry[entry.localName] = {
+                reactImport: toRelativeModulePath(template.relativePath, importedTemplate.relativePath.replace(/\.template\.tsx$/, "")),
+                include: toRelativeIncludePath(template.relativePath, importedTemplate.relativePath),
+            };
+        }
+        template.componentRegistry = componentRegistry;
+        const templateDir = dirname(template.relativePath);
+        for (const target of outputTargets) {
+            for (const output of target.emitFiles(template)) {
+                const outputPath = join(distDir, target.outputSubdir, templateDir, output.fileName);
+                mkdirSync(dirname(outputPath), { recursive: true });
+                writeFileSync(outputPath, output.content, "utf8");
+                writtenFiles.push(outputPath);
+                logger.log(`wrote ${outputPath}`);
+            }
+        }
+    }
+    return {
+        templates: parsedTemplates,
+        writtenFiles,
+    };
+}
+function isMainModule(metaUrl) {
+    const entry = process.argv[1];
+    return Boolean(entry) && resolve(entry) === fileURLToPath(metaUrl);
+}
+if (isMainModule(import.meta.url)) {
+    buildProject();
+}

package/dist/core/compiler.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Compatibility barrel for existing internal imports.
+ *
+ * New code should usually import from `./ast` or `./targets/*` directly.
+ */
+export * from "./ast.js";
+export { emitReact, emitReactComponent } from "../targets/react.js";
+export { emitStaticJsx, emitStaticJsxComponent } from "../targets/static-jsx.js";
+export { emitAskama, emitAskamaComponent, emitAskamaPartial } from "../targets/askama.js";

package/dist/core/compiler.js

@@ -0,0 +1,9 @@
+/**
+ * Compatibility barrel for existing internal imports.
+ *
+ * New code should usually import from `./ast` or `./targets/*` directly.
+ */
+export * from "./ast.js";
+export { emitReact, emitReactComponent } from "../targets/react.js";
+export { emitStaticJsx, emitStaticJsxComponent } from "../targets/static-jsx.js";
+export { emitAskama, emitAskamaComponent, emitAskamaPartial } from "../targets/askama.js";

package/dist/core/example-fixtures.d.ts

@@ -0,0 +1,5 @@
+import type { Fixture } from "./verify.js";
+export declare function resolveExampleRoot(exampleName?: string): string;
+export declare function createExampleFixtures(exampleRoot: string, distDir?: string): Fixture[];
+export declare const basicExampleRoot: string;
+export declare const exampleFixtures: Fixture[];

package/dist/core/example-fixtures.js

@@ -0,0 +1,54 @@
+import { fileURLToPath } from "node:url";
+import { resolve } from "node:path";
+const rootDir = fileURLToPath(new URL("../..", import.meta.url));
+export function resolveExampleRoot(exampleName = "basic") {
+    return resolve(rootDir, "examples", exampleName);
+}
+export function createExampleFixtures(exampleRoot, distDir = resolve(exampleRoot, "dist")) {
+    const componentsDir = resolve(exampleRoot, "components");
+    const askamaIncludesDir = resolve(distDir, "askama", "includes");
+    return [
+        {
+            name: "examples/basic/badge-chip",
+            source: resolve(componentsDir, "badge-chip.html"),
+            generated: resolve(askamaIncludesDir, "badge-chip.html"),
+        },
+        {
+            name: "examples/basic/comparison-table",
+            source: resolve(componentsDir, "comparison-table.html"),
+            generated: resolve(askamaIncludesDir, "comparison-table.html"),
+        },
+        {
+            name: "examples/basic/glyph",
+            source: resolve(componentsDir, "glyph.html"),
+            generated: resolve(askamaIncludesDir, "glyph.html"),
+        },
+        {
+            name: "examples/basic/hover-note",
+            source: resolve(componentsDir, "hover-note.html"),
+            generated: resolve(askamaIncludesDir, "hover-note.html"),
+        },
+        {
+            name: "examples/basic/media-frame",
+            source: resolve(componentsDir, "media-frame.html"),
+            generated: resolve(askamaIncludesDir, "media-frame.html"),
+        },
+        {
+            name: "examples/basic/notice-panel",
+            source: resolve(componentsDir, "notice-panel.html"),
+            generated: resolve(askamaIncludesDir, "notice-panel.html"),
+        },
+        {
+            name: "examples/basic/resource-tile",
+            source: resolve(componentsDir, "resource-tile.html"),
+            generated: resolve(askamaIncludesDir, "resource-tile.html"),
+        },
+        {
+            name: "examples/basic/stack-shell",
+            source: resolve(componentsDir, "stack-shell.html"),
+            generated: resolve(askamaIncludesDir, "stack-shell.html"),
+        },
+    ];
+}
+export const basicExampleRoot = resolveExampleRoot();
+export const exampleFixtures = createExampleFixtures(basicExampleRoot);

package/dist/core/parser.d.ts

@@ -0,0 +1,5 @@
+import type { ParsedTemplate } from "./types.js";
+/**
+ * Parses a template module into the portable compiler representation.
+ */
+export declare function parseTemplateFile(source: string): ParsedTemplate;