@mxpicture/gcp-functions-code 0.2.0

package/dist/changelog/ChangeDetector.d.ts

@@ -0,0 +1,25 @@
+import { DocumentData } from "@mxpicture/gcp-functions-common/types";
+import { GitChangesCommit } from "../git/GitChanges.js";
+import { Changelog } from "./Changelog.js";
+import { PackageVersion } from "./changelog.util.js";
+export declare enum ChangeWatchType {
+    changelog = "changelog",
+    gitHistory = "gitHistory"
+}
+export interface ChangeWatch {
+    pattern: string;
+    type: ChangeWatchType;
+}
+export type ChangeEventHandler<T extends DocumentData> = (paths: string[], watch: ChangeWatch) => Promise<T | null>;
+export interface ChangeWatchHandler<T extends DocumentData> extends ChangeWatch {
+    handler: ChangeEventHandler<T>;
+}
+export declare class ChangeDetector<T extends DocumentData> {
+    protected readonly log: Changelog;
+    protected readonly git: GitChangesCommit;
+    protected readonly sinceVersion?: PackageVersion | undefined;
+    protected readonly watches: ChangeWatchHandler<T>[];
+    constructor(log: Changelog, git: GitChangesCommit, sinceVersion?: PackageVersion | undefined);
+    addWatch(...watches: ChangeWatchHandler<T>[]): void;
+    run(): Promise<T[]>;
+}

package/dist/changelog/ChangeDetector.js

@@ -0,0 +1,47 @@
+import micromatch from "micromatch";
+export var ChangeWatchType;
+(function (ChangeWatchType) {
+    ChangeWatchType["changelog"] = "changelog";
+    ChangeWatchType["gitHistory"] = "gitHistory";
+})(ChangeWatchType || (ChangeWatchType = {}));
+export class ChangeDetector {
+    log;
+    git;
+    sinceVersion;
+    watches = [];
+    constructor(log, git, sinceVersion) {
+        this.log = log;
+        this.git = git;
+        this.sinceVersion = sinceVersion;
+    }
+    addWatch(...watches) {
+        this.watches.push(...watches);
+    }
+    async run() {
+        const results = [];
+        const logEntries = await this.log.readChangelogEntries(this.sinceVersion);
+        const gitEntries = (await this.git.readChangedFiles()).files;
+        for (const watch of this.watches) {
+            if (watch.type === ChangeWatchType.changelog) {
+                const paths = [];
+                for (const logEntry of logEntries)
+                    for (const file of logEntry.changedFiles)
+                        if (micromatch.isMatch(file, watch.pattern))
+                            paths.push(file);
+                if (paths.length > 0)
+                    results.push(watch.handler(paths, watch));
+                continue;
+            }
+            if (watch.type === ChangeWatchType.gitHistory) {
+                const paths = [];
+                for (const gitEntry of gitEntries)
+                    if (micromatch.isMatch(gitEntry.repoFilePath, watch.pattern))
+                        paths.push(gitEntry.repoFilePath);
+                if (paths.length > 0)
+                    results.push(watch.handler(paths, watch));
+                continue;
+            }
+        }
+        return (await Promise.all(results)).filter((r) => r !== null);
+    }
+}

package/dist/changelog/Changelog.d.ts

@@ -0,0 +1,15 @@
+import { GitChanges } from "../git/GitChanges.js";
+import { ChangelogEntry, PackageVersion } from "./changelog.util.js";
+export declare class Changelog {
+    protected readonly git: GitChanges;
+    protected readonly changelogPath: string;
+    protected readonly packageJsonPath: string;
+    protected readonly rootDir: string;
+    constructor(git: GitChanges);
+    run(): Promise<ChangelogEntry | null>;
+    readChangelogEntries(sinceVersion?: PackageVersion): Promise<ChangelogEntry[]>;
+    protected condenseEntries(entries: ChangelogEntry[]): {
+        entries: ChangelogEntry[];
+        hasChanged: boolean;
+    };
+}

package/dist/changelog/Changelog.js

@@ -0,0 +1,98 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { changelogEntriesSchema, changelogEntrySchema, resolveBaselineCommit, readChangedTsFiles, mapChangedPackages, mapAffectedPackages, readMinPackageVersion, splitVersion, compareVersionsGT, } from "./changelog.util.js";
+import pkg from "json5";
+import { fileURLToPath } from "node:url";
+import { lastCommitHash } from "../git/git.util.js";
+import { formatJson2Spaces } from "../common/code.common.js";
+const changelogLimit = 10;
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export class Changelog {
+    git;
+    changelogPath;
+    packageJsonPath;
+    rootDir;
+    constructor(git) {
+        this.git = git;
+        this.changelogPath = resolve(__dirname, "../../changelog.json");
+        this.packageJsonPath = resolve(__dirname, "../../package.json");
+        this.rootDir = resolve(__dirname, "../../../..");
+    }
+    async run() {
+        const existingEntries = await this.readChangelogEntries();
+        const currentCommitHash = await lastCommitHash(this.rootDir);
+        if (!currentCommitHash)
+            throw new Error("No current git commit hash found");
+        const baselineCommit = await resolveBaselineCommit(existingEntries, this.git.rootDir, this.packageJsonPath);
+        const changedFiles = await readChangedTsFiles(baselineCommit, this.git);
+        if (changedFiles.length === 0)
+            return null;
+        const changedPackages = mapChangedPackages(changedFiles);
+        const affectedPackages = mapAffectedPackages(changedPackages);
+        const version = await readMinPackageVersion(this.rootDir);
+        if (!version)
+            throw new Error("No version found");
+        const entry = {
+            timestamp: new Date().toISOString(),
+            gitCommitHashs: [currentCommitHash],
+            version,
+            versionParts: splitVersion(version),
+            changedPackages,
+            affectedPackages,
+            changedFiles,
+        };
+        await changelogEntrySchema.parseAsync(entry);
+        const condenseResult = this.condenseEntries([entry, ...existingEntries]);
+        if (!condenseResult.hasChanged)
+            return null;
+        await changelogEntriesSchema.parseAsync(condenseResult.entries);
+        await writeFile(this.changelogPath, await formatJson2Spaces(pkg.stringify(condenseResult.entries)));
+        return entry;
+    }
+    async readChangelogEntries(sinceVersion) {
+        try {
+            const content = await readFile(this.changelogPath, "utf8");
+            const parsed = pkg.parse(content);
+            const entries = await changelogEntriesSchema.parseAsync(parsed);
+            if (!sinceVersion)
+                return entries;
+            return entries.filter((e) => compareVersionsGT(e.versionParts, sinceVersion));
+        }
+        catch {
+            return [];
+        }
+    }
+    condenseEntries(entries) {
+        const results = [];
+        let hasChanged = false;
+        for (const entry of entries) {
+            const result = results.find((result) => result.version === entry.version);
+            if (!result) {
+                results.push({ ...entry });
+                hasChanged = true;
+                continue;
+            }
+            for (const item of entry.affectedPackages)
+                if (!result.affectedPackages.includes(item)) {
+                    result.affectedPackages.push(item);
+                    hasChanged = true;
+                }
+            for (const item of entry.changedFiles)
+                if (!result.changedFiles.includes(item)) {
+                    result.changedFiles.push(item);
+                    hasChanged = true;
+                }
+            for (const item of entry.changedPackages)
+                if (!result.changedPackages.includes(item)) {
+                    result.changedPackages.push(item);
+                    hasChanged = true;
+                }
+            for (const item of entry.gitCommitHashs)
+                if (!result.gitCommitHashs.includes(item)) {
+                    result.gitCommitHashs.unshift(item);
+                    hasChanged = true;
+                }
+        }
+        return { entries: results.splice(0, changelogLimit), hasChanged };
+    }
+}

package/dist/changelog/changelog.util.d.ts

@@ -0,0 +1,94 @@
+import { z } from "zod";
+import { GitChanges } from "../git/GitChanges.js";
+export type ProcessMode = "fix" | "restore";
+export interface PackageVersion {
+    major: number;
+    minor: number | null;
+    patch: number | null;
+    prefix: string | null;
+}
+export declare const packageVersionSchema: z.ZodObject<{
+    major: z.ZodNumber;
+    minor: z.ZodXor<readonly [z.ZodNumber, z.ZodNull]>;
+    patch: z.ZodXor<readonly [z.ZodNumber, z.ZodNull]>;
+    prefix: z.ZodXor<readonly [z.ZodString, z.ZodNull]>;
+}, z.core.$strip>;
+export interface PnpmWorkspace {
+    packages: string[];
+}
+export interface PackageJson {
+    name: string;
+    version: string;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    [key: string]: unknown;
+}
+export interface PackageEntry {
+    jsonPath: string;
+    repoPath: string;
+    wsName: string;
+    content: PackageJson;
+    modified: boolean;
+}
+export interface MapEntry {
+    fromPkg: PackageEntry;
+    toPkg: PackageEntry;
+    relPath: string;
+}
+export declare const readPackageJson: (dirOrFilepath: string) => Promise<PackageJson | null>;
+export declare const changelogPackageNames: readonly ["common", "backend", "frontend", "code"];
+export type ChangelogPackageName = (typeof changelogPackageNames)[number];
+export declare const changelogDependents: Record<ChangelogPackageName, string[]>;
+export interface ChangelogEntry {
+    version: string;
+    versionParts: PackageVersion;
+    timestamp: string;
+    gitCommitHashs: string[];
+    changedPackages: string[];
+    affectedPackages: string[];
+    changedFiles: string[];
+}
+export declare const changelogEntrySchema: z.ZodObject<{
+    version: z.ZodString;
+    versionParts: z.ZodObject<{
+        major: z.ZodNumber;
+        minor: z.ZodXor<readonly [z.ZodNumber, z.ZodNull]>;
+        patch: z.ZodXor<readonly [z.ZodNumber, z.ZodNull]>;
+        prefix: z.ZodXor<readonly [z.ZodString, z.ZodNull]>;
+    }, z.core.$strip>;
+    timestamp: z.ZodISODateTime;
+    gitCommitHashs: z.ZodArray<z.ZodString>;
+    changedPackages: z.ZodArray<z.ZodString>;
+    affectedPackages: z.ZodArray<z.ZodString>;
+    changedFiles: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const changelogEntriesSchema: z.ZodArray<z.ZodObject<{
+    version: z.ZodString;
+    versionParts: z.ZodObject<{
+        major: z.ZodNumber;
+        minor: z.ZodXor<readonly [z.ZodNumber, z.ZodNull]>;
+        patch: z.ZodXor<readonly [z.ZodNumber, z.ZodNull]>;
+        prefix: z.ZodXor<readonly [z.ZodString, z.ZodNull]>;
+    }, z.core.$strip>;
+    timestamp: z.ZodISODateTime;
+    gitCommitHashs: z.ZodArray<z.ZodString>;
+    changedPackages: z.ZodArray<z.ZodString>;
+    affectedPackages: z.ZodArray<z.ZodString>;
+    changedFiles: z.ZodArray<z.ZodString>;
+}, z.core.$strip>>;
+export declare const splitVersion: (version: string) => PackageVersion;
+export declare const concatVersion: (version: PackageVersion) => string;
+export declare const compareVersions: (a: PackageVersion | string, b: PackageVersion | string) => number;
+export declare const compareVersionsGT: (a: PackageVersion | string, b: PackageVersion | string) => boolean;
+export declare const readWorkspaceYaml: (repoRoot: string) => Promise<PnpmWorkspace>;
+export declare const readPackageJsons: (repoRoot: string) => Promise<PackageEntry[]>;
+export declare const writePackageJsons: (entries: PackageEntry[]) => Promise<void[]>;
+export declare const buildMapEntries: (pkgEntries: PackageEntry[]) => MapEntry[];
+export declare const resolveBaselineCommit: (entries: ChangelogEntry[], rootDir: string, packageJsonPath: string) => Promise<string>;
+export declare const ensureCommitRef: (ref: string, fallback: string, rootDir: string) => Promise<string>;
+export declare const readChangedTsFiles: (baselineCommit: string, git: GitChanges) => Promise<string[]>;
+export declare const mapChangedPackages: (files: string[]) => string[];
+export declare const mapAffectedPackages: (changedPackages: string[]) => string[];
+export declare const readPackageVersions: (rootDir: string) => Promise<Record<string, string>>;
+export declare const readMinPackageVersion: (rootDir: string) => Promise<string | null>;

package/dist/changelog/changelog.util.js

@@ -0,0 +1,228 @@
+import { readdir, readFile, writeFile } from "node:fs/promises";
+import { join, relative, resolve } from "node:path";
+import pkg from "json5";
+import { z } from "zod";
+import { parse } from "yaml";
+import { verifiedGit } from "../git/git.util.js";
+export const packageVersionSchema = z.object({
+    major: z.number().min(0),
+    minor: z.xor([z.number(), z.null()]),
+    patch: z.xor([z.number(), z.null()]),
+    prefix: z.xor([z.string(), z.null()]),
+});
+export const readPackageJson = async (dirOrFilepath) => {
+    try {
+        const pkgPath = dirOrFilepath.endsWith("/package.json")
+            ? dirOrFilepath
+            : join(dirOrFilepath, "package.json");
+        const content = await readFile(pkgPath, "utf8");
+        return pkg.parse(content);
+    }
+    catch {
+        return null;
+    }
+};
+// todo get dynamically
+export const changelogPackageNames = [
+    "common",
+    "backend",
+    "frontend",
+    "code",
+];
+// todo get dynamically
+export const changelogDependents = {
+    common: ["common", "backend", "frontend", "code"],
+    backend: ["backend", "code"],
+    frontend: ["frontend", "code"],
+    code: ["code"],
+};
+export const changelogEntrySchema = z.object({
+    version: z.string().min(1),
+    versionParts: packageVersionSchema,
+    timestamp: z.iso.datetime(),
+    gitCommitHashs: z.array(z.string().min(1)).min(1),
+    changedPackages: z.array(z.string()),
+    affectedPackages: z.array(z.string()),
+    changedFiles: z.array(z.string()),
+});
+export const changelogEntriesSchema = z.array(changelogEntrySchema);
+export const splitVersion = (version) => {
+    const parts = version.split(".");
+    let major = parts.shift();
+    const prefix = major.startsWith("v") ? "v" : null;
+    if (major.startsWith("v"))
+        major = major.substring(1);
+    const minor = parts.shift();
+    const patch = parts.shift();
+    return {
+        major: Number(major),
+        minor: minor ? Number(minor) : null,
+        patch: patch ? Number(patch) : null,
+        prefix,
+    };
+};
+export const concatVersion = (version) => {
+    let result = version.major.toString();
+    if (version.prefix)
+        result = version.prefix + result;
+    if (version.minor)
+        result += "." + version.minor.toString();
+    if (version.patch)
+        result += "." + version.patch.toString();
+    return result;
+};
+export const compareVersions = (a, b) => {
+    a = typeof a === "string" ? splitVersion(a) : a;
+    b = typeof b === "string" ? splitVersion(b) : b;
+    if (a.major !== b.major)
+        return a.major - b.major;
+    if (a.minor === null || b.minor === null)
+        return 0;
+    if (a.minor !== b.minor)
+        return a.minor - b.minor;
+    if (a.patch === null || b.patch === null)
+        return 0;
+    if (a.patch !== b.patch)
+        return a.patch - b.patch;
+    return 0;
+};
+export const compareVersionsGT = (a, b) => compareVersions(a, b) > 0;
+export const readWorkspaceYaml = async (repoRoot) => {
+    const workspaceFilePath = resolve(repoRoot, "pnpm-workspace.yaml");
+    const fileContent = await readFile(workspaceFilePath, "utf8");
+    const parsed = parse(fileContent);
+    if (!parsed || !parsed.packages || !Array.isArray(parsed.packages))
+        throw new Error("No 'packages' field found in pnpm-workspace.yaml");
+    const packageColletions = await Promise.all(parsed.packages.map(async (p) => {
+        if (!p.endsWith("/*"))
+            return [p];
+        const base = p.substring(0, p.length - 2);
+        const pkgs = await readdir(join(repoRoot, base));
+        return pkgs
+            .filter((pkg) => !pkg.startsWith("."))
+            .map((pkg) => join(base, pkg));
+    }));
+    const packages = [];
+    for (const packageColletion of packageColletions)
+        packages.push(...packageColletion);
+    return { packages };
+};
+export const readPackageJsons = async (repoRoot) => {
+    try {
+        const pnpmWS = await readWorkspaceYaml(repoRoot);
+        return Promise.all(pnpmWS.packages.map(async (repoPath) => {
+            const jsonPath = join(repoRoot, repoPath, "package.json");
+            const content = JSON.parse(await readFile(jsonPath, "utf8"));
+            return {
+                jsonPath,
+                repoPath,
+                content,
+                modified: false,
+                wsName: repoPath.startsWith("packages/")
+                    ? repoPath.substring(9)
+                    : repoPath,
+            };
+        }));
+    }
+    catch {
+        return [];
+    }
+};
+export const writePackageJsons = async (entries) => Promise.all(entries.map(async (entry) => {
+    if (entry.modified) {
+        await writeFile(entry.jsonPath, JSON.stringify(entry.content, null, 2) + "\n", "utf8");
+        console.log(`  ✅ Updated ${entry.content.name}\n`);
+    }
+    else {
+        console.log(`  ⏭️  No workspace dependencies to fix. ${entry.content.name}\n`);
+    }
+}));
+// Build a map of package names to their versions
+export const buildMapEntries = (pkgEntries) => {
+    const versionEntries = [];
+    for (const fromPkg of pkgEntries)
+        for (const toPkg of pkgEntries)
+            if (fromPkg.content.name !== toPkg.content.name)
+                versionEntries.push({
+                    fromPkg,
+                    toPkg,
+                    relPath: relative(fromPkg.repoPath, toPkg.repoPath),
+                });
+    return versionEntries;
+};
+export const resolveBaselineCommit = async (entries, rootDir, packageJsonPath) => {
+    if (entries.length > 0 &&
+        entries[0].gitCommitHashs.length > 0 &&
+        entries[0].gitCommitHashs[0])
+        return ensureCommitRef(entries[0].gitCommitHashs[0], "HEAD~1", rootDir);
+    const packageJson = await readPackageJson(packageJsonPath);
+    const versionTag = packageJson?.version ? `v${packageJson.version}` : null;
+    if (versionTag) {
+        const simplegit = await verifiedGit(rootDir);
+        const tags = await simplegit.tags();
+        if (tags.all.includes(versionTag)) {
+            return ensureCommitRef(versionTag, "HEAD~1", rootDir);
+        }
+    }
+    return ensureCommitRef("HEAD~1", "HEAD", rootDir);
+};
+export const ensureCommitRef = async (ref, fallback, rootDir) => {
+    try {
+        await verifiedGit(rootDir, ref);
+        return ref;
+    }
+    catch {
+        await verifiedGit(rootDir, fallback);
+        return fallback;
+    }
+};
+export const readChangedTsFiles = async (baselineCommit, git) => {
+    git.sinceCommit = baselineCommit;
+    const [result, simplegit] = await Promise.all([
+        git.readChangedFiles(),
+        verifiedGit(git.rootDir),
+    ]);
+    const status = await simplegit.status();
+    const targetPrefix = /^packages\/(common|backend|frontend|code)\/src\//;
+    const untracked = status.not_added.map((path) => path.replaceAll("\\", "/"));
+    return [...result.files.map((file) => file.repoFilePath), ...untracked]
+        .map((path) => path.replaceAll("\\", "/"))
+        .filter((path) => targetPrefix.test(path) && path.endsWith(".ts"))
+        .filter((path, index, arr) => arr.indexOf(path) === index)
+        .sort();
+};
+export const mapChangedPackages = (files) => {
+    const found = new Set();
+    for (const filePath of files) {
+        const parts = filePath.split("/");
+        const packageName = parts[1];
+        if (packageName)
+            found.add(packageName);
+    }
+    return [...found].sort();
+};
+export const mapAffectedPackages = (changedPackages) => {
+    const affected = new Set();
+    for (const packageName of changedPackages) {
+        const typedName = packageName;
+        const dependents = changelogDependents[typedName] ?? [packageName];
+        for (const dependent of dependents)
+            affected.add(dependent);
+    }
+    return [...affected].sort();
+};
+export const readPackageVersions = async (rootDir) => {
+    const versions = {};
+    const packageJsons = await readPackageJsons(rootDir);
+    for (const packageJson of packageJsons)
+        versions[packageJson.repoPath] = packageJson.content.version;
+    return versions;
+};
+export const readMinPackageVersion = async (rootDir) => {
+    const versions = await readPackageVersions(rootDir);
+    const splitVersions = Object.values(versions).map(splitVersion);
+    if (splitVersions.length === 0)
+        return null;
+    splitVersions.sort(compareVersions);
+    return concatVersion(splitVersions[0]);
+};

package/dist/changelog/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./ChangeDetector.js";
+export * from "./Changelog.js";
+export * from "./changelog.util.js";

package/dist/changelog/index.js

@@ -0,0 +1,4 @@
+// This file is auto-generated. Do not edit manually.
+export * from "./ChangeDetector.js";
+export * from "./Changelog.js";
+export * from "./changelog.util.js";

package/dist/common/code.common.d.ts

@@ -0,0 +1,17 @@
+import { MetaFileExtension, MetaFileType } from "@mxpicture/gcp-functions-common/meta";
+import { ExtractFileParts, SourceFile } from "./types.common.js";
+export declare const isTemplateFile: (filename: string) => boolean;
+export declare const isTsFile: (filename: string, type: MetaFileType) => boolean;
+export declare const isAnyFile: (filename: string, type?: MetaFileType, ext?: MetaFileExtension) => boolean;
+export declare const extractFileParts: (filename: string) => ExtractFileParts;
+export declare const concatFileParts: (parts: ExtractFileParts) => string;
+export declare const toFilename: (p: {
+    filename: string;
+    type: MetaFileType;
+    generated?: boolean;
+    ext?: MetaFileExtension;
+}) => string;
+export declare const formatCode: (...lines: string[]) => Promise<string>;
+export declare const formatJson: (...lines: string[]) => Promise<string>;
+export declare const formatJson2Spaces: (...lines: string[]) => Promise<string>;
+export declare const createSourceFiles: (filePaths: string[]) => SourceFile[];

package/dist/common/code.common.js

@@ -0,0 +1,65 @@
+import ts from "typescript";
+import { format } from "prettier";
+import { guardMetaFileExtension, guardMetaFileType, MetaFileExtension, MetaFileType, } from "@mxpicture/gcp-functions-common/meta";
+export const isTemplateFile = (filename) => isTsFile(filename, MetaFileType.template);
+export const isTsFile = (filename, type) => isAnyFile(filename, type, MetaFileExtension.ts);
+export const isAnyFile = (filename, type, ext) => {
+    try {
+        const parts = extractFileParts(filename);
+        if (type && type !== parts.type)
+            return false;
+        if (ext && ext !== parts.ext)
+            return false;
+    }
+    catch {
+        return false;
+    }
+    return true;
+};
+export const extractFileParts = (filename) => {
+    const parts = filename.split(".");
+    if (parts.length < 3)
+        throw new Error(`Filename "${filename}" invalid (3 parts divided by ".")`);
+    const _type = parts.shift();
+    const _ext = parts.pop();
+    const type = guardMetaFileType(_type);
+    const ext = guardMetaFileExtension(_ext);
+    if (!type)
+        throw new Error(`Filename "${filename}" invalid (type: ${_type})`);
+    if (!ext)
+        throw new Error(`Filename "${filename}" invalid (extension: ${_ext})`);
+    return {
+        filename,
+        type,
+        ext,
+        middlePart: parts.join("."),
+    };
+};
+export const concatFileParts = (parts) => [parts.type, parts.middlePart, parts.generated ? "gen" : null, parts.ext]
+    .filter((p) => !!p)
+    .join(".");
+export const toFilename = (p) => concatFileParts({
+    ...extractFileParts(p.filename),
+    type: p.type,
+    ext: p.ext ?? MetaFileExtension.ts,
+    generated: p.generated,
+});
+export const formatCode = async (...lines) => format(lines.join("\n"), { parser: "typescript" });
+export const formatJson = async (...lines) => format(lines.join("\n"), { parser: "json" });
+export const formatJson2Spaces = async (...lines) => format(lines.join("\n"), { parser: "json", tabWidth: 2, useTabs: false });
+export const createSourceFiles = (filePaths) => {
+    const program = ts.createProgram(filePaths, {
+        target: ts.ScriptTarget.ES2023,
+        module: ts.ModuleKind.Node20,
+        strict: true,
+    });
+    const checker = program.getTypeChecker();
+    const results = [];
+    for (const filePath of filePaths) {
+        const sourceFile = program.getSourceFile(filePath);
+        if (!sourceFile)
+            continue;
+        results.push({ sourceFile, filePath, checker });
+    }
+    return results;
+};

package/dist/common/hash.common.d.ts

@@ -0,0 +1 @@
+export declare const calcHash: (input: string) => string;

package/dist/common/hash.common.js

@@ -0,0 +1,2 @@
+import { createHash } from "node:crypto";
+export const calcHash = (input) => createHash("sha256").update(input).digest("hex");

package/dist/common/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./code.common.js";
+export * from "./hash.common.js";
+export * from "./string.common.js";
+export * from "./types.common.js";

package/dist/common/index.js

@@ -0,0 +1,5 @@
+// This file is auto-generated. Do not edit manually.
+export * from "./code.common.js";
+export * from "./hash.common.js";
+export * from "./string.common.js";
+export * from "./types.common.js";

package/dist/common/string.common.d.ts

@@ -0,0 +1,4 @@
+export declare const lowerFirstLetter: (val: string) => string;
+export declare const upperFirstLetter: (val: string) => string;
+export declare const lowerFirstLetterAsync: (val: string) => Promise<string>;
+export declare const upperFirstLetterAsync: (val: string) => Promise<string>;

package/dist/common/string.common.js

@@ -0,0 +1,8 @@
+export const lowerFirstLetter = (val) => val.length > 1
+    ? val.charAt(0).toLocaleLowerCase() + val.slice(1)
+    : val.toLocaleLowerCase();
+export const upperFirstLetter = (val) => val.length > 1
+    ? val.charAt(0).toUpperCase() + val.slice(1)
+    : val.toUpperCase();
+export const lowerFirstLetterAsync = async (val) => Promise.resolve().then(() => lowerFirstLetter(val));
+export const upperFirstLetterAsync = async (val) => Promise.resolve().then(() => upperFirstLetter(val));

package/dist/common/types.common.d.ts

@@ -0,0 +1,20 @@
+import ts from "typescript";
+import type { PackageJson } from "type-fest";
+import { MetaFileExtension, MetaFileType, MetaTargetType } from "@mxpicture/gcp-functions-common/meta";
+export interface ExtractFileParts {
+    filename: string;
+    type: MetaFileType;
+    ext: MetaFileExtension;
+    middlePart: string;
+    generated?: boolean;
+}
+export interface SourceFile {
+    filePath: string;
+    checker: ts.TypeChecker;
+    sourceFile: ts.SourceFile;
+}
+export interface TargetPackage {
+    targetType: MetaTargetType;
+    filePath: string;
+    pkg: PackageJson;
+}

package/dist/common/types.common.js

@@ -0,0 +1 @@
+export {};