@simplysm/sd-cli 6.4.4 → 7.0.8

package/.eslintrc.cjs

@@ -0,0 +1,11 @@
+module.exports = {
+  overrides: [
+    {
+      files: ["*.ts"],
+      parserOptions: {
+        tsconfigRootDir: __dirname,
+        project: "tsconfig.json",
+      }
+    }
+  ]
+};

package/dist/bin/sd-cli.d.ts

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

package/dist/bin/sd-cli.mjs

@@ -0,0 +1,60 @@
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { Logger, LoggerSeverity } from "@simplysm/sd-core-node";
+import { SdCliWorkspace } from "../entry-points/SdCliWorkspace";
+Error.stackTraceLimit = Infinity;
+const argv = yargs(hideBin(process.argv))
+    .version(false)
+    .help("help", "도움말")
+    .alias("help", "h")
+    .options({
+    debug: {
+        type: "boolean",
+        describe: "디버그 로그를 표시할 것인지 여부",
+        default: false
+    }
+})
+    .command("watch", "프로젝트의 각 패키지에 대한 변경감지 빌드를 수행합니다.")
+    .command("build", "프로젝트의 각 패키지에 대한 빌드를 수행합니다.")
+    .command("publish", "프로젝트의 각 패키지를 배포합니다.", (cmd) => cmd
+    .options({
+    "noBuild": {
+        type: "boolean",
+        describe: "빌드를 하지않고 배포합니다.",
+        default: false
+    }
+}))
+    .parseSync();
+if (argv.debug) {
+    process.env["SD_CLI_LOGGER_SEVERITY"] = "DEBUG";
+    Logger.setConfig({
+        console: {
+            level: LoggerSeverity.debug
+        }
+    });
+}
+else {
+    Logger.setConfig({
+        dot: true
+    });
+}
+const logger = Logger.get(["simplysm", "sd-cli", "bin", "sd-cli"]);
+(async () => {
+    if (argv._[0] === "watch") {
+        await new SdCliWorkspace(process.cwd()).watchAsync();
+    }
+    else if (argv._[0] === "build") {
+        await new SdCliWorkspace(process.cwd()).buildAsync();
+    }
+    else if (argv._[0] === "publish") {
+        await new SdCliWorkspace(process.cwd()).publishAsync({
+            noBuild: argv.noBuild
+        });
+    }
+    else {
+        throw new Error(`명령어가 잘못 되었습니다.\n\t${argv._[0]}\n`);
+    }
+})().catch((err) => {
+    logger.error(err);
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/build-tool/SdCliCacheCompilerHost.d.ts

@@ -0,0 +1,10 @@
+import ts from "typescript";
+export declare class SdCliCacheCompilerHost {
+    static create(parsedTsconfig: ts.ParsedCommandLine, moduleResolutionCache: ts.ModuleResolutionCache, sourceFileCache: Map<string, IFileCache>, outputFileCache: Map<string, string>): ts.CompilerHost;
+}
+interface IFileCache {
+    exists?: boolean;
+    sourceFile?: ts.SourceFile;
+    content?: string;
+}
+export {};

package/dist/build-tool/SdCliCacheCompilerHost.mjs

@@ -0,0 +1,44 @@
+import ts from "typescript";
+import { PathUtil } from "@simplysm/sd-core-node";
+export class SdCliCacheCompilerHost {
+    static create(parsedTsconfig, moduleResolutionCache, sourceFileCache, outputFileCache) {
+        const compilerHost = ts.createIncrementalCompilerHost(parsedTsconfig.options);
+        const cacheCompilerHost = { ...compilerHost };
+        cacheCompilerHost.fileExists = (fileName) => {
+            const cache = sourceFileCache.getOrCreate(PathUtil.posix(fileName), {});
+            if (cache.exists === undefined) {
+                cache.exists = compilerHost.fileExists.call(cacheCompilerHost, fileName);
+            }
+            return cache.exists;
+        };
+        cacheCompilerHost.getSourceFile = (fileName, languageVersion) => {
+            const cache = sourceFileCache.getOrCreate(PathUtil.posix(fileName), {});
+            if (!cache.sourceFile) {
+                cache.sourceFile = compilerHost.getSourceFile.call(cacheCompilerHost, fileName, languageVersion);
+            }
+            return cache.sourceFile;
+        };
+        cacheCompilerHost.writeFile = (fileName, data, writeByteOrderMark, onError, sourceFiles) => {
+            fileName = fileName.replace(/\.js(\.map)?$/, ".mjs$1");
+            const writeCache = outputFileCache.get(PathUtil.posix(fileName));
+            if (writeCache !== data) {
+                outputFileCache.set(PathUtil.posix(fileName), data);
+                compilerHost.writeFile.call(cacheCompilerHost, fileName, data, writeByteOrderMark, onError, sourceFiles);
+            }
+        };
+        cacheCompilerHost.readFile = (fileName) => {
+            const cache = sourceFileCache.getOrCreate(PathUtil.posix(fileName), {});
+            if (cache.content === undefined) {
+                cache.content = compilerHost.readFile.call(cacheCompilerHost, fileName);
+            }
+            return cache.content;
+        };
+        cacheCompilerHost.resolveModuleNames = (moduleNames, containingFile) => {
+            return moduleNames.map((moduleName) => {
+                return ts.resolveModuleName(moduleName, PathUtil.posix(containingFile), parsedTsconfig.options, compilerHost, moduleResolutionCache).resolvedModule;
+            });
+        };
+        return cacheCompilerHost;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/build-tool/SdCliNgCacheCompilerHost.d.ts

@@ -0,0 +1,11 @@
+import ts from "typescript";
+export declare class SdCliNgCacheCompilerHost {
+    static wrap(compilerHost: ts.CompilerHost, sourceFileCache: Map<string, IFileCache>): ts.CompilerHost;
+}
+interface IFileCache {
+    exists?: boolean;
+    sourceFile?: ts.SourceFile;
+    content?: string;
+    styleContent?: string;
+}
+export {};

package/dist/build-tool/SdCliNgCacheCompilerHost.mjs

@@ -0,0 +1,36 @@
+import { PathUtil } from "@simplysm/sd-core-node";
+import sass from "sass";
+import { pathToFileURL, URL } from "url";
+export class SdCliNgCacheCompilerHost {
+    static wrap(compilerHost, sourceFileCache) {
+        const cacheCompilerHost = { ...compilerHost };
+        cacheCompilerHost["readResource"] = (fileName) => {
+            const cache = sourceFileCache.getOrCreate(PathUtil.posix(fileName), {});
+            if (cache.content === undefined) {
+                cache.content = compilerHost.readFile.call(cacheCompilerHost, fileName);
+            }
+            return cache.content;
+        };
+        cacheCompilerHost["transformResource"] = async (data, context) => {
+            if (context.resourceFile || context.type !== "style") {
+                return null;
+            }
+            const cache = sourceFileCache.getOrCreate(PathUtil.posix(context.containingFile), {});
+            if (cache.styleContent === undefined) {
+                cache.styleContent = (await sass.compileStringAsync(data, {
+                    url: new URL(context.containingFile + ".sd.scss"),
+                    importer: {
+                        findFileUrl: (url) => {
+                            if (!url.startsWith("~"))
+                                return undefined;
+                            return new URL(url.substring(1), pathToFileURL("node_modules"));
+                        }
+                    }
+                })).css.toString();
+            }
+            return { content: cache.styleContent };
+        };
+        return cacheCompilerHost;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/build-tool/SdCliPackageLinter.d.ts

@@ -0,0 +1,8 @@
+import { ISdCliPackageBuildResult } from "../commons";
+import ts from "typescript";
+export declare class SdCliPackageLinter {
+    private readonly _rootPath;
+    private readonly _lintResultCache;
+    constructor(_rootPath: string);
+    lintAsync(filePaths: string[], program?: ts.Program): Promise<ISdCliPackageBuildResult[]>;
+}

package/dist/build-tool/SdCliPackageLinter.mjs

@@ -0,0 +1,41 @@
+import { FsUtil } from "@simplysm/sd-core-node";
+import path from "path";
+import { ESLint } from "eslint";
+export class SdCliPackageLinter {
+    constructor(_rootPath) {
+        this._rootPath = _rootPath;
+        this._lintResultCache = new Map();
+    }
+    async lintAsync(filePaths, program) {
+        if (!FsUtil.exists(path.resolve(this._rootPath, ".eslintrc.cjs")))
+            return [];
+        const linter = new ESLint(program && filePaths.some((item) => item.endsWith(".ts")) ? {
+            overrideConfig: {
+                parserOptions: { program }
+            }
+        } : {});
+        const lintFilePaths = await filePaths
+            .filterAsync(async (filePath) => (!filePath.endsWith(".d.ts") &&
+            !(await linter.isPathIgnored(filePath))));
+        for (const lintFilePath of lintFilePaths) {
+            this._lintResultCache.delete(lintFilePath);
+        }
+        const lintResults = await linter.lintFiles(lintFilePaths);
+        const result = lintResults.map((lintResult) => ({
+            filePath: lintResult.filePath,
+            results: lintResult.messages.map((msg) => ({
+                filePath: lintResult.filePath,
+                line: msg.line,
+                char: msg.column,
+                code: msg.ruleId ?? undefined,
+                severity: msg.severity === 1 ? "warning" : "error",
+                message: msg.message
+            }))
+        }));
+        for (const resultItem of result) {
+            this._lintResultCache.set(resultItem.filePath, resultItem.results);
+        }
+        return Array.from(this._lintResultCache.values()).mapMany();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/builder/SdCliJsLibBuilder.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import { ISdCliPackageBuildResult } from "../commons";
+import { EventEmitter } from "events";
+export declare class SdCliJsLibBuilder extends EventEmitter {
+    private readonly _rootPath;
+    private readonly _logger;
+    private readonly _linter;
+    constructor(_rootPath: string);
+    on(event: "change", listener: () => void): this;
+    on(event: "complete", listener: (results: ISdCliPackageBuildResult[]) => void): this;
+    watchAsync(): Promise<void>;
+    buildAsync(): Promise<ISdCliPackageBuildResult[]>;
+    private getRelatedPathsAsync;
+}

package/dist/builder/SdCliJsLibBuilder.mjs

@@ -0,0 +1,50 @@
+import { EventEmitter } from "events";
+import { FsUtil, Logger, SdFsWatcher } from "@simplysm/sd-core-node";
+import * as path from "path";
+import { SdCliPackageLinter } from "../build-tool/SdCliPackageLinter";
+export class SdCliJsLibBuilder extends EventEmitter {
+    constructor(_rootPath) {
+        super();
+        this._rootPath = _rootPath;
+        this._logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
+        this._linter = new SdCliPackageLinter(this._rootPath);
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    async watchAsync() {
+        this.emit("change");
+        const relatedPaths = await this.getRelatedPathsAsync();
+        const watcher = SdFsWatcher.watch(relatedPaths);
+        watcher.onChange(async (changeInfos) => {
+            const changeFilePaths = changeInfos.filter((item) => ["add", "change", "unlink"].includes(item.event)).map((item) => item.path);
+            if (changeFilePaths.length === 0)
+                return;
+            this._logger.debug("파일 변경 감지", changeInfos);
+            this.emit("change");
+            const watchBuildResults = await this._linter.lintAsync(changeFilePaths);
+            const watchRelatedPaths = await this.getRelatedPathsAsync();
+            watcher.add(watchRelatedPaths);
+            this.emit("complete", watchBuildResults);
+        });
+        // 빌드
+        const buildResults = await this._linter.lintAsync(relatedPaths);
+        this.emit("complete", buildResults);
+    }
+    async buildAsync() {
+        const relatedPaths = await this.getRelatedPathsAsync();
+        return await this._linter.lintAsync(relatedPaths);
+    }
+    async getRelatedPathsAsync() {
+        const mySourceGlobPath = path.resolve(this._rootPath, "**", "+(*.js|*.cjs|*.mjs|*.ts)");
+        const mySourceFilePaths = await FsUtil.globAsync(mySourceGlobPath, {
+            ignore: [
+                "**/node_modules/**",
+                "**/dist/**",
+                "**/.*/**"
+            ]
+        });
+        return [...mySourceFilePaths, path.resolve(this._rootPath, ".eslintrc.cjs")].distinct();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/builder/SdCliTsLibBuilder.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import { ISdCliPackageBuildResult } from "../commons";
+import { EventEmitter } from "events";
+export declare class SdCliTsLibBuilder extends EventEmitter {
+    private readonly _rootPath;
+    private readonly _isAngular;
+    private readonly _logger;
+    private _moduleResolutionCache?;
+    private readonly _linter;
+    private readonly _fileCache;
+    private readonly _writeFileCache;
+    private _program?;
+    private _ngProgram?;
+    private _builder?;
+    constructor(_rootPath: any, _isAngular: boolean);
+    on(event: "change", listener: () => void): this;
+    on(event: "complete", listener: (results: ISdCliPackageBuildResult[]) => void): this;
+    watchAsync(): Promise<void>;
+    buildAsync(): Promise<ISdCliPackageBuildResult[]>;
+    private getAllRelatedPathsAsync;
+    private _runBuilderAsync;
+    private _createSdBuildPack;
+    private _createProgram;
+    private _configProgramSourceFileVersions;
+    private _createCacheCompilerHost;
+    private _getParsedTsconfigAsync;
+}

package/dist/builder/SdCliTsLibBuilder.mjs

@@ -0,0 +1,226 @@
+import { EventEmitter } from "events";
+import ts from "typescript";
+import { FsUtil, Logger, PathUtil, SdFsWatcher } from "@simplysm/sd-core-node";
+import * as path from "path";
+import { createHash } from "crypto";
+import { SdBuildResultUtil } from "../utils/SdBuildResultUtil";
+import { NgtscProgram } from "@angular/compiler-cli";
+import sass from "sass";
+import { SdCliPackageLinter } from "../build-tool/SdCliPackageLinter";
+import { SdCliCacheCompilerHost } from "../build-tool/SdCliCacheCompilerHost";
+import { SdCliNgCacheCompilerHost } from "../build-tool/SdCliNgCacheCompilerHost";
+export class SdCliTsLibBuilder extends EventEmitter {
+    constructor(_rootPath, _isAngular) {
+        super();
+        this._rootPath = _rootPath;
+        this._isAngular = _isAngular;
+        this._logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
+        this._fileCache = new Map();
+        this._writeFileCache = new Map();
+        this._linter = new SdCliPackageLinter(this._rootPath);
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    async watchAsync() {
+        this.emit("change");
+        // TSCONFIG 읽기
+        const parsedTsconfig = await this._getParsedTsconfigAsync();
+        // DIST 비우기
+        await FsUtil.removeAsync(parsedTsconfig.options.outDir);
+        // 프로그램 리로드
+        const buildPack = this._createSdBuildPack(parsedTsconfig);
+        const relatedPaths = await this.getAllRelatedPathsAsync();
+        const watcher = SdFsWatcher.watch(relatedPaths);
+        watcher.onChange(async (changeInfos) => {
+            const changeFilePaths = changeInfos.filter((item) => ["add", "change", "unlink"].includes(item.event)).map((item) => item.path);
+            if (changeFilePaths.length === 0)
+                return;
+            this._logger.debug("파일 변경 감지", changeInfos);
+            this.emit("change");
+            // 캐쉬 삭제
+            for (const changeFilePath of changeFilePaths) {
+                this._fileCache.delete(PathUtil.posix(changeFilePath));
+            }
+            // 빌드
+            const watchBuildPack = this._createSdBuildPack(parsedTsconfig);
+            // 린트
+            const watchBuildResults = await this._runBuilderAsync(watchBuildPack.builder, watchBuildPack.ngCompiler);
+            watchBuildResults.push(...await this._linter.lintAsync([
+                ...watchBuildPack.affectedSourceFiles.map((item) => item.fileName),
+                ...changeFilePaths
+            ], watchBuildPack.program));
+            const watchRelatedPaths = await this.getAllRelatedPathsAsync();
+            watcher.add(watchRelatedPaths);
+            this.emit("complete", watchBuildResults);
+        });
+        // 빌드
+        const buildResults = await this._runBuilderAsync(buildPack.builder, buildPack.ngCompiler);
+        // 린트
+        buildResults.push(...await this._linter.lintAsync(relatedPaths, buildPack.program));
+        this.emit("complete", buildResults);
+    }
+    async buildAsync() {
+        // TSCONFIG 읽기
+        const parsedTsconfig = await this._getParsedTsconfigAsync();
+        // DIST 비우기
+        await FsUtil.removeAsync(parsedTsconfig.options.outDir);
+        // 프로그램 리로드
+        const buildPack = this._createSdBuildPack(parsedTsconfig);
+        // 빌드
+        const buildResults = await this._runBuilderAsync(buildPack.builder, buildPack.ngCompiler);
+        // 린트
+        const relatedPaths = await this.getAllRelatedPathsAsync();
+        buildResults.push(...await this._linter.lintAsync(relatedPaths, buildPack.program));
+        return buildResults;
+    }
+    async getAllRelatedPathsAsync() {
+        const fileCachePaths = Array.from(this._fileCache.keys());
+        const mySourceGlobPath = path.resolve(this._rootPath, "**", "+(*.js|*.cjs|*.mjs|*.ts)");
+        const mySourceFilePaths = await FsUtil.globAsync(mySourceGlobPath, {
+            ignore: [
+                "**/node_modules/**",
+                "**/dist/**",
+                "**/.*/**"
+            ]
+        });
+        return [...fileCachePaths, ...mySourceFilePaths, path.resolve(this._rootPath, ".eslintrc.cjs")].distinct();
+    }
+    async _runBuilderAsync(builder, ngCompiler) {
+        try {
+            const results = [];
+            const diagnostics = [];
+            if (ngCompiler) {
+                diagnostics.push(...ngCompiler.getOptionDiagnostics());
+            }
+            diagnostics.push(...builder.getOptionsDiagnostics(), ...builder.getGlobalDiagnostics());
+            if (ngCompiler) {
+                await ngCompiler.analyzeAsync();
+            }
+            for (const sourceFile of builder.getSourceFiles()) {
+                if (ngCompiler?.ignoreForDiagnostics.has(sourceFile))
+                    continue;
+                diagnostics.push(...builder.getSyntacticDiagnostics(sourceFile), ...builder.getSemanticDiagnostics(sourceFile));
+                if (ngCompiler &&
+                    !sourceFile.isDeclarationFile &&
+                    !ngCompiler.ignoreForEmit.has(sourceFile) &&
+                    !ngCompiler.incrementalDriver.safeToSkipEmit(sourceFile)) {
+                    diagnostics.push(...ngCompiler.getDiagnosticsForFile(sourceFile, 1));
+                }
+            }
+            results.push(...diagnostics
+                .filter((item) => [ts.DiagnosticCategory.Error, ts.DiagnosticCategory.Warning].includes(item.category))
+                .map((item) => SdBuildResultUtil.convertDiagsToResult(item))
+                .filterExists());
+            if (results.some((item) => item.severity === "error")) {
+                return results;
+            }
+            const transformers = ngCompiler?.prepareEmit().transformers;
+            for (const sourceFile of builder.getSourceFiles()) {
+                if (ngCompiler?.ignoreForEmit.has(sourceFile))
+                    continue;
+                builder.emit(sourceFile, undefined, undefined, undefined, transformers);
+            }
+            return results;
+        }
+        catch (err) {
+            if (err instanceof sass.Exception) {
+                const matches = err.sassStack.match(/^(.*\.sd\.scss) ([0-9]*):([0-9]*)/);
+                const filePath = path.resolve(matches[1].replace(/\.sd\.scss/, "").replace(/^\.:/, item => item.toUpperCase()));
+                const scssLine = matches[2];
+                const scssChar = matches[3];
+                const message = err.sassMessage;
+                return [{
+                        filePath,
+                        line: undefined,
+                        char: undefined,
+                        code: undefined,
+                        severity: "error",
+                        message: `스타일(${scssLine}:${scssChar}): ${message}`
+                    }];
+            }
+            return [{
+                    filePath: undefined,
+                    line: undefined,
+                    char: undefined,
+                    code: undefined,
+                    severity: "error",
+                    message: err.message
+                }];
+        }
+    }
+    _createSdBuildPack(parsedTsconfig) {
+        const compilerHost = this._createCacheCompilerHost(parsedTsconfig);
+        const { program, ngCompiler } = this._createProgram(parsedTsconfig, compilerHost);
+        this._builder = ts.createEmitAndSemanticDiagnosticsBuilderProgram(program, compilerHost, this._builder);
+        const affectedSourceFileSet = new Set();
+        while (true) {
+            const result = this._builder.getSemanticDiagnosticsOfNextAffectedFile(undefined, (sourceFile) => {
+                if (ngCompiler && ngCompiler.ignoreForDiagnostics.has(sourceFile) && sourceFile.fileName.endsWith(".ngtypecheck.ts")) {
+                    const orgFileName = sourceFile.fileName.slice(0, -15) + ".ts";
+                    const orgSourceFile = this._builder.getSourceFile(orgFileName);
+                    if (orgSourceFile) {
+                        affectedSourceFileSet.add(orgSourceFile);
+                    }
+                    return true;
+                }
+                return false;
+            });
+            if (!result)
+                break;
+            affectedSourceFileSet.add(result.affected);
+        }
+        return {
+            program,
+            ngCompiler,
+            builder: this._builder,
+            affectedSourceFiles: Array.from(affectedSourceFileSet.values())
+        };
+    }
+    _createProgram(parsedTsconfig, compilerHost) {
+        if (this._isAngular) {
+            this._ngProgram = new NgtscProgram(parsedTsconfig.fileNames, parsedTsconfig.options, compilerHost, this._ngProgram);
+            this._program = this._ngProgram.getTsProgram();
+            this._configProgramSourceFileVersions(this._program);
+            return {
+                program: this._program,
+                ngCompiler: this._ngProgram.compiler
+            };
+        }
+        else {
+            this._program = ts.createProgram(parsedTsconfig.fileNames, parsedTsconfig.options, compilerHost, this._program);
+            this._configProgramSourceFileVersions(this._program);
+            return { program: this._program };
+        }
+    }
+    _configProgramSourceFileVersions(program) {
+        const baseGetSourceFiles = program.getSourceFiles;
+        program.getSourceFiles = function (...parameters) {
+            const files = baseGetSourceFiles(...parameters);
+            for (const file of files) {
+                if (file.version === undefined) {
+                    file.version = createHash("sha256").update(file.text).digest("hex");
+                }
+            }
+            return files;
+        };
+    }
+    _createCacheCompilerHost(parsedTsconfig) {
+        if (!this._moduleResolutionCache) {
+            this._moduleResolutionCache = ts.createModuleResolutionCache(this._rootPath, (s) => s, parsedTsconfig.options);
+        }
+        const compilerHost = SdCliCacheCompilerHost.create(parsedTsconfig, this._moduleResolutionCache, this._fileCache, this._writeFileCache);
+        if (this._isAngular) {
+            return SdCliNgCacheCompilerHost.wrap(compilerHost, this._fileCache);
+        }
+        else {
+            return compilerHost;
+        }
+    }
+    async _getParsedTsconfigAsync() {
+        const tsconfigFilePath = path.resolve(this._rootPath, "tsconfig-build.json");
+        const tsconfig = await FsUtil.readJsonAsync(tsconfigFilePath);
+        return ts.parseJsonConfigFileContent(tsconfig, ts.sys, this._rootPath);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SdCliTsLibBuilder.js","sourceRoot":"","sources":["../../src/builder/SdCliTsLibBuilder.ts"],"names":[],"mappings":"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"}

package/dist/commons.d.ts

@@ -0,0 +1,43 @@
+export interface INpmConfig {
+    name: string;
+    version: string;
+    workspaces?: string[];
+    es2020?: string;
+    browser?: string;
+    module?: string;
+    main?: string;
+    exports?: Record<string, {
+        types?: string;
+    }>;
+    scripts?: Record<string, string>;
+    dependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+}
+export interface ITsconfig {
+    compilerOptions?: {
+        outDir?: string;
+        baseUrl?: string;
+        paths?: Record<string, string[]>;
+    };
+}
+export interface ISdCliPackageBuildResult {
+    filePath: string | undefined;
+    line: number | undefined;
+    char: number | undefined;
+    code: string | undefined;
+    severity: "error" | "warning";
+    message: string;
+}
+export interface ISdCliWorkspaceConfig {
+    packages: Record<string, TSdCliPackageConfig | undefined>;
+}
+export declare type TSdCliPackageConfig = ISdCliLibPackageConfig | ISdCliNgLibPackageConfig;
+export interface ISdCliLibPackageConfig {
+    type: "library";
+    publish?: "npm";
+}
+export interface ISdCliNgLibPackageConfig {
+    type: "angular";
+}

package/dist/commons.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9jb21tb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==