@playcraft/build 0.0.45 → 0.0.47

package/dist/validation/validation-runner.js

@@ -0,0 +1,96 @@
+import { getChannelRuleProfile } from './profiles.js';
+import { validateHtmlArtifact } from './html-validator.js';
+import { validateDeliveryPackage } from './package-validator.js';
+import { scanSourceForChannels, scanSourceForCompliance } from './source-scanner.js';
+export const VALIDATION_REPORT_VERSION = '0.1.0';
+export async function runPlayableValidation(context, stages) {
+    const profile = getChannelRuleProfile(context.channel);
+    const defaultStages = [...profile.defaultStages];
+    if (context.packagePath && profile.optionalStages.includes('delivery-package')) {
+        defaultStages.push('delivery-package');
+    }
+    const enabledStages = new Set(stages ?? defaultStages);
+    const results = [];
+    if (enabledStages.has('prebuild-source')) {
+        results.push(...await scanSourceForCompliance(context));
+    }
+    if (enabledStages.has('html-artifact')) {
+        results.push(...await validateHtmlArtifact(context, profile));
+    }
+    if (enabledStages.has('delivery-package')) {
+        results.push(...await validateDeliveryPackage(context, profile));
+    }
+    const manualChecklist = buildManualChecklist(profile.rules, enabledStages);
+    const externalChecklist = buildExternalChecklist(profile.rules, enabledStages);
+    return {
+        version: VALIDATION_REPORT_VERSION,
+        channel: context.channel,
+        buildChain: context.buildChain,
+        summary: summarize(results, manualChecklist, externalChecklist),
+        results,
+        manualChecklist,
+        externalChecklist,
+    };
+}
+export async function runPlayableSourceValidationForChannels(context, channels) {
+    const uniqueChannels = Array.from(new Set(channels));
+    const results = await scanSourceForChannels(context, uniqueChannels);
+    return {
+        version: VALIDATION_REPORT_VERSION,
+        channel: uniqueChannels[0] ?? 'playcraft',
+        buildChain: context.buildChain,
+        summary: summarize(results, [], []),
+        results,
+        manualChecklist: [],
+        externalChecklist: [],
+    };
+}
+function buildManualChecklist(rules, enabledStages) {
+    return rules
+        .filter((rule) => rule.owner === 'manual')
+        .filter((rule) => enabledStages.has(rule.stage) || rule.stage === 'runtime-manual')
+        .map((rule) => ({
+        ruleId: rule.id,
+        channel: rule.channel,
+        stage: rule.stage,
+        message: rule.title,
+        recommendation: rule.recommendation,
+        owner: rule.owner,
+    }));
+}
+function buildExternalChecklist(rules, enabledStages) {
+    return rules
+        .filter((rule) => rule.owner === 'external')
+        .filter((rule) => enabledStages.has(rule.stage) || rule.stage === 'external-validator')
+        .map((rule) => ({
+        ruleId: rule.id,
+        channel: rule.channel,
+        stage: rule.stage,
+        message: rule.title,
+        recommendation: rule.recommendation,
+        owner: rule.owner,
+    }));
+}
+function summarize(results, manualChecklist, externalChecklist) {
+    const errorCount = results.filter((result) => result.status === 'fail').length;
+    const warningCount = results.filter((result) => result.status === 'warning').length;
+    const manualCount = manualChecklist.length;
+    const externalCount = externalChecklist.length;
+    let status = 'pass';
+    if (errorCount > 0) {
+        status = 'failed';
+    }
+    else if (warningCount > 0) {
+        status = 'warning';
+    }
+    else if (manualCount > 0 || externalCount > 0) {
+        status = 'manual-required';
+    }
+    return {
+        status,
+        errorCount,
+        warningCount,
+        manualCount,
+        externalCount,
+    };
+}

package/dist/validation/zip-reader.d.ts

@@ -0,0 +1,17 @@
+export interface ZipEntryInfo {
+    path: string;
+    compressedSize: number;
+    uncompressedSize: number;
+    compressionMethod: number;
+    isDirectory: boolean;
+}
+export declare class SimpleZipReader {
+    private readonly buffer;
+    private entriesCache?;
+    constructor(buffer: Buffer);
+    listEntries(): ZipEntryInfo[];
+    readEntryText(entryPath: string): string | null;
+    private readCentralDirectory;
+    private readEntryData;
+    private findEndOfCentralDirectory;
+}

package/dist/validation/zip-reader.js

@@ -0,0 +1,84 @@
+import { inflateRawSync } from 'zlib';
+export class SimpleZipReader {
+    constructor(buffer) {
+        this.buffer = buffer;
+    }
+    listEntries() {
+        return this.readCentralDirectory().map(({ localHeaderOffset: _offset, ...entry }) => entry);
+    }
+    readEntryText(entryPath) {
+        const entry = this.readCentralDirectory().find((item) => item.path === entryPath);
+        if (!entry || entry.isDirectory)
+            return null;
+        const data = this.readEntryData(entry);
+        return data.toString('utf-8');
+    }
+    readCentralDirectory() {
+        if (this.entriesCache)
+            return this.entriesCache;
+        const eocdOffset = this.findEndOfCentralDirectory();
+        if (eocdOffset < 0) {
+            throw new Error('Invalid ZIP: end of central directory not found');
+        }
+        const totalEntries = this.buffer.readUInt16LE(eocdOffset + 10);
+        const centralDirectoryOffset = this.buffer.readUInt32LE(eocdOffset + 16);
+        const entries = [];
+        let offset = centralDirectoryOffset;
+        for (let i = 0; i < totalEntries; i++) {
+            const signature = this.buffer.readUInt32LE(offset);
+            if (signature !== 0x02014b50) {
+                throw new Error(`Invalid ZIP: bad central directory signature at ${offset}`);
+            }
+            const compressionMethod = this.buffer.readUInt16LE(offset + 10);
+            const compressedSize = this.buffer.readUInt32LE(offset + 20);
+            const uncompressedSize = this.buffer.readUInt32LE(offset + 24);
+            const fileNameLength = this.buffer.readUInt16LE(offset + 28);
+            const extraLength = this.buffer.readUInt16LE(offset + 30);
+            const commentLength = this.buffer.readUInt16LE(offset + 32);
+            const localHeaderOffset = this.buffer.readUInt32LE(offset + 42);
+            const fileNameStart = offset + 46;
+            const entryPath = this.buffer
+                .subarray(fileNameStart, fileNameStart + fileNameLength)
+                .toString('utf-8')
+                .replace(/\\/g, '/');
+            entries.push({
+                path: entryPath,
+                compressedSize,
+                uncompressedSize,
+                compressionMethod,
+                localHeaderOffset,
+                isDirectory: entryPath.endsWith('/'),
+            });
+            offset = fileNameStart + fileNameLength + extraLength + commentLength;
+        }
+        this.entriesCache = entries;
+        return entries;
+    }
+    readEntryData(entry) {
+        const offset = entry.localHeaderOffset;
+        const signature = this.buffer.readUInt32LE(offset);
+        if (signature !== 0x04034b50) {
+            throw new Error(`Invalid ZIP: bad local header signature at ${offset}`);
+        }
+        const fileNameLength = this.buffer.readUInt16LE(offset + 26);
+        const extraLength = this.buffer.readUInt16LE(offset + 28);
+        const dataStart = offset + 30 + fileNameLength + extraLength;
+        const compressed = this.buffer.subarray(dataStart, dataStart + entry.compressedSize);
+        if (entry.compressionMethod === 0) {
+            return Buffer.from(compressed);
+        }
+        if (entry.compressionMethod === 8) {
+            return inflateRawSync(compressed);
+        }
+        throw new Error(`Unsupported ZIP compression method: ${entry.compressionMethod}`);
+    }
+    findEndOfCentralDirectory() {
+        const minOffset = Math.max(0, this.buffer.length - 0xffff - 22);
+        for (let offset = this.buffer.length - 22; offset >= minOffset; offset--) {
+            if (this.buffer.readUInt32LE(offset) === 0x06054b50) {
+                return offset;
+            }
+        }
+        return -1;
+    }
+}

package/dist/vite-builder.d.ts

@@ -82,5 +82,6 @@ export declare class ViteBuilder {
     /**
      * 格式化字节数
      */
+    private runComplianceValidation;
     private formatBytes;
 }

package/dist/vite-builder.js

@@ -4,6 +4,7 @@ import path from 'path';
 import { ViteConfigBuilder } from './vite/config-builder.js';
 import { GenericViteConfigBuilder } from './vite/config-builder-generic.js';
 import { PLATFORM_CONFIGS } from './vite/platform-configs.js';
+import { formatValidationSummary, hasBlockingValidationErrors, runPlayableValidation, saveValidationReport, } from './validation/index.js';
 /**
  * Vite 构建器 - 使用 Vite 构建 Playable Ads
  *
@@ -90,6 +91,7 @@ export class ViteBuilder {
         // 6. 验证输出大小
         const outputPath = this.getOutputPath();
         await this.validateSize(outputPath);
+        await this.runComplianceValidation(outputPath, metadata);
         // 7. 生成报告
         this.generateReport(outputPath);
         return outputPath;
@@ -350,6 +352,47 @@ export class ViteBuilder {
     /**
      * 格式化字节数
      */
+    async runComplianceValidation(outputPath, metadata) {
+        const validationOptions = this.options.validation;
+        if (validationOptions?.enabled === false) {
+            return;
+        }
+        if (this.engine !== 'phaser') {
+            return;
+        }
+        const isZip = outputPath.toLowerCase().endsWith('.zip');
+        const stages = validationOptions?.stages
+            ?? (isZip ? ['delivery-package'] : ['html-artifact']);
+        const report = await runPlayableValidation({
+            projectRoot: this.baseBuildDir,
+            channel: this.options.platform,
+            engine: this.engine,
+            buildTool: metadata?.buildTool,
+            buildChain: metadata?.buildTool === 'playable-scripts'
+                ? 'devkit'
+                : metadata?.buildTool === 'playcanvas-native'
+                    ? 'playcanvas-native'
+                    : 'generic',
+            htmlPath: isZip ? undefined : outputPath,
+            packagePath: isZip ? outputPath : undefined,
+            outputDir: this.options.outputDir,
+            sourceGlobs: validationOptions?.sourceGlobs,
+            metadata: metadata ? { ...metadata } : undefined,
+        }, stages);
+        const summary = formatValidationSummary(report);
+        if (report.summary.status === 'pass') {
+            console.log(summary);
+        }
+        else {
+            console.warn(summary);
+        }
+        if (validationOptions?.reportPath) {
+            await saveValidationReport(report, validationOptions.reportPath);
+        }
+        if (validationOptions?.failOnError && hasBlockingValidationErrors(report)) {
+            throw new Error(`Playable validation failed for ${this.options.platform}`);
+        }
+    }
     formatBytes(bytes) {
         if (bytes === 0)
             return '0 Bytes';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playcraft/build",
-  "version": "0.0.45",
+  "version": "0.0.47",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",
@@ -32,7 +32,7 @@
   "scripts": {
     "dev": "tsc -w",
     "build": "tsc",
-    "release": "node scripts/release.js"
+    "release": "node ../../scripts/release-npm.mjs --packages=build --skip-install --skip-tests --skip-git-push"
   },
   "dependencies": {
     "@playcraft/ads-tracking": "^1.0.0",