@liuhange/dsh-construction-data-inventory 0.0.0-stage → 3.1.0

package/lib/report-desensitizer.js

@@ -0,0 +1,72 @@
+const SENSITIVE_FIELD_PATTERNS = [
+    'amount',
+    'price',
+    'cost',
+    'fee',
+    'quote',
+    'quotation',
+    '合同金额',
+    '报价',
+    '费用',
+    '金额',
+    '参建方报价',
+];
+const UNKNOWN_SENSITIVE_REPLACEMENT = '***';
+export class ReportDesensitizer {
+    desensitize(report) {
+        const warnings = [];
+        const desensitizedAssetList = report.assetList.map((asset) => {
+            const cleaned = this.desensitizeAsset(asset, warnings);
+            return cleaned;
+        });
+        return {
+            report: {
+                ...report,
+                assetList: desensitizedAssetList,
+            },
+            warnings,
+        };
+    }
+    desensitizeAsset(asset, warnings) {
+        const cleaned = { ...asset };
+        const keys = Object.keys(cleaned);
+        for (const key of keys) {
+            if (this.isSensitiveField(String(key))) {
+                const value = cleaned[key];
+                if (value !== undefined && value !== null && String(value) !== '') {
+                    warnings.push(`敏感字段 ${String(key)} 已脱敏`);
+                    cleaned[key] = UNKNOWN_SENSITIVE_REPLACEMENT;
+                }
+            }
+        }
+        return cleaned;
+    }
+    desensitizeRecord(record) {
+        const warnings = [];
+        return this.desensitizeGenericRecord(record, warnings);
+    }
+    desensitizeGenericRecord(record, warnings) {
+        const cleaned = {};
+        for (const key of Object.keys(record)) {
+            if (this.isSensitiveField(key)) {
+                const value = record[key];
+                if (value !== undefined && value !== null && String(value) !== '') {
+                    warnings.push(`敏感字段 ${key} 已脱敏`);
+                    cleaned[key] = UNKNOWN_SENSITIVE_REPLACEMENT;
+                }
+                else {
+                    cleaned[key] = value;
+                }
+            }
+            else {
+                cleaned[key] = record[key];
+            }
+        }
+        return cleaned;
+    }
+    isSensitiveField(fieldName) {
+        const lower = fieldName.toLowerCase();
+        return SENSITIVE_FIELD_PATTERNS.some((pattern) => lower.includes(pattern.toLowerCase()));
+    }
+}
+//# sourceMappingURL=report-desensitizer.js.map

package/lib/review-override-recorder.js

@@ -0,0 +1,54 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { DEFAULT_OVERRIDE_LOG_PATH } from './invariant.js';
+export class ReviewOverrideRecorder {
+    logPath;
+    constructor(logPath) {
+        this.logPath = logPath ?? resolve(process.cwd(), DEFAULT_OVERRIDE_LOG_PATH);
+    }
+    record(record) {
+        const dir = dirname(this.logPath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        const line = JSON.stringify(record) + '\n';
+        appendFileSync(this.logPath, line, 'utf-8');
+    }
+    getAll() {
+        if (!existsSync(this.logPath)) {
+            return [];
+        }
+        const content = readFileSync(this.logPath, 'utf-8');
+        const records = [];
+        for (const line of content.split(/\r?\n/)) {
+            if (line.trim() === '')
+                continue;
+            try {
+                records.push(JSON.parse(line));
+            }
+            catch {
+                continue;
+            }
+        }
+        return records;
+    }
+    delete() {
+        return {
+            error: 'OVERWRITE_RECORD_IMMUTABLE',
+            message: '覆盖记录不可删除，仅允许追加新的覆盖记录',
+        };
+    }
+    buildRecord(params) {
+        return {
+            assetId: params.assetId,
+            reviewItem: params.reviewItem,
+            originalConclusion: params.originalConclusion,
+            newConclusion: params.newConclusion,
+            overrideReason: params.overrideReason,
+            operator: params.operator,
+            overrideTime: new Date().toISOString(),
+            originalAssetCode: params.originalAssetCode,
+        };
+    }
+}
+//# sourceMappingURL=review-override-recorder.js.map

package/lib/sequential-code-allocator.js

@@ -0,0 +1,22 @@
+export class SequentialCodeAllocator {
+    current;
+    max;
+    start;
+    constructor(config) {
+        this.start = config.sequentialCodeStart;
+        this.current = config.sequentialCodeStart;
+        this.max = config.sequentialCodeMax;
+    }
+    allocate() {
+        if (this.current > this.max) {
+            return null;
+        }
+        const value = this.current;
+        this.current++;
+        return value;
+    }
+    reset() {
+        this.current = this.start;
+    }
+}
+//# sourceMappingURL=sequential-code-allocator.js.map

package/lib/source-adapter.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=source-adapter.js.map

package/lib/types/acceptance-doc-adapter.d.ts

@@ -0,0 +1,11 @@
+import type { UnifiedAssetItem } from './types.js';
+import type { SourceAdapter } from './source-adapter.js';
+export declare class AcceptanceDocAdapter implements SourceAdapter {
+    adapt(sourcePath: string, systemId: string, projectId: string): {
+        assets: UnifiedAssetItem[];
+        warnings: string[];
+        errors: string[];
+    };
+    private mapAcceptanceTypeToDataType;
+}
+//# sourceMappingURL=acceptance-doc-adapter.d.ts.map

package/lib/types/asset-code-generator.d.ts

@@ -0,0 +1,17 @@
+import type { AssetCodeGenerateResult, EncodingRuleConfig, UnifiedAssetItem } from './types.js';
+export interface AssetCodeGenerationResult {
+    assets: UnifiedAssetItem[];
+    errors: string[];
+    warnings: string[];
+    overflowAssets: string[];
+}
+export declare class AssetCodeGenerator {
+    private readonly checksumCalculator;
+    private readonly uniquenessValidator;
+    constructor();
+    generate(classifiedAssets: UnifiedAssetItem[], encodingRuleConfig: EncodingRuleConfig): AssetCodeGenerationResult;
+    regenerateForAsset(asset: UnifiedAssetItem, encodingRuleConfig: EncodingRuleConfig): AssetCodeGenerationResult;
+    generateSingleCode(classificationCode: string, sequentialCode: number, encodingRuleConfig: EncodingRuleConfig): AssetCodeGenerateResult;
+    private padToLength;
+}
+//# sourceMappingURL=asset-code-generator.d.ts.map

package/lib/types/asset-ledger-exporter.d.ts

@@ -0,0 +1,7 @@
+import type { AssetLedgerEntry, UnifiedAssetItem } from './types.js';
+export declare class AssetLedgerExporter {
+    export(assetList: UnifiedAssetItem[], outputPath: string): string;
+    buildLedger(assetList: UnifiedAssetItem[]): AssetLedgerEntry[];
+    exportToPath(assetList: UnifiedAssetItem[], outputPathDir: string): string;
+}
+//# sourceMappingURL=asset-ledger-exporter.d.ts.map

package/lib/types/change-traceability-checker.d.ts

@@ -0,0 +1,11 @@
+import type { ChangeRecord, ChangeTraceabilityResult } from './types.js';
+export interface ChangeTraceabilityCheckResult {
+    results: ChangeTraceabilityResult[];
+    warnings: string[];
+    skipped: boolean;
+}
+export declare class ChangeTraceabilityChecker {
+    check(changeRecords: ChangeRecord[], assetIds: string[]): ChangeTraceabilityCheckResult;
+    checkWithSkip(changeRecords: ChangeRecord[] | null, assetIds: string[]): ChangeTraceabilityCheckResult;
+}
+//# sourceMappingURL=change-traceability-checker.d.ts.map

package/lib/types/checksum-calculator.d.ts

@@ -0,0 +1,7 @@
+export declare class ChecksumCalculator {
+    calculate(code: string, algorithm: string): string;
+    private luhnChecksum;
+    private mod11Checksum;
+    validate(codeWithChecksum: string, algorithm: string): boolean;
+}
+//# sourceMappingURL=checksum-calculator.d.ts.map

package/lib/types/classification-mapper.d.ts

@@ -0,0 +1,12 @@
+import type { ClassificationConfig, UnifiedAssetItem } from './types.js';
+export interface ClassificationMapResult {
+    assets: UnifiedAssetItem[];
+    warnings: string[];
+    unclassified: string[];
+}
+export declare class ClassificationMapper {
+    map(unifiedAssets: UnifiedAssetItem[], classificationConfig: ClassificationConfig | null): ClassificationMapResult;
+    private findMatchingRules;
+    isValidClassificationCode(code: string, config: ClassificationConfig): boolean;
+}
+//# sourceMappingURL=classification-mapper.d.ts.map

package/lib/types/code-uniqueness-validator.d.ts

@@ -0,0 +1,8 @@
+export declare class CodeUniquenessValidator {
+    private readonly codeSet;
+    validate(assetCode: string): boolean;
+    has(assetCode: string): boolean;
+    clear(): void;
+    size(): number;
+}
+//# sourceMappingURL=code-uniqueness-validator.d.ts.map

package/lib/types/construction-config-loader.d.ts

@@ -0,0 +1,11 @@
+import type { ConfigLoadResult } from './types.js';
+export declare class ConstructionConfigLoader {
+    private readonly configPath;
+    constructor(configPath?: string);
+    load(): ConfigLoadResult;
+    private aggregateStatus;
+    private loadClassificationConfig;
+    private loadEncodingRuleConfig;
+    private loadSourceAdapterConfig;
+}
+//# sourceMappingURL=construction-config-loader.d.ts.map

package/lib/types/contract-adapter.d.ts

@@ -0,0 +1,11 @@
+import type { UnifiedAssetItem } from './types.js';
+import type { SourceAdapter } from './source-adapter.js';
+export declare class ContractAdapter implements SourceAdapter {
+    adapt(sourcePath: string, systemId: string, projectId: string): {
+        assets: UnifiedAssetItem[];
+        warnings: string[];
+        errors: string[];
+    };
+    private mapContractTypeToDataType;
+}
+//# sourceMappingURL=contract-adapter.d.ts.map

package/lib/types/default-classification-config.d.ts

@@ -0,0 +1,3 @@
+import type { ClassificationConfig } from './types.js';
+export declare const defaultClassificationConfig: ClassificationConfig;
+//# sourceMappingURL=default-classification-config.d.ts.map

package/lib/types/default-encoding-rule-config.d.ts

@@ -0,0 +1,3 @@
+import type { EncodingRuleConfig } from './types.js';
+export declare const defaultEncodingRuleConfig: EncodingRuleConfig;
+//# sourceMappingURL=default-encoding-rule-config.d.ts.map

package/lib/types/ifc-model-adapter.d.ts

@@ -0,0 +1,14 @@
+import type { IfcParseResult, UnifiedAssetItem } from './types.js';
+import type { SourceAdapter } from './source-adapter.js';
+export declare class IfcModelAdapter implements SourceAdapter {
+    adapt(sourcePath: string, systemId: string, projectId: string): {
+        assets: UnifiedAssetItem[];
+        warnings: string[];
+        errors: string[];
+    };
+    parseIfc(content: string, filePath: string): IfcParseResult;
+    private extractGuid;
+    private extractAttributes;
+    private mapEntityTypeToDataType;
+}
+//# sourceMappingURL=ifc-model-adapter.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,8 @@
+export declare const name = "@liuhange/dsh-construction-data-inventory";
+export declare const inject: readonly ["tools"];
+export declare function apply(ctx: {
+    tools: {
+        register: (tool: unknown) => void;
+    };
+}): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/input-validator.d.ts

@@ -0,0 +1,12 @@
+import type { ChangeRecord, SourceConfig, ValidationResult } from './types.js';
+export declare class InputValidator {
+    validateInspectInput(args: unknown): ValidationResult;
+    validateOverrideInput(args: unknown): ValidationResult;
+    validateSources(sourceConfig: SourceConfig): ValidationResult;
+    isSourceAvailable(sourcePath: string): boolean;
+    validateChangeRecords(changeRecords: unknown): {
+        valid: ChangeRecord[];
+        invalid: string[];
+    };
+}
+//# sourceMappingURL=input-validator.d.ts.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,12 @@
+export declare const PLUGIN_NAME = "@liuhange/dsh-construction-data-inventory";
+export declare const DEFAULT_CLASSIFICATION_CONFIG_PATH = "config/classification-config.json";
+export declare const DEFAULT_ENCODING_RULE_CONFIG_PATH = "config/encoding-rule-config.json";
+export declare const DEFAULT_SOURCE_ADAPTER_CONFIG_PATH = "config/source-adapter-config.json";
+export declare const DEFAULT_OVERRIDE_LOG_PATH = "logs/override-records.log";
+export declare const LEGAL_DISCLAIMER = "\u672C\u62A5\u544A\u7531\u8F85\u52A9\u76D8\u70B9\u5DE5\u5177\u751F\u6210\uFF0C\u4E0D\u66FF\u4EE3GB/T 51269\u6807\u51C6\u7684\u6B63\u5F0F\u5408\u89C4\u8BA4\u8BC1";
+export declare const POLICY_STANDARD_NAME = "\u300A\u5EFA\u7B51\u4FE1\u606F\u6A21\u578B\u5206\u7C7B\u548C\u7F16\u7801\u6807\u51C6\u300B\uFF08GB/T 51269-2017\uFF09";
+export type ErrorCode = 'ASSET_NOT_FOUND' | 'REASON_REQUIRED' | 'OVERWRITE_RECORD_IMMUTABLE' | 'INVALID_CLASSIFICATION_CODE' | 'CHECKSUM_ALGORITHM_MISSING' | 'INPUT_INVALID' | 'CONFIG_NOT_FOUND' | 'SOURCE_UNAVAILABLE' | 'IFC_PARSE_ERROR' | 'SEQUENTIAL_CODE_OVERFLOW' | 'UNKNOWN_ERROR';
+export type ConfigLoadStatus = 'CONFIG_LOADED' | 'DEFAULT_MISSING' | 'DEFAULT_PARSE' | 'DEFAULT_VERSION' | 'DEFAULT_PARTIAL';
+export declare const SUPPORTED_IFC_VERSIONS: readonly ["IFC2X3", "IFC4"];
+export declare const IFC_ENTITY_TYPES: readonly ["IFCWALL", "IFCWALLSTANDARDCASE", "IFCCOLUMN", "IFCCOLUMNSTANDARDCASE", "IFCSLAB", "IFCSLABSTANDARDCASE", "IFCDOOR", "IFCWINDOW", "IFCSPACE", "IFCBUILDINGSTOREY", "IFCBUILDING", "IFCSITE", "IFCROOF", "IFCBEAM", "IFCBEAMSTANDARDCASE", "IFCFOOTING", "IFCSTAIR", "IFCSTAIRFLIGHT", "IFCRAILING", "IFCCURTAINWALL", "IFCPROPERTYSET"];
+//# sourceMappingURL=invariant.d.ts.map

package/lib/types/inventory-report-generator.d.ts

@@ -0,0 +1,22 @@
+import type { ChangeTraceabilityResult, ClassificationEncodingEntry, ConfigVersionSet, InventoryReport, ReviewOverrideRecord, UnifiedAssetItem, ValidationError } from './types.js';
+export declare class InventoryReportGenerator {
+    private readonly policyBasisBuilder;
+    private readonly desensitizer;
+    private readonly ledgerExporter;
+    constructor();
+    generate(params: {
+        assetList: UnifiedAssetItem[];
+        classificationEncodingList: ClassificationEncodingEntry[];
+        changeTraceabilityReport: ChangeTraceabilityResult[];
+        overrideList: ReviewOverrideRecord[];
+        errorList: ValidationError[];
+        configVersions: ConfigVersionSet;
+        projectId: string;
+        skippedChangeTraceability?: boolean;
+    }): InventoryReport;
+    writeJson(report: InventoryReport, outputPathDir: string): string;
+    writeMarkdown(report: InventoryReport, outputPathDir: string): string;
+    exportLedger(assetList: UnifiedAssetItem[], outputPathDir: string): string;
+    private renderMarkdown;
+}
+//# sourceMappingURL=inventory-report-generator.d.ts.map

package/lib/types/policy-basis-builder.d.ts

@@ -0,0 +1,8 @@
+export declare class PolicyBasisBuilder {
+    build(clause: string): string;
+    buildClassification(): string;
+    buildEncoding(): string;
+    buildChangeTraceability(): string;
+    buildSummary(policyBasisList: string[]): string[];
+}
+//# sourceMappingURL=policy-basis-builder.d.ts.map

package/lib/types/progress-record-adapter.d.ts

@@ -0,0 +1,11 @@
+import type { UnifiedAssetItem } from './types.js';
+import type { SourceAdapter } from './source-adapter.js';
+export declare class ProgressRecordAdapter implements SourceAdapter {
+    adapt(sourcePath: string, systemId: string, projectId: string): {
+        assets: UnifiedAssetItem[];
+        warnings: string[];
+        errors: string[];
+    };
+    private mapProcessTypeToDataType;
+}
+//# sourceMappingURL=progress-record-adapter.d.ts.map

package/lib/types/report-desensitizer.d.ts

@@ -0,0 +1,12 @@
+import type { InventoryReport, UnifiedAssetItem } from './types.js';
+export declare class ReportDesensitizer {
+    desensitize(report: InventoryReport): {
+        report: InventoryReport;
+        warnings: string[];
+    };
+    desensitizeAsset(asset: UnifiedAssetItem, warnings: string[]): UnifiedAssetItem;
+    desensitizeRecord(record: Record<string, unknown>): Record<string, unknown>;
+    private desensitizeGenericRecord;
+    private isSensitiveField;
+}
+//# sourceMappingURL=report-desensitizer.d.ts.map

package/lib/types/review-override-recorder.d.ts

@@ -0,0 +1,21 @@
+import type { ReviewOverrideRecord } from './types.js';
+export declare class ReviewOverrideRecorder {
+    private readonly logPath;
+    constructor(logPath?: string);
+    record(record: ReviewOverrideRecord): void;
+    getAll(): ReviewOverrideRecord[];
+    delete(): {
+        error: 'OVERWRITE_RECORD_IMMUTABLE';
+        message: string;
+    };
+    buildRecord(params: {
+        assetId: string;
+        reviewItem: ReviewOverrideRecord['reviewItem'];
+        originalConclusion: string;
+        newConclusion: string;
+        overrideReason: string;
+        operator: string;
+        originalAssetCode: string;
+    }): ReviewOverrideRecord;
+}
+//# sourceMappingURL=review-override-recorder.d.ts.map

package/lib/types/sequential-code-allocator.d.ts

@@ -0,0 +1,10 @@
+import type { EncodingRuleConfig } from './types.js';
+export declare class SequentialCodeAllocator {
+    private current;
+    private readonly max;
+    private readonly start;
+    constructor(config: EncodingRuleConfig);
+    allocate(): number | null;
+    reset(): void;
+}
+//# sourceMappingURL=sequential-code-allocator.d.ts.map

package/lib/types/source-adapter.d.ts

@@ -0,0 +1,9 @@
+import type { UnifiedAssetItem } from './types.js';
+export interface SourceAdapter {
+    adapt(sourcePath: string, systemId: string, projectId: string): {
+        assets: UnifiedAssetItem[];
+        warnings: string[];
+        errors: string[];
+    };
+}
+//# sourceMappingURL=source-adapter.d.ts.map

package/lib/types/types.d.ts

@@ -0,0 +1,157 @@
+import type { ConfigLoadStatus, ErrorCode } from './invariant.js';
+export type JudgmentStatus = '自动判定' | '人工确认';
+export type ReviewItem = 'classification' | 'encoding' | 'changeTraceability';
+export interface UnifiedAssetItem {
+    assetId: string;
+    sourceSystemId: string;
+    dataType: string;
+    projectId: string;
+    collectionTime: string;
+    classificationCode: string;
+    assetCode: string;
+    judgmentStatus: JudgmentStatus;
+    originalAssetCode?: string;
+    policyBasis?: string;
+}
+export interface SourceConfigEntry {
+    type: string;
+    systemId: string;
+    path: string;
+    version?: string;
+}
+export interface SourceConfig {
+    projectId: string;
+    sources: SourceConfigEntry[];
+}
+export interface ApprovalChain {
+    initiator: string;
+    approver: string;
+    approvalTime: string;
+    approvalConclusion: string;
+}
+export interface ChangeRecord {
+    changeId: string;
+    relatedAssetId: string;
+    changeReason: string;
+    approvalChain: ApprovalChain;
+    impactScope: string[];
+    changeDate: string;
+}
+export interface ClassificationNode {
+    classificationCode: string;
+    classificationName: string;
+    parentCode: string;
+    level: number;
+    mappedDataTypes: string[];
+}
+export interface ClassificationConfig {
+    version: string;
+    lastUpdated: string;
+    nodes: ClassificationNode[];
+}
+export interface EncodingRuleConfig {
+    version: string;
+    lastUpdated: string;
+    classificationCodeLength: number;
+    sequentialCodeLength: number;
+    sequentialCodeStart: number;
+    sequentialCodeMax: number;
+    checksumAlgorithm: string;
+}
+export interface SourceAdapterConfigEntry {
+    type: string;
+    adapterClassName: string;
+    supportedVersions: string[];
+}
+export interface SourceAdapterConfig {
+    version: string;
+    lastUpdated: string;
+    adapters: SourceAdapterConfigEntry[];
+}
+export interface ClassificationEncodingEntry {
+    assetId: string;
+    classificationCode: string;
+    assetCode: string;
+    policyBasis: string;
+    judgmentStatus: JudgmentStatus;
+}
+export interface ChangeTraceabilityResult {
+    changeId: string;
+    assetLinked: boolean;
+    recordComplete: boolean;
+    approvalChainComplete: boolean;
+    impactScopeLinked: boolean;
+    missingItems: string[];
+    policyBasis: string;
+}
+export interface ReviewOverrideRecord {
+    assetId: string;
+    reviewItem: ReviewItem;
+    originalConclusion: string;
+    newConclusion: string;
+    overrideReason: string;
+    operator: string;
+    overrideTime: string;
+    originalAssetCode: string;
+}
+export interface AssetLedgerEntry {
+    assetCode: string;
+    classificationCode: string;
+    sourceSystemId: string;
+    inventoryTime: string;
+    judgmentStatus: JudgmentStatus;
+}
+export interface ConfigVersionSet {
+    classificationConfigVersion: string;
+    encodingRuleConfigVersion: string;
+    sourceAdapterConfigVersion: string;
+}
+export interface ValidationError {
+    assetId: string;
+    errorMessage: string;
+}
+export interface InventoryReport {
+    reportId: string;
+    inventoryTime: string;
+    projectId: string;
+    assetList: UnifiedAssetItem[];
+    classificationEncodingList: ClassificationEncodingEntry[];
+    changeTraceabilityReport: ChangeTraceabilityResult[];
+    overrideList: ReviewOverrideRecord[];
+    errorList: ValidationError[];
+    policyBasisSummary: string[];
+    configVersions: ConfigVersionSet;
+    legalDisclaimer: string;
+}
+export interface ConfigLoadResult {
+    classificationConfig: ClassificationConfig;
+    encodingRuleConfig: EncodingRuleConfig;
+    sourceAdapterConfig: SourceAdapterConfig;
+    loadStatus: ConfigLoadStatus;
+}
+export interface ValidationResult {
+    isValid: boolean;
+    errors: ValidationError[];
+}
+export interface IfcEntityRecord {
+    lineId: number;
+    entityType: string;
+    guid: string;
+    attributes: string[];
+}
+export interface IfcParseResult {
+    entities: IfcEntityRecord[];
+    warnings: string[];
+    errors: string[];
+    version: string;
+}
+export interface AssetCodeGenerateResult {
+    assetCode: string;
+    policyBasis: string;
+    error?: ErrorCode;
+}
+export interface ToolError {
+    error: ErrorCode;
+    message: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types/unified-asset-merger.d.ts

@@ -0,0 +1,13 @@
+import type { UnifiedAssetItem } from './types.js';
+export declare class UnifiedAssetMerger {
+    merge(adaptedAssetLists: Array<{
+        assets: UnifiedAssetItem[];
+        warnings: string[];
+        errors: string[];
+    }>): {
+        unifiedAssets: UnifiedAssetItem[];
+        warnings: string[];
+        errors: string[];
+    };
+}
+//# sourceMappingURL=unified-asset-merger.d.ts.map

package/lib/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/lib/unified-asset-merger.js

@@ -0,0 +1,18 @@
+export class UnifiedAssetMerger {
+    merge(adaptedAssetLists) {
+        const unifiedAssets = [];
+        const warnings = [];
+        const errors = [];
+        for (const list of adaptedAssetLists) {
+            if (!list)
+                continue;
+            warnings.push(...(list.warnings ?? []));
+            errors.push(...(list.errors ?? []));
+            for (const asset of list.assets ?? []) {
+                unifiedAssets.push(asset);
+            }
+        }
+        return { unifiedAssets, warnings, errors };
+    }
+}
+//# sourceMappingURL=unified-asset-merger.js.map