@cxl/build 0.0.2 → 0.2.1

package/lint.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eslint = eslint;
+const path_1 = require("path");
+const rx_1 = require("@cxl/rx");
+const builder_js_1 = require("./builder.js");
+function handleEslintResult(results) {
+    const result = [];
+    let hasErrors = false;
+    results.forEach(result => {
+        const errorCount = result.errorCount;
+        const file = (0, path_1.relative)(process.cwd(), result.filePath);
+        (0, builder_js_1.appLog)(`eslint ${file}`);
+        if (errorCount) {
+            hasErrors = true;
+            result.messages.forEach(r => console.error(`${file}#${r.line}:${r.column}: ${r.message} (${r.ruleId})`));
+        }
+    });
+    if (hasErrors)
+        throw new Error('eslint errors found.');
+    return result;
+}
+function eslint(options) {
+    return new rx_1.Observable(subs => {
+        const eslintPath = require.resolve('eslint', {
+            paths: [process.cwd(), __dirname],
+        });
+        const { ESLint } = require(eslintPath);
+        (0, builder_js_1.appLog)(`eslint ${ESLint.version} (${eslintPath})`);
+        const linter = new ESLint({
+            cache: true,
+            cwd: process.cwd(),
+            // fix: true,
+            ...options,
+        });
+        linter
+            .lintFiles(['**/*.ts?(x)'])
+            .then(handleEslintResult)
+            .then(() => subs.complete(), e => subs.error(e));
+    });
+}

package/npm.d.ts

@@ -0,0 +1,38 @@
+export type License = 'GPL-3.0' | 'GPL-3.0-only' | 'Apache-2.0' | 'UNLICENSED' | 'SEE LICENSE IN LICENSE.txt';
+export type Dependencies = Record<string, string>;
+export interface Package {
+    name: string;
+    version: string;
+    description: string;
+    license: License;
+    files: string[];
+    main: string;
+    bin?: string;
+    keywords?: string[];
+    browser?: string;
+    homepage: string;
+    private: boolean;
+    bugs: string;
+    repository: string | {
+        type: 'git';
+        url: string;
+        directory?: string;
+    };
+    dependencies?: Dependencies;
+    devDependencies?: Dependencies;
+    peerDependencies?: Dependencies;
+    bundledDependecies?: Dependencies;
+    type?: string;
+    scripts?: Record<string, string>;
+}
+export interface PackageInfo extends Package {
+    'dist-tags': Record<string, string>;
+    versions: string[];
+    time: Record<string, string>;
+}
+export declare function readPackage(path: string): Promise<Package>;
+export declare function getLatestVersion(packageName: string, tag?: string): Promise<string | undefined>;
+export declare function isPackageVersionPublished(packageName: string, version: string): Promise<boolean>;
+export declare function testPackage(dir: string): Promise<void>;
+export declare function publishNpm(dir: string): Promise<void>;
+export declare function getPackageInfo(name: string): Promise<PackageInfo>;

package/npm.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPackage = readPackage;
+exports.getLatestVersion = getLatestVersion;
+exports.isPackageVersionPublished = isPackageVersionPublished;
+exports.testPackage = testPackage;
+exports.publishNpm = publishNpm;
+exports.getPackageInfo = getPackageInfo;
+const program_1 = require("@cxl/program");
+const promises_1 = require("fs/promises");
+const git_js_1 = require("./git.js");
+const path_1 = require("path");
+async function readPackage(path) {
+    return JSON.parse(await (0, promises_1.readFile)(path, 'utf8'));
+}
+async function getLatestVersion(packageName, tag = 'latest') {
+    const info = await getPackageInfo(packageName);
+    return info?.['dist-tags'][tag] || undefined;
+}
+async function isPackageVersionPublished(packageName, version) {
+    const info = await getPackageInfo(packageName);
+    return info.versions.includes(version);
+}
+async function testPackage(dir) {
+    const cwd = (0, path_1.resolve)(`dist/${dir}`);
+    if (!cwd.startsWith(process.cwd()))
+        throw `"${cwd}" should be under current working directory`;
+    await (0, program_1.sh)(`npm install --production`, { cwd });
+    try {
+        await (0, program_1.sh)(`npm test`, { cwd: dir });
+    }
+    finally {
+        await (0, program_1.sh)(`rm -rf ${cwd}/node_modules package-lock.json`);
+    }
+}
+async function publishNpm(dir) {
+    const branch = await (0, git_js_1.getBranch)(process.cwd());
+    if (branch !== 'master')
+        throw `Active branch "${branch}" is not master`;
+    const pkg = await readPackage(`${dir}/package.json`);
+    await (0, git_js_1.checkBranchClean)('master');
+    const info = await getPackageInfo(pkg.name);
+    if (info.versions.includes(pkg.version)) {
+        console.log(`Package "${pkg.name}" version "${pkg.version}" already published. Skipping.`);
+    }
+    else {
+        console.log(`Building ${pkg.name} ${pkg.version}`);
+        await (0, program_1.sh)(`npm run build package --prefix ${dir}`);
+        await testPackage(dir);
+        const distDir = `dist/${dir}`;
+        const tag = pkg.version.includes('beta') ? 'beta' : 'latest';
+        const removeVersion = tag === 'beta' ? info['dist-tags'].beta : undefined;
+        console.log(await (0, program_1.sh)(`npm publish --access=public --tag ${tag}`, {
+            cwd: distDir,
+        }));
+        if (tag === 'beta') {
+            const baseTag = `${pkg.version.split('.')[0]}-beta`;
+            console.log(await (0, program_1.sh)(`npm dist-tag add ${pkg.name}@${pkg.version} ${baseTag}`));
+        }
+        if (removeVersion)
+            console.log(await (0, program_1.sh)(`npm unpublish ${pkg.name}@${removeVersion}`));
+    }
+    // Create Release Tag if it doesn't exist already
+    const gitTag = `${dir}/${pkg.version}`;
+    if (!(await (0, program_1.sh)(`git tag -l ${gitTag}`)).trim()) {
+        console.log(`Creating tag "${gitTag}"`);
+        await (0, program_1.sh)(`git tag ${gitTag} && git push origin ${gitTag}`);
+    }
+}
+async function getPackageInfo(name) {
+    return JSON.parse((await (0, program_1.sh)(`npm show ${name} --json`)).trim());
+}

package/package.d.ts

@@ -0,0 +1,70 @@
+import { Observable } from '@cxl/rx';
+import { Output } from '@cxl/source';
+import { Package } from './npm.js';
+import * as ts from 'typescript';
+export declare const BASEDIR: string;
+export declare function readPackage(base?: string): Package;
+export declare function docs(dirName: string, devMode?: boolean): Observable<any, "none">;
+export interface DocgenOptions {
+    file: string | string[];
+    name: string;
+    npm?: string;
+    setup?: string;
+    repo?: string;
+    repodir?: string;
+    typeRoots?: string;
+    sitemapBase?: string;
+    scripts?: string;
+    packageJson?: string;
+    docsJson?: string;
+    cwd?: string;
+    forceInstall?: boolean;
+    markdown?: boolean;
+    baseHref?: string;
+    tag: string;
+    outDir?: string;
+    tmpDir?: string;
+    rootDir?: string;
+    customJsDocTags?: string[];
+    exports?: string[];
+    summary?: boolean;
+    followReferences?: boolean;
+    cxlExtensions?: boolean;
+    headHtml?: string;
+}
+export declare function docgen(options: DocgenOptions): Promise<{
+    name: string;
+    version: string;
+    description: string;
+    sitemap: string;
+}>;
+export declare function docgenTask(packages: DocgenOptions[], commonOptions?: Partial<DocgenOptions>): Observable<{
+    path: string;
+    source: Buffer<ArrayBuffer>;
+}, "none">;
+/**
+ * Generate README file
+ */
+export declare function readme(): Observable<{
+    path: string;
+    source: Buffer<ArrayBuffer>;
+}, "none">;
+export declare function pkg(): Observable<Output, "none">;
+export declare function AMD(): Observable<Output, "none">;
+export declare function bundle(files: Record<string, string>, outFile: string, config?: ts.CompilerOptions): Observable<Output, "none">;
+export declare function bundleAmd(files: Record<string, string>, outFile: string): Observable<Output, "none">;
+export declare const REQUIRE_REPLACE = "\n\trequire.replace = function (path) {\n\t\treturn path.replace(\n\t\t\t/^@cxl\\/workspace\\.(.+)/,\n\t\t\t(str, p1) =>\n\t\t\t\t`/cxl.app/dist/${str.endsWith('.js') ? p1 : p1 + '/index.js'}`\n\t\t).replace(\n\t\t\t/^@cxl\\/(ui.*)/,\n\t\t\t(str, p1) =>\n\t\t\t\t`/ui/dist/${str.endsWith('.js') ? p1 : p1 + '/index.js'}`\n\t\t).replace(\n\t\t\t/^@cxl\\/(.+)/,\n\t\t\t(str, p1) =>\n\t\t\t\t`/cxl/dist/${str.endsWith('.js') ? p1 : p1 + '/index.js'}`\n\t\t);\n\t};\n";
+interface TemplateConfig {
+    header: string;
+    debugHeader: string;
+}
+export declare function template(filename: string, config?: Partial<TemplateConfig>): Observable<{
+    path: string;
+    source: string;
+}, "none">;
+export interface PublishConfiguration {
+    s3Path: string;
+    environment: 'dev' | 'prod';
+}
+export declare function deployS3({ environment, s3Path }: PublishConfiguration): Observable<never, "none">;
+export {};

package/package.js

@@ -0,0 +1,337 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REQUIRE_REPLACE = exports.BASEDIR = void 0;
+exports.readPackage = readPackage;
+exports.docs = docs;
+exports.docgen = docgen;
+exports.docgenTask = docgenTask;
+exports.readme = readme;
+exports.pkg = pkg;
+exports.AMD = AMD;
+exports.bundle = bundle;
+exports.bundleAmd = bundleAmd;
+exports.template = template;
+exports.deployS3 = deployS3;
+const rx_1 = require("@cxl/rx");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const file_js_1 = require("./file.js");
+const child_process_1 = require("child_process");
+const program_1 = require("@cxl/program");
+const builder_js_1 = require("./builder.js");
+const npm_js_1 = require("./npm.js");
+const ts = require("typescript");
+const SCRIPTDIR = process.cwd();
+exports.BASEDIR = (0, child_process_1.execSync)(`npm prefix`, { cwd: SCRIPTDIR })
+    .toString()
+    .trim();
+const LICENSE_MAP = {
+    'GPL-3.0': 'license-GPL-3.0.txt',
+    'GPL-3.0-only': 'license-GPL-3.0.txt',
+    'Apache-2.0': 'license-Apache-2.0.txt',
+    'SEE LICENSE IN LICENSE.txt': '',
+    UNLICENSED: '',
+};
+function verifyFields(fields, pkg) {
+    for (const f of fields)
+        if (!pkg[f])
+            throw new Error(`Field "${f}" missing in package.json`);
+}
+function readPackage(base = exports.BASEDIR) {
+    const pkg = base + '/package.json';
+    if (!(0, fs_1.existsSync)(pkg))
+        throw new Error('package.json not found');
+    const PACKAGE = JSON.parse((0, fs_1.readFileSync)(pkg, 'utf8'));
+    verifyFields(['name', 'version', 'description'], PACKAGE);
+    if (!PACKAGE.private)
+        verifyFields(['license'], PACKAGE);
+    return PACKAGE;
+}
+function docs(dirName, devMode = false) {
+    const docgen = (0, path_1.join)(__dirname, '../docgen');
+    return new rx_1.Observable(subs => {
+        const cmd = `node ${docgen} --clean ${devMode ? '--debug' : ''} -o ../docs/${dirName} --summary --markdown --cxlExtensions`;
+        console.log(cmd);
+        (0, program_1.sh)(cmd).then(out => (console.log(out), subs.complete()), e => subs.error(e));
+    });
+}
+async function docgen(options) {
+    const { name, tag, repo, file, setup, npm, tmpDir, typeRoots, scripts, sitemapBase, packageJson, docsJson, forceInstall, baseHref, rootDir, customJsDocTags, exports, summary, followReferences, cxlExtensions, headHtml, } = options;
+    const repodir = options.repodir ||
+        `${name.replace('/', '--')}-${tag.replace('/', '--')}`;
+    const dir = (0, path_1.join)(tmpDir || '', repodir, npm ? `/node_modules/${npm}` : ``);
+    const cwd = (0, path_1.join)(dir, options.cwd || '');
+    const outDir = (0, path_1.resolve)(options.outDir || 'docs');
+    const files = Array.isArray(file)
+        ? file.map(f => `--file ${f}`).join(' ')
+        : `--tsconfig ${file}`;
+    const pkg = (0, path_1.join)(cwd, packageJson || 'package.json');
+    const install = repo
+        ? `git clone ${repo} --branch=${tag} --depth=1 ${repodir};
+cd ${repodir} ${setup ? `&& ${setup}` : ''}`
+        : `mkdir -p ${repodir} && npm install --prefix ./${repodir} ${npm}@${tag}`;
+    const DOCGEN = (0, path_1.join)(__dirname, '../docgen');
+    if (forceInstall)
+        await (0, program_1.sh)(`mkdir -p ${tmpDir} && cd ${tmpDir} && rm -rf ${repodir} && ${install}`);
+    else
+        await (0, program_1.sh)(`if [ ! -d "${dir}" ]; then
+		mkdir -p ${tmpDir} && cd ${tmpDir}
+		${install}
+	fi`);
+    const { description, version } = await (0, npm_js_1.readPackage)(pkg);
+    const sitemap = `${sitemapBase}/${name}/${version}/sitemap.xml`;
+    const outputDir = (0, path_1.join)(outDir, name);
+    console.log(cwd);
+    await (0, builder_js_1.run)(`node ${DOCGEN} ${files}`, {
+        packageJson,
+        docsJson,
+        scripts,
+        outputDir,
+        sitemap: sitemapBase ? `${sitemapBase}/${name}` : '',
+        summary: summary ?? true,
+        typeRoots,
+        packageName: name,
+        repository: repo?.startsWith('https')
+            ? `${repo.replace(/.git$/, '')}/blob/${tag}${options.cwd ? `/${options.cwd}` : ''}`
+            : undefined,
+        markdown: true,
+        baseHref,
+        customJsDocTags,
+        rootDir,
+        exports,
+        followReferences,
+        cxlExtensions,
+        headHtml,
+    }, { cwd });
+    return { name, version, description, sitemap };
+}
+function docgenTask(packages, commonOptions) {
+    return (0, rx_1.fromAsync)(async () => {
+        const output = [];
+        for (const p of packages)
+            output.push(await docgen({
+                ...commonOptions,
+                ...p,
+            }));
+        return {
+            path: 'docgen.json',
+            source: Buffer.from(JSON.stringify(output)),
+        };
+    });
+}
+function packageJson(p) {
+    return (0, rx_1.of)({
+        path: 'package.json',
+        source: Buffer.from(JSON.stringify({
+            name: p.name,
+            version: p.version,
+            description: p.description,
+            private: p.private,
+            license: p.license,
+            files: p.files || [
+                '*.js',
+                '*.d.ts',
+                '*.css',
+                'amd/*.js',
+                'amd/*.d.ts',
+                'mjs/*.js',
+                'mjs/*.d.ts',
+                'LICENSE',
+                '*.md',
+            ],
+            main: p.main || 'index.js',
+            exports: p.exports,
+            browser: p.browser,
+            homepage: p.homepage,
+            bugs: p.bugs,
+            bin: p.bin,
+            repository: p.repository,
+            dependencies: p.dependencies,
+            peerDependencies: p.peerDependencies,
+            bundledDependencies: p.bundledDependencies,
+            type: p.type,
+        }, null, 2)),
+    });
+}
+function license(id) {
+    if (id === 'UNLICENSED' || id === 'SEE LICENSE IN LICENSE.txt')
+        return rx_1.EMPTY;
+    const licenseFile = LICENSE_MAP[id];
+    if (!licenseFile)
+        throw new Error(`Invalid license: "${id}"`);
+    return (0, file_js_1.file)((0, path_1.join)(__dirname, licenseFile), 'LICENSE');
+}
+function npmLink(pkgName, version) {
+    return `https://npmjs.com/package/${pkgName}/v/${version}`;
+}
+function readIfExists(file) {
+    try {
+        return (0, fs_1.readFileSync)(file, 'utf8');
+    }
+    catch (E) {
+        return '';
+    }
+}
+/**
+ * Generate README file
+ */
+function readme() {
+    return (0, rx_1.defer)(() => {
+        const pkg = readPackage(exports.BASEDIR);
+        const extra = readIfExists('USAGE.md');
+        const encodedName = encodeURIComponent(pkg.name);
+        return (0, rx_1.of)({
+            path: 'README.md',
+            source: Buffer.from(`# ${pkg.name} 
+	
+[![npm version](https://badge.fury.io/js/${encodedName}.svg)](https://badge.fury.io/js/${encodedName})
+
+${pkg.description}
+
+## Project Details
+
+-   Branch Version: [${pkg.version}](${npmLink(pkg.name, pkg.version)})
+-   License: ${pkg.license}
+-   Documentation: [Link](${pkg.homepage})
+-   Report Issues: [Github](${pkg.bugs})
+
+## Installation
+
+	npm install ${pkg.name}
+
+${extra}`),
+        });
+    });
+}
+function pkg() {
+    return (0, rx_1.defer)(() => {
+        const p = readPackage();
+        const licenseId = p.license;
+        const output = [packageJson(p)];
+        output.push((0, file_js_1.file)('README.md', 'README.md'));
+        if (licenseId)
+            output.push(license(licenseId));
+        return (0, rx_1.merge)(...output);
+    });
+}
+function createBundle(files, resolvedFiles, content, outFile, config) {
+    const options = {
+        lib: ['lib.es2017.d.ts'],
+        target: ts.ScriptTarget.ES2019,
+        module: ts.ModuleKind.AMD,
+        allowJs: true,
+        declaration: false,
+        baseUrl: process.cwd(),
+        outDir: process.cwd(),
+        outFile: outFile,
+        removeComments: true,
+        isolatedModules: true,
+        moduleResolution: ts.ModuleResolutionKind.NodeJs,
+        sourceMap: false,
+        ...config,
+    };
+    const host = ts.createCompilerHost(options);
+    const oldGetSourceFile = host.getSourceFile;
+    const sourceFiles = [];
+    host.getSourceFile = function (fn, target) {
+        const i = resolvedFiles.indexOf(fn);
+        if (i !== -1) {
+            const sf = ts.createSourceFile(resolvedFiles[i], content[i], target);
+            sf.moduleName = files[i];
+            sourceFiles.push(sf);
+            return sf;
+        }
+        return oldGetSourceFile.apply(this, arguments);
+    };
+    const program = ts.createProgram(resolvedFiles, options, host);
+    let source = '';
+    program.emit(undefined, (_a, b) => (source += b));
+    return {
+        path: outFile,
+        source: Buffer.from(source),
+    };
+}
+function AMD() {
+    return (0, rx_1.defer)(() => (0, rx_1.of)({
+        path: 'amd.js',
+        source: (0, fs_1.readFileSync)(__dirname + '/amd.js'),
+    }));
+}
+function bundle(files, outFile, config) {
+    return new rx_1.Observable(subs => {
+        const moduleNames = Object.keys(files);
+        const resolvedFiles = Object.values(files);
+        Promise.all(resolvedFiles.map(f => fs_1.promises.readFile(f, 'utf8')))
+            .then(content => {
+            subs.next(createBundle(moduleNames, resolvedFiles, content, outFile, config));
+            subs.complete();
+        })
+            .catch(e => subs.error(e));
+    });
+}
+function bundleAmd(files, outFile) {
+    return new rx_1.Observable(subs => {
+        const result = [];
+        const moduleNames = Object.keys(files);
+        const resolvedFiles = Object.values(files);
+        Promise.all(resolvedFiles.map(f => fs_1.promises.readFile(f, 'utf8'))).then(content => {
+            moduleNames.forEach((mod, i) => {
+                result.push(`define("${mod}", ["require", "exports"], function (require, exports) {\n${content[i]}\n})`);
+            });
+            subs.next({
+                path: outFile,
+                source: Buffer.from(result.join('\n')),
+            });
+        });
+    });
+}
+exports.REQUIRE_REPLACE = `
+	require.replace = function (path) {
+		return path.replace(
+			/^@cxl\\/workspace\\.(.+)/,
+			(str, p1) =>
+				\`/cxl.app/dist/\${str.endsWith('.js') ? p1 : p1 + '/index.js'}\`
+		).replace(
+			/^@cxl\\/(ui.*)/,
+			(str, p1) =>
+				\`/ui/dist/\${str.endsWith('.js') ? p1 : p1 + '/index.js'}\`
+		).replace(
+			/^@cxl\\/(.+)/,
+			(str, p1) =>
+				\`/cxl/dist/\${str.endsWith('.js') ? p1 : p1 + '/index.js'}\`
+		);
+	};
+`;
+const INDEX_HEAD = `<!DOCTYPE html><meta charset="utf-8"><script src="index.bundle.min.js"></script>`;
+const DEBUG_HEAD = `<!DOCTYPE html><meta charset="utf-8">
+<script src="/cxl/dist/tester/require-browser.js"></script>
+<script>
+	window.CXL_DEBUG = true;
+	${exports.REQUIRE_REPLACE}
+	require('@cxl/ui');
+	require('@cxl/ui-router');
+	require('@cxl/router/debug.js');
+</script>
+`;
+const DefaultTemplateConfig = {
+    header: INDEX_HEAD,
+    debugHeader: DEBUG_HEAD,
+};
+const HTML_COMMENT_REGEX = /<!--[^]+?-->/gm;
+function template(filename, config = {}) {
+    return (0, file_js_1.file)(filename).switchMap(({ source }) => {
+        const prodSource = source
+            .toString('utf8')
+            .replace(HTML_COMMENT_REGEX, '');
+        const cfg = { ...DefaultTemplateConfig, ...config };
+        return (0, rx_1.from)([
+            { path: 'index.html', source: `${cfg.header}\n${prodSource}` },
+            { path: 'debug.html', source: `${cfg.debugHeader}\n${source}` },
+        ]);
+    });
+}
+function deployS3({ environment, s3Path }) {
+    if (environment !== 'dev' && environment !== 'prod')
+        throw new Error(`Invalid environment ${environment}`);
+    return (0, builder_js_1.exec)(`aws s3 sync --dryrun --cache-control max-age=60 --content-encoding=utf8 --delete ../dist/debuggerjs.com s3://${s3Path}`);
+}

package/package.json

@@ -1,9 +1,32 @@
 {
 	"name": "@cxl/build",
-	"version": "0.0.2",
-	"main": "src/build.js",
+	"version": "0.2.1",
+	"bin": {
+		"cxl-build": "index.js"
+	},
+	"description": "Build Tool",
+	"license": "GPL-3.0",
+	"main": "index.js",
+	"scripts": {
+		"build-index": "tsc -b && tsc -b tsconfig.amd.json",
+		"build-test": "tsc -b tsconfig.test.json",
+		"build": "node build.mjs",
+		"test": "npm run build && cd ../dist/build && node ../tester --node"
+	},
 	"dependencies": {
-		"uglify-es": "*",
-		"colors": "*"
+		"eslint": "^8.56.0",
+		"terser": "^5.16.1",
+		"typescript": "^5.5.3",
+		"@cxl/rx": "~0.8.0",
+		"@cxl/source": "~0.0.2",
+		"@cxl/amd": "~0.0.1",
+		"@cxl/program": "~0.0.3"
+	},
+	"bugs": "https://github.com/cxlio/cxl/issues",
+	"homepage": "https://cxlio.github.io/cxl/build",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/cxlio/cxl.git",
+		"directory": "build"
 	}
 }