@syncbridge/syncbuild 0.5.4 → 0.5.6

package/builder/build-sources.js

@@ -26,7 +26,7 @@ export async function buildSources(context) {
         entryPoints: [entryPoint],
         bundle: true,
         external: ['@syncbridge/common', ...Object.keys(context.externals || {})],
-        outfile: path.join(context.outPackageDir, context.outFile),
+        outfile: path.join(context.tmpDir, context.outEntryPoint),
         platform: 'node',
         target: ['node22'],
         format: 'esm',
@@ -46,6 +46,11 @@ export async function buildSources(context) {
     if (context.tsconfig) {
         esbuildConfig.plugins?.push(esbuildTsc({
             tsconfig: context.tsconfig,
+            overwriteConfig: cfg => {
+                cfg.compilerOptions = cfg.compilerOptions || {};
+                cfg.compilerOptions.declaration = true;
+                cfg.declarationDir = path.join(context.tmpDir, 'typings');
+            },
         }));
     }
     try {

package/builder/create-context.js

@@ -6,39 +6,30 @@ import * as jsonc from 'jsonc-parser';
 import { version } from '../constants.js';
 import { scanNativeDeps } from './utils/scan-native-deps.js';
 export function createContext(config) {
+    const packageDir = path.resolve(process.cwd(), config.packageDir || './');
     let pkgJson;
     try {
-        pkgJson = jsonc.parse(fs.readFileSync(path.resolve(config.packageDir, 'package.json'), 'utf-8'));
+        pkgJson = jsonc.parse(fs.readFileSync(path.resolve(packageDir, 'package.json'), 'utf-8'));
     }
     catch {
         throw new SbError('package.json not found');
     }
     const context = {
+        logger: config.logger,
         config,
         pkgJson,
         outPkgJson: deepClone(pkgJson),
         cwd: process.cwd(),
-        packageDir: path.resolve(config.packageDir),
-        outDir: path.resolve(process.cwd(), config.outDir ?? 'dist'),
-        outPackageDir: '',
-        outTypingsDir: '',
-        outFile: 'index.js',
+        packageDir,
+        outDir: path.resolve(packageDir, config.outDir ?? './'),
+        tmpDir: config.tempDir || fs.mkdtempSync(path.join(packageDir, 'tmp-')),
+        outEntryPoint: 'index.js',
         entryPoint: pkgJson.module ?? pkgJson.main ?? 'index.js',
-        packageZip: '',
-        typingsZip: '',
-    };
-    context.outPackageDir = path.resolve(context.outDir, 'package');
-    context.outTypingsDir = path.resolve(context.outDir, 'typing');
-    context.packageZip =
-        pkgJson.name.replace(/^@/, '').replace(/\//g, '-') +
+        outFile: pkgJson.name.replace(/^@/, '').replace(/\//g, '-') +
             '-' +
-            pkgJson.version +
-            '.zip';
-    context.typingsZip =
-        pkgJson.name.replace(/^@/, '').replace(/\//g, '-') +
-            '-typings-' +
-            pkgJson.version +
-            '.zip';
+            pkgJson.version,
+    };
+    fs.rmSync(context.tmpDir, { recursive: true, force: true });
     const allDeps = {
         ...pkgJson.dependencies,
         ...pkgJson.optionalDependencies,
@@ -57,7 +48,7 @@ export function createContext(config) {
     delete outPkgJson.exports;
     outPkgJson.private = true;
     outPkgJson.type = 'module';
-    outPkgJson.module = context.outFile;
+    outPkgJson.module = context.outEntryPoint;
     outPkgJson.syncbridge = {
         version: /^(\d+)/.exec(version)[1],
     };

package/builder/extract-exports.js

@@ -1,18 +1,20 @@
 import 'reflect-metadata';
 import fs from 'node:fs';
+import { createRequire } from 'node:module';
 import path from 'node:path';
 import { COMPONENT_OPTIONS, PROCESSOR_OPTIONS } from '@syncbridge/common';
 import { resolvePromisesDeep } from './utils/resolve-promises.js';
 export async function extractExports(context) {
     const { outPkgJson } = context;
-    const pkgGlobal = await import(path.join(context.outPackageDir, context.outFile));
+    const require = createRequire(path.join(context.tmpDir, 'index.js'));
+    const pkgGlobal = await require('./' + context.outEntryPoint);
     for (const [k, v] of Object.entries(pkgGlobal)) {
         if (typeof v !== 'function')
             continue;
         let metadata = Reflect.getMetadata(COMPONENT_OPTIONS, v);
         if (metadata) {
             metadata = await resolvePromisesDeep(metadata);
-            const metadataDir = path.join(context.outPackageDir, 'metadata');
+            const metadataDir = path.join(context.tmpDir, 'metadata');
             fs.mkdirSync(metadataDir, { recursive: true });
             fs.writeFileSync(path.join(metadataDir, `${k}.json`), JSON.stringify(metadata, undefined, 2));
             outPkgJson.syncbridge.components =
@@ -21,7 +23,7 @@ export async function extractExports(context) {
         }
         metadata = Reflect.getMetadata(PROCESSOR_OPTIONS, v);
         if (metadata) {
-            const metadataDir = path.join(context.outPackageDir, 'metadata');
+            const metadataDir = path.join(context.tmpDir, 'metadata');
             fs.mkdirSync(metadataDir, { recursive: true });
             fs.writeFileSync(path.join(metadataDir, `${k}.json`), JSON.stringify(metadata, undefined, 2));
             outPkgJson.syncbridge.processors =

package/builder/read-tsconfig.js

@@ -9,7 +9,7 @@ export function readTsconfig(context) {
             overwriteConfig: cfg => {
                 cfg.compilerOptions = cfg.compilerOptions || {};
                 cfg.compilerOptions.sourceMap = false;
-                cfg.compilerOptions.declarationDir = context.outTypingsDir;
+                cfg.compilerOptions.declarationDir = path.join(context.tmpDir, 'typings');
             },
         });
         const dtsRoot = path.join(context.packageDir, context.entryPoint.replace(/\.ts$/, '.d.ts'));

package/builder/utils/esbuild-tsc.js

@@ -34,7 +34,7 @@ function esbuildTsc(options) {
                 });
                 const declarationDir = parsedTsConfig.options.declarationDir ||
                     parsedTsConfig.options.outDir;
-                if (declarationDir && parsedTsConfig.options.declaration) {
+                if (declarationDir && (parsedTsConfig.options.declaration ?? true)) {
                     const declaration = typescript.transpileDeclaration(fileContent, {
                         compilerOptions: parsedTsConfig.options,
                         fileName: path.basename(args.path),

package/builder/utils/scan-native-deps.d.ts

@@ -1,2 +1,2 @@
 export declare function scanNativeDeps(rootPath: string, pkgNames: string[]): Record<string, string>;
-export declare function _scanNativeDeps(rootPath: string, pkgName: string, externals: Record<string, string>, visited: Set<string>, ignoreNotFount?: boolean): void;
+export declare function _scanNativeDeps(parentPath: string, pkgName: string, externals: Record<string, string>, visited: Set<string>, ignoreNotFount?: boolean): void;

package/builder/utils/scan-native-deps.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
+import { createRequire } from 'node:module';
 import path from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
 import { SbError } from '@syncbridge/common';
 import glob from 'fast-glob';
 import * as jsonc from 'jsonc-parser';
@@ -10,18 +10,19 @@ export function scanNativeDeps(rootPath, pkgNames) {
     pkgNames.forEach(pkgName => _scanNativeDeps(rootPath, pkgName, externals, visited));
     return externals;
 }
-export function _scanNativeDeps(rootPath, pkgName, externals, visited, ignoreNotFount) {
+export function _scanNativeDeps(parentPath, pkgName, externals, visited, ignoreNotFount) {
     if (visited.has(pkgName))
         return;
     visited.add(pkgName);
+    const require = createRequire(path.join(parentPath, 'package.json'));
     let pkgDir;
     let pkgJson;
     try {
         try {
-            const location = import.meta.resolve(pkgName, pathToFileURL(rootPath));
+            const location = require.resolve(pkgName);
             if (location === pkgName || location.startsWith('node:'))
                 return;
-            pkgDir = path.dirname(fileURLToPath(location));
+            pkgDir = path.dirname(location);
         }
         catch (e) {
             if (e.code === 'ERR_INVALID_URL_SCHEME')
@@ -60,12 +61,12 @@ export function _scanNativeDeps(rootPath, pkgName, externals, visited, ignoreNot
     }
     if (pkgJson.dependencies) {
         for (const dep of Object.keys(pkgJson.dependencies)) {
-            _scanNativeDeps(rootPath, dep, externals, visited);
+            _scanNativeDeps(parentPath, dep, externals, visited);
         }
     }
     if (pkgJson.optionalDependencies) {
         for (const dep of Object.keys(pkgJson.optionalDependencies)) {
-            _scanNativeDeps(rootPath, dep, externals, visited, true);
+            _scanNativeDeps(parentPath, dep, externals, visited, true);
         }
     }
 }

package/bundle-package.js

@@ -1,27 +1,36 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import AdmZip from 'adm-zip';
+import colors from 'ansi-colors';
 import { rimraf } from 'rimraf';
 import { buildSources } from './builder/build-sources.js';
 import { createContext } from './builder/create-context.js';
 import { extractExports } from './builder/extract-exports.js';
 import { readTsconfig } from './builder/read-tsconfig.js';
-import { zipPackage } from './builder/zip-package.js';
 export async function bundlePackage(config) {
     const context = createContext(config);
-    rimraf.sync(context.outDir);
-    readTsconfig(context);
-    await buildSources(context);
-    await extractExports(context);
-    fs.writeFileSync(path.join(context.outPackageDir, 'package.json'), JSON.stringify({
-        ...context.outPkgJson,
-        types: undefined,
-    }, null, 2));
-    fs.writeFileSync(path.join(context.outTypingsDir, 'package.json'), JSON.stringify({
-        ...context.outPkgJson,
-        module: '',
-        syncbridge: undefined,
-    }, null, 2));
-    zipPackage(context);
-    // rimraf.sync(context.outPackageDir);
-    // rimraf.sync(context.outTypingsDir);
+    context.logger?.(`Bundling package ${colors.magenta(context.pkgJson.name)}...`);
+    try {
+        rimraf.sync(context.outDir);
+        readTsconfig(context);
+        await buildSources(context);
+        await extractExports(context);
+        fs.writeFileSync(path.join(context.tmpDir, 'package.json'), JSON.stringify({
+            ...context.outPkgJson,
+            types: './' +
+                path.join(`./typings`, context.entryPoint.replace(/\.js$/, '.d.ts')),
+        }, null, 2));
+        const zipFileName = path.join(context.outDir, context.outFile + '.zip');
+        if (fs.existsSync(context.tmpDir)) {
+            const zip = new AdmZip();
+            zip.addLocalFolder(context.tmpDir);
+            zip.writeZip(zipFileName);
+        }
+        context.logger?.(`Generated ${colors.magenta(path.basename(zipFileName))}`);
+    }
+    finally {
+        fs.rmSync(context.tmpDir, {
+            recursive: true,
+        });
+    }
 }

package/constants.js

@@ -1,5 +1,5 @@
 import process from 'node:process';
-export const version = '0.5.4';
+export const version = '0.5.6';
 // Environment variables
 export const NODE_ENV = process.env.NODE_ENV === 'test'
     ? 'test'

package/context.d.ts

@@ -3,15 +3,14 @@ export declare class Context {
     pkgJson: PackageJson;
     outPkgJson: PackageJson;
     packageDir: string;
+    tmpDir: string;
+    outEntryPoint: string;
     outDir: string;
-    outPackageDir: string;
-    outTypingsDir: string;
     outFile: string;
     config: PackageBuildConfig;
     cwd: string;
     entryPoint: string;
     tsconfig?: any;
     externals?: Record<string, string>;
-    packageZip: string;
-    typingsZip: string;
+    logger?: typeof console.log;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncbridge/syncbuild",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "description": "SyncBridge Extension Package Builder",
   "author": "Panates Inc",
   "license": "MIT",
@@ -20,7 +20,7 @@
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@syncbridge/common": "^0.5.4"
+    "@syncbridge/common": "^0.5.6"
   },
   "type": "module",
   "module": "./index.js",

package/syncbuild-cli.js

@@ -7,16 +7,21 @@ import { bundlePackage } from './bundle-package.js';
 import { version } from './constants.js';
 program
     .version(version)
-    .option('-p, --path <packagePath>', 'Directory of package')
-    .option('-o, --out <fileName>', 'Output package file name')
+    .option('-o, --out <directory>', 'Output directory', 'dist')
+    .option('-p, --package-dir <directory>', 'Directory of package')
+    .option('--temp-dir <directory>', 'Directory for temp files')
     .option('--tsconfig <fileName>', 'tsconfig file name', 'tsconfig.json')
     .option('--no-color', 'Disables colors in logs messages')
     .action(async (options) => {
     if (!options.color)
         colors.enabled = false;
+    console.log(colors.yellow('**** SyncBuild v' + version + ' ****'));
     bundlePackage({
-        packageDir: options.path,
+        packageDir: options.packageDir,
+        outDir: options.out,
         tsconfig: options.tsconfig,
+        tempDir: options.tempDir,
+        logger: console.log,
     }).catch(e => {
         if (e instanceof SbError)
             console.error(colors.red(e.message));

package/types.d.ts

@@ -7,6 +7,10 @@ export interface PackageBuildConfig {
      * Represents the output directory of the build.
      */
     outDir?: string;
+    /**
+     * Represents the directory to store temporary files.
+     */
+    tempDir?: string;
     /**
      * Represents the path to the tsconfig file.
      */
@@ -44,6 +48,10 @@ export interface PackageBuildConfig {
      * Default: false
      */
     keepNames?: boolean;
+    /**
+     * Custom logger function for output messages.
+     */
+    logger?: typeof console.log;
 }
 export interface PackageJson {
     name: string;

package/builder/zip-package.d.ts

@@ -1,2 +0,0 @@
-import { Context } from '../context.js';
-export declare function zipPackage(context: Context): void;

package/builder/zip-package.js

@@ -1,15 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import AdmZip from 'adm-zip';
-export function zipPackage(context) {
-    if (fs.existsSync(context.outPackageDir)) {
-        const zip = new AdmZip();
-        zip.addLocalFolder(context.outPackageDir);
-        zip.writeZip(path.join(context.outDir, context.packageZip));
-    }
-    if (fs.existsSync(context.outTypingsDir)) {
-        const zip = new AdmZip();
-        zip.addLocalFolder(context.outTypingsDir);
-        zip.writeZip(path.join(context.outDir, context.typingsZip));
-    }
-}