@ykdz/template 0.0.3 → 0.0.4

package/dist/src/template-boundary-check.js

@@ -0,0 +1,448 @@
+import { readFile } from "node:fs/promises";
+import ts from "typescript";
+const inlineOperationKinds = new Set([
+    "writeText",
+    "writeJson",
+    "mergeJson",
+]);
+export const templateBoundaryDebtAllowlist = [];
+function operationTarget(operation) {
+    if ("to" in operation) {
+        return operation.to;
+    }
+    return undefined;
+}
+function isInlineProtectedOperation(operation) {
+    const generatedPath = operationTarget(operation);
+    return (generatedPath !== undefined &&
+        inlineOperationKinds.has(operation.kind) &&
+        isProtectedGeneratedPath(generatedPath));
+}
+export function isProtectedGeneratedPath(generatedPath) {
+    const normalizedPath = generatedPath.split("\\").join("/");
+    const fileName = normalizedPath.split("/").at(-1);
+    return (normalizedPath === ".devcontainer/Dockerfile" ||
+        normalizedPath === ".devcontainer/devcontainer.json" ||
+        normalizedPath === ".github/dependabot.yml" ||
+        normalizedPath.startsWith(".github/workflows/") ||
+        normalizedPath.startsWith(".vscode/") ||
+        fileName === "oxfmt.config.ts" ||
+        fileName === "oxlint.config.ts" ||
+        fileName === "playwright.config.ts" ||
+        fileName === "rustfmt.toml" ||
+        fileName === "rust-toolchain.toml" ||
+        fileName === "turbo.json" ||
+        fileName === "tsconfig.config.json" ||
+        fileName === "vite.config.ts" ||
+        fileName === "vitest.config.ts");
+}
+function propertyStringValue(objectLiteral, name) {
+    const initializer = propertyInitializer(objectLiteral, name);
+    if (!initializer) {
+        return undefined;
+    }
+    if (ts.isStringLiteralLike(initializer)) {
+        return initializer.text;
+    }
+    if (ts.isNoSubstitutionTemplateLiteral(initializer) ||
+        ts.isTemplateExpression(initializer)) {
+        return initializer.getText();
+    }
+    return undefined;
+}
+function propertyInitializer(objectLiteral, name) {
+    const property = objectLiteral.properties.find((candidate) => {
+        return (ts.isPropertyAssignment(candidate) &&
+            ts.isIdentifier(candidate.name) &&
+            candidate.name.text === name);
+    });
+    if (!property || !ts.isPropertyAssignment(property)) {
+        return undefined;
+    }
+    return property.initializer;
+}
+function propertyPathMatches(objectLiteral, name, expectedPath) {
+    const initializer = propertyInitializer(objectLiteral, name);
+    if (!initializer) {
+        return false;
+    }
+    if (ts.isStringLiteralLike(initializer)) {
+        return initializer.text === expectedPath;
+    }
+    if (ts.isNoSubstitutionTemplateLiteral(initializer)) {
+        return initializer.text === expectedPath;
+    }
+    if (ts.isTemplateExpression(initializer)) {
+        const literalParts = [
+            initializer.head.text,
+            ...initializer.templateSpans.map((span) => span.literal.text),
+        ].filter((part) => part.length > 0);
+        let searchStart = 0;
+        return literalParts.every((part, index) => {
+            const foundAt = expectedPath.indexOf(part, searchStart);
+            if (foundAt === -1) {
+                return false;
+            }
+            const isFirst = index === 0;
+            const isLast = index === literalParts.length - 1;
+            if (isFirst && initializer.head.text.length > 0 && foundAt !== 0) {
+                return false;
+            }
+            if (isLast && !expectedPath.endsWith(part)) {
+                return false;
+            }
+            searchStart = foundAt + part.length;
+            return true;
+        });
+    }
+    return false;
+}
+function owningFunctionName(node) {
+    let current = node;
+    while (current) {
+        if ((ts.isFunctionDeclaration(current) ||
+            ts.isFunctionExpression(current) ||
+            ts.isArrowFunction(current) ||
+            ts.isMethodDeclaration(current)) &&
+            current.name) {
+            return current.name.getText();
+        }
+        if (ts.isPropertyAssignment(current) &&
+            (ts.isFunctionExpression(current.initializer) ||
+                ts.isArrowFunction(current.initializer))) {
+            return current.name.getText();
+        }
+        current = current.parent;
+    }
+    return "<module>";
+}
+function propertyNameText(name) {
+    if (ts.isIdentifier(name) || ts.isStringLiteralLike(name)) {
+        return name.text;
+    }
+    if (ts.isNumericLiteral(name)) {
+        return name.text;
+    }
+    return undefined;
+}
+function expressionLiteralJsonValue(expression) {
+    if (ts.isParenthesizedExpression(expression)) {
+        return expressionLiteralJsonValue(expression.expression);
+    }
+    if (ts.isAsExpression(expression) ||
+        ts.isSatisfiesExpression(expression) ||
+        ts.isTypeAssertionExpression(expression)) {
+        return expressionLiteralJsonValue(expression.expression);
+    }
+    if (ts.isStringLiteralLike(expression)) {
+        return { known: true, value: expression.text };
+    }
+    if (ts.isNoSubstitutionTemplateLiteral(expression)) {
+        return { known: true, value: expression.text };
+    }
+    if (ts.isNumericLiteral(expression)) {
+        return { known: true, value: Number(expression.text) };
+    }
+    if (expression.kind === ts.SyntaxKind.TrueKeyword) {
+        return { known: true, value: true };
+    }
+    if (expression.kind === ts.SyntaxKind.FalseKeyword) {
+        return { known: true, value: false };
+    }
+    if (expression.kind === ts.SyntaxKind.NullKeyword) {
+        return { known: true, value: null };
+    }
+    if (ts.isPrefixUnaryExpression(expression)) {
+        const operand = expressionLiteralJsonValue(expression.operand);
+        if (!operand.known || typeof operand.value !== "number") {
+            return { known: false };
+        }
+        if (expression.operator === ts.SyntaxKind.MinusToken) {
+            return { known: true, value: -operand.value };
+        }
+        if (expression.operator === ts.SyntaxKind.PlusToken) {
+            return { known: true, value: operand.value };
+        }
+        return { known: false };
+    }
+    if (ts.isArrayLiteralExpression(expression)) {
+        const values = [];
+        for (const element of expression.elements) {
+            if (ts.isSpreadElement(element)) {
+                return { known: false };
+            }
+            const value = expressionLiteralJsonValue(element);
+            if (!value.known) {
+                return { known: false };
+            }
+            values.push(value.value);
+        }
+        return { known: true, value: values };
+    }
+    if (ts.isObjectLiteralExpression(expression)) {
+        const value = {};
+        for (const property of expression.properties) {
+            if (!ts.isPropertyAssignment(property)) {
+                return { known: false };
+            }
+            const name = propertyNameText(property.name);
+            if (name === undefined) {
+                return { known: false };
+            }
+            const initializer = expressionLiteralJsonValue(property.initializer);
+            if (!initializer.known) {
+                return { known: false };
+            }
+            value[name] = initializer.value;
+        }
+        return { known: true, value };
+    }
+    return { known: false };
+}
+function jsonValuesEqual(left, right) {
+    if (Object.is(left, right)) {
+        return true;
+    }
+    if (Array.isArray(left) || Array.isArray(right)) {
+        return (Array.isArray(left) &&
+            Array.isArray(right) &&
+            left.length === right.length &&
+            left.every((entry, index) => jsonValuesEqual(entry, right[index])));
+    }
+    if (typeof left !== "object" ||
+        left === null ||
+        typeof right !== "object" ||
+        right === null) {
+        return false;
+    }
+    const leftEntries = Object.entries(left);
+    const rightRecord = right;
+    const rightKeys = new Set(Object.keys(rightRecord));
+    return (leftEntries.length === rightKeys.size &&
+        leftEntries.every(([key, value]) => {
+            rightKeys.delete(key);
+            return jsonValuesEqual(value, rightRecord[key]);
+        }) &&
+        rightKeys.size === 0);
+}
+function expressionMatchesJsonValue(expression, expectedValue) {
+    const literalValue = expressionLiteralJsonValue(expression);
+    return (literalValue.known && jsonValuesEqual(literalValue.value, expectedValue));
+}
+function isExactOperationAstMatch(node, operation) {
+    if (operation.kind === "writeText") {
+        return propertyStringValue(node, "text") === operation.text;
+    }
+    const value = propertyInitializer(node, "value");
+    return (value !== undefined && expressionMatchesJsonValue(value, operation.value));
+}
+function findAstMatchesForOperation(sourceFile, operation) {
+    const exactMatches = [];
+    const candidateMatches = [];
+    function visit(node) {
+        if (!ts.isObjectLiteralExpression(node)) {
+            ts.forEachChild(node, visit);
+            return;
+        }
+        if (propertyStringValue(node, "kind") === operation.kind &&
+            propertyPathMatches(node, "to", operation.to)) {
+            const match = {
+                node,
+                owningFunction: owningFunctionName(node),
+            };
+            candidateMatches.push(match);
+            if (isExactOperationAstMatch(node, operation)) {
+                exactMatches.push(match);
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    if (exactMatches.length > 0) {
+        return exactMatches;
+    }
+    return candidateMatches;
+}
+function findOwningFunctionsForOperation(sourceFile, operation) {
+    const owners = new Set(findAstMatchesForOperation(sourceFile, operation).map((match) => match.owningFunction));
+    if (owners.size > 0) {
+        return [...owners];
+    }
+    return ["<unknown>"];
+}
+function isPropertyAccess(expression, objectName, propertyName) {
+    return (ts.isPropertyAccessExpression(expression) &&
+        ts.isIdentifier(expression.expression) &&
+        expression.expression.text === objectName &&
+        expression.name.text === propertyName);
+}
+function isEditorExtensionsProjectionValue(expression) {
+    if (!ts.isObjectLiteralExpression(expression)) {
+        return false;
+    }
+    const [property] = expression.properties;
+    return (expression.properties.length === 1 &&
+        property !== undefined &&
+        ts.isPropertyAssignment(property) &&
+        ts.isIdentifier(property.name) &&
+        property.name.text === "recommendations" &&
+        isPropertyAccess(property.initializer, "editorCustomization", "extensions"));
+}
+function isStructuredEditorCustomizationOperation(sourceFile, operation) {
+    if (operation.kind !== "writeJson") {
+        return false;
+    }
+    if (operation.to !== ".vscode/extensions.json" &&
+        operation.to !== ".vscode/settings.json") {
+        return false;
+    }
+    const matches = findAstMatchesForOperation(sourceFile, operation);
+    if (matches.length === 0) {
+        return false;
+    }
+    return matches.every((match) => {
+        const value = propertyInitializer(match.node, "value");
+        return (value !== undefined &&
+            (operation.to === ".vscode/settings.json"
+                ? isPropertyAccess(value, "editorCustomization", "settings")
+                : isEditorExtensionsProjectionValue(value)));
+    });
+}
+function isStringArray(value) {
+    return (Array.isArray(value) && value.every((entry) => typeof entry === "string"));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasExactKeys(value, expectedKeys) {
+    const keys = Object.keys(value);
+    const expectedKeySet = new Set(expectedKeys);
+    return (keys.length === expectedKeySet.size &&
+        keys.every((key) => expectedKeySet.has(key)));
+}
+function isStructuralTurboValue(value) {
+    if (!isRecord(value) ||
+        !hasExactKeys(value, ["tasks"]) ||
+        !isRecord(value.tasks)) {
+        return false;
+    }
+    return Object.values(value.tasks).every((task) => {
+        if (!isRecord(task)) {
+            return false;
+        }
+        return Object.entries(task).every(([key, entryValue]) => {
+            if (key === "dependsOn" || key === "outputs") {
+                return isStringArray(entryValue);
+            }
+            if (key === "cache" || key === "persistent") {
+                return typeof entryValue === "boolean";
+            }
+            return false;
+        });
+    });
+}
+const rootTsconfigConfigCompilerOptions = {
+    module: "NodeNext",
+    moduleResolution: "NodeNext",
+    noEmitOnError: true,
+    skipLibCheck: false,
+    strict: true,
+    target: "ES2022",
+};
+const rootTsconfigConfigIncludes = new Set([
+    "oxlint.config.ts",
+    "oxfmt.config.ts",
+    "playwright.config.ts",
+    "vite.config.ts",
+    "vitest.config.ts",
+]);
+function isStructuralTsconfigConfigValue(value) {
+    if (!isRecord(value) ||
+        !hasExactKeys(value, ["compilerOptions", "include"]) ||
+        !isRecord(value.compilerOptions) ||
+        !isStringArray(value.include)) {
+        return false;
+    }
+    return (jsonValuesEqual(value.compilerOptions, rootTsconfigConfigCompilerOptions) &&
+        value.include.every((entry) => rootTsconfigConfigIncludes.has(entry)));
+}
+function isDevelopmentContainerPlanValue(expression) {
+    return isPropertyAccess(expression, "developmentContainer", "devcontainer");
+}
+function isAllowedStructuralMachineDeclaration(sourceFile, operation) {
+    if (operation.kind !== "writeJson") {
+        return false;
+    }
+    if (operation.to === "turbo.json") {
+        return isStructuralTurboValue(operation.value);
+    }
+    if (operation.to === "tsconfig.config.json") {
+        return isStructuralTsconfigConfigValue(operation.value);
+    }
+    if (operation.to !== ".devcontainer/devcontainer.json") {
+        return false;
+    }
+    const matches = findAstMatchesForOperation(sourceFile, operation);
+    return (matches.length > 0 &&
+        matches.every((match) => {
+            const value = propertyInitializer(match.node, "value");
+            return value !== undefined && isDevelopmentContainerPlanValue(value);
+        }));
+}
+function allowlistKey(preset, generatedPath, owningFunction) {
+    return `${preset}\0${owningFunction}\0${generatedPath}`;
+}
+export async function checkTemplateSourceBoundary({ projections, allowlist = [], }) {
+    const allowed = new Map(allowlist.map((entry) => [
+        allowlistKey(entry.preset, entry.generatedPath, entry.owningFunction),
+        entry.reason,
+    ]));
+    const checkedPresets = new Set(projections.map((projection) => projection.name));
+    const usedAllowlistKeys = new Set();
+    const violations = [];
+    const allowlistedDebt = [];
+    for (const projection of projections) {
+        const sourceText = await readFile(projection.sourceFilePath, "utf8");
+        const sourceFile = ts.createSourceFile(projection.sourceFilePath, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+        for (const operation of projection.plan.operations) {
+            if (!isInlineProtectedOperation(operation)) {
+                continue;
+            }
+            if (isStructuredEditorCustomizationOperation(sourceFile, operation)) {
+                continue;
+            }
+            if (isAllowedStructuralMachineDeclaration(sourceFile, operation)) {
+                continue;
+            }
+            const owningFunctions = findOwningFunctionsForOperation(sourceFile, operation);
+            for (const owningFunction of owningFunctions) {
+                const diagnostic = {
+                    preset: projection.name,
+                    generatedPath: operation.to,
+                    owningFunction,
+                    operationKind: operation.kind,
+                    sourceFilePath: projection.sourceFilePath,
+                };
+                const allowlistReason = allowed.get(allowlistKey(projection.name, operation.to, owningFunction));
+                if (allowlistReason) {
+                    usedAllowlistKeys.add(allowlistKey(projection.name, operation.to, owningFunction));
+                    allowlistedDebt.push({ ...diagnostic, allowlistReason });
+                    continue;
+                }
+                violations.push(diagnostic);
+            }
+        }
+    }
+    const unusedAllowlistEntries = allowlist.filter((entry) => {
+        if (!checkedPresets.has(entry.preset)) {
+            return false;
+        }
+        return !usedAllowlistKeys.has(allowlistKey(entry.preset, entry.generatedPath, entry.owningFunction));
+    });
+    return {
+        ok: violations.length === 0 && unusedAllowlistEntries.length === 0,
+        violations,
+        allowlistedDebt,
+        unusedAllowlistEntries,
+    };
+}

package/dist/src/toolchain-resolution.d.ts

@@ -32,4 +32,3 @@ export type OnlineToolchainResolutionContractResult = {
 export declare function resolveToolchainVersions(options?: ResolveToolchainVersionsOptions): Promise<ResolvedToolchainVersions>;
 export declare function checkOnlineToolchainResolutionContract(options?: OnlineToolchainResolutionContractOptions): Promise<OnlineToolchainResolutionContractResult>;
 export {};
-//# sourceMappingURL=toolchain-resolution.d.ts.map

package/dist/templates/hono-api/projection.d.ts

@@ -1,7 +1,6 @@
 import type { BuiltInPreset, ProjectBlueprint } from "../../src/declarations.js";
-import type { PresetProjection } from "../../src/preset-projection.js";
+import type { PresetBlueprintOptions, PresetProjection } from "../../src/preset-projection.js";
 export declare const honoApiPresetMetadata: BuiltInPreset;
-export declare function honoApiBlueprint(): ProjectBlueprint;
+export declare function honoApiBlueprint(options?: PresetBlueprintOptions): ProjectBlueprint;
 export declare function projectHonoApiPackageScripts(): Record<string, string>;
 export declare const honoApiPresetProjection: PresetProjection;
-//# sourceMappingURL=projection.d.ts.map