@syncbridge/syncbuild 0.5.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Panates
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,165 @@
+# @syncbridge/syncbuild
+
+SyncBridge Extension Package Builder - A powerful tool for building and bundling SyncBridge extension packages.
+
+## Installation
+
+```bash
+npm install @syncbridge/syncbuild
+```
+
+## CLI Usage
+
+The `syncbuild` CLI tool allows you to build and bundle your SyncBridge extension packages from the command line.
+
+### Basic Usage
+
+```bash
+syncbuild [options]
+```
+
+### CLI Options
+
+| Option                     | Description                       | Default         |
+|----------------------------|-----------------------------------|-----------------|
+| `-p, --path <packagePath>` | Directory of the package to build | -               |
+| `-o, --out <fileName>`     | Output package file name          | -               |
+| `--tsconfig <fileName>`    | Path to tsconfig file             | `tsconfig.json` |
+| `--no-color`               | Disables colors in log messages   | -               |
+| `-V, --version`            | Output the version number         | -               |
+| `-h, --help`               | Display help information          | -               |
+
+### CLI Examples
+
+Build a package from a specific directory:
+
+```bash
+syncbuild --path ./my-extension
+```
+
+Build with a custom tsconfig:
+
+```bash
+syncbuild --path ./my-extension --tsconfig tsconfig.build.json
+```
+
+Disable colored output:
+
+```bash
+syncbuild --path ./my-extension --no-color
+```
+
+## API Usage
+
+You can also use `syncbuild` programmatically in your Node.js applications.
+
+### Basic API Usage
+
+```typescript
+import { bundlePackage } from '@syncbridge/syncbuild';
+
+await bundlePackage({
+  packageDir: './my-extension',
+  tsconfig: 'tsconfig.json'
+});
+```
+
+### API Configuration
+
+#### `bundlePackage(config: PackageBuildConfig): Promise<void>`
+
+The main function for building and bundling packages.
+
+#### `PackageBuildConfig` Interface
+
+| Property            | Type                     | Description                                     | Default         |
+|---------------------|--------------------------|-------------------------------------------------|-----------------|
+| `packageDir`        | `string`                 | Directory of the package to be built (required) | -               |
+| `outDir`            | `string`                 | Output directory for the build                  | -               |
+| `tsconfig`          | `string`                 | Path to the tsconfig file                       | `tsconfig.json` |
+| `external`          | `Record<string, string>` | External dependencies to exclude from the build | -               |
+| `minify`            | `boolean`                | Minify the output bundle                        | `true`          |
+| `minifyWhitespace`  | `boolean`                | Minify whitespace in the output                 | `true`          |
+| `minifyIdentifiers` | `boolean`                | Minify identifiers in the output                | `true`          |
+| `minifySyntax`      | `boolean`                | Minify syntax in the output                     | `true`          |
+| `banner`            | `string`                 | Custom banner to prepend to the output          | -               |
+| `keepNames`         | `boolean`                | Keep names of variables and functions           | `false`         |
+
+### API Examples
+
+#### Basic Build
+
+```typescript
+import { bundlePackage } from '@syncbridge/syncbuild';
+
+await bundlePackage({
+  packageDir: './my-extension'
+});
+```
+
+#### Advanced Build with Options
+
+```typescript
+import { bundlePackage } from '@syncbridge/syncbuild';
+
+await bundlePackage({
+  packageDir: './my-extension',
+  outDir: './dist',
+  tsconfig: 'tsconfig.build.json',
+  minify: true,
+  minifyWhitespace: true,
+  minifyIdentifiers: true,
+  minifySyntax: true,
+  keepNames: false,
+  external: {
+    'external-module': '^1.0.0'
+  },
+  banner: '// Copyright 2024 My Company'
+});
+```
+
+#### With Error Handling
+
+```typescript
+import { bundlePackage } from '@syncbridge/syncbuild';
+import { SbError } from '@syncbridge/common';
+
+try {
+  await bundlePackage({
+    packageDir: './my-extension',
+    tsconfig: 'tsconfig.json'
+  });
+  console.log('Build completed successfully!');
+} catch (error) {
+  if (error instanceof SbError) {
+    console.error('Build failed:', error.message);
+  } else {
+    console.error('Unexpected error:', error);
+  }
+}
+```
+
+## Build Process
+
+The build process performs the following steps:
+
+1. **Context Creation** - Initializes build context with configuration
+2. **TypeScript Configuration** - Reads and validates tsconfig.json
+3. **Source Building** - Compiles TypeScript sources using esbuild
+4. **Export Extraction** - Extracts and processes package exports
+5. **Package Generation** - Creates package.json for output
+6. **Zipping** - Bundles the built package into a distributable format
+
+## Requirements
+
+- Node.js >= 20.0
+- TypeScript project with valid tsconfig.json
+- Valid package.json in the package directory
+
+## License
+
+[MIT License](LICENSE)
+
+## Author
+
+Panates Inc

package/builder/build-sources.d.ts

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

package/builder/build-sources.js

@@ -0,0 +1,57 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { SbError } from '@syncbridge/common';
+import * as esbuild from 'esbuild';
+import { version } from '../constants.js';
+import esbuildTsc from './utils/esbuild-tsc.js';
+export async function buildSources(context) {
+    let entryPoint = context.entryPoint;
+    if (context.tsconfig?.wildcardDirectories) {
+        const entryPointTs = entryPoint.replace(/\.js$/, '.ts');
+        for (const dir of Object.keys(context.tsconfig.wildcardDirectories)) {
+            let filename = path.join(dir, entryPointTs);
+            if (fs.existsSync(filename)) {
+                entryPoint = filename;
+                break;
+            }
+            filename = path.join(dir, entryPoint);
+            if (fs.existsSync(filename)) {
+                entryPoint = filename;
+                break;
+            }
+        }
+    }
+    const esbuildConfig = {
+        absWorkingDir: context.packageDir,
+        entryPoints: [entryPoint],
+        bundle: true,
+        external: ['@syncbridge/common', ...Object.keys(context.externals || {})],
+        outfile: path.join(context.outPackageDir, context.outFile),
+        platform: 'node',
+        target: ['node22'],
+        format: 'esm',
+        mainFields: ['module', 'main'],
+        minify: context.config.minify ?? false,
+        minifyWhitespace: context.config.minifyWhitespace ?? false,
+        minifyIdentifiers: context.config.minifyIdentifiers ?? false,
+        minifySyntax: context.config.minifySyntax ?? false,
+        keepNames: context.config.keepNames ?? true,
+        banner: {
+            js: `/**\n  Build with SyncBridge® package builder v${version}\n **/` +
+                "import { createRequire } from 'module';\nconst require = createRequire(import.meta.url);\n" +
+                (context.config.banner ?? ''),
+        },
+        plugins: [],
+    };
+    if (context.tsconfig) {
+        esbuildConfig.plugins?.push(esbuildTsc({
+            tsconfig: context.tsconfig,
+        }));
+    }
+    try {
+        await esbuild.build(esbuildConfig);
+    }
+    catch (err) {
+        throw new SbError(err);
+    }
+}

package/builder/create-context.d.ts

@@ -0,0 +1,3 @@
+import { Context } from '../context.js';
+import { PackageBuildConfig } from '../types.js';
+export declare function createContext(config: PackageBuildConfig): Context;

package/builder/create-context.js

@@ -0,0 +1,65 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { deepClone } from '@jsopen/objects';
+import { SbError } from '@syncbridge/common';
+import * as jsonc from 'jsonc-parser';
+import { version } from '../constants.js';
+import { scanNativeDeps } from './utils/scan-native-deps.js';
+export function createContext(config) {
+    let pkgJson;
+    try {
+        pkgJson = jsonc.parse(fs.readFileSync(path.resolve(config.packageDir, 'package.json'), 'utf-8'));
+    }
+    catch {
+        throw new SbError('package.json not found');
+    }
+    const context = {
+        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',
+        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, '-') +
+            '-' +
+            pkgJson.version +
+            '.zip';
+    context.typingsZip =
+        pkgJson.name.replace(/^@/, '').replace(/\//g, '-') +
+            '-typings-' +
+            pkgJson.version +
+            '.zip';
+    const allDeps = {
+        ...pkgJson.dependencies,
+        ...pkgJson.optionalDependencies,
+    };
+    context.externals = {
+        ...scanNativeDeps(context.packageDir, Object.keys(allDeps)),
+        ...context.config.external,
+    };
+    /** Create package.json */
+    const { outPkgJson } = context;
+    outPkgJson.dependencies = context.externals;
+    delete outPkgJson.devDependencies;
+    delete outPkgJson.peerDependencies;
+    delete outPkgJson.scripts;
+    delete outPkgJson.main;
+    delete outPkgJson.exports;
+    outPkgJson.private = true;
+    outPkgJson.type = 'module';
+    outPkgJson.module = context.outFile;
+    outPkgJson.syncbridge = {
+        version: /^(\d+)/.exec(version)[1],
+    };
+    return context;
+}

package/builder/extract-exports.d.ts

@@ -0,0 +1,3 @@
+import 'reflect-metadata';
+import { Context } from '../context.js';
+export declare function extractExports(context: Context): Promise<void>;

package/builder/extract-exports.js

@@ -0,0 +1,32 @@
+import 'reflect-metadata';
+import fs from 'node:fs';
+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));
+    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');
+            fs.mkdirSync(metadataDir, { recursive: true });
+            fs.writeFileSync(path.join(metadataDir, `${k}.json`), JSON.stringify(metadata, undefined, 2));
+            outPkgJson.syncbridge.components =
+                outPkgJson.syncbridge.components || [];
+            outPkgJson.syncbridge.components.push(k);
+        }
+        metadata = Reflect.getMetadata(PROCESSOR_OPTIONS, v);
+        if (metadata) {
+            const metadataDir = path.join(context.outPackageDir, 'metadata');
+            fs.mkdirSync(metadataDir, { recursive: true });
+            fs.writeFileSync(path.join(metadataDir, `${k}.json`), JSON.stringify(metadata, undefined, 2));
+            outPkgJson.syncbridge.processors =
+                outPkgJson.syncbridge.processors || [];
+            outPkgJson.syncbridge.processors.push(k);
+        }
+    }
+}

package/builder/read-tsconfig.d.ts

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

package/builder/read-tsconfig.js

@@ -0,0 +1,18 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import esbuildTsc from './utils/esbuild-tsc.js';
+export function readTsconfig(context) {
+    /** Read tsconfig.json */
+    const tsconfigPath = path.resolve(context.packageDir, context.config.tsconfig || 'tsconfig.json');
+    if (fs.existsSync(tsconfigPath)) {
+        context.tsconfig = esbuildTsc.parseTsConfig(tsconfigPath, {
+            overwriteConfig: cfg => {
+                cfg.compilerOptions = cfg.compilerOptions || {};
+                cfg.compilerOptions.sourceMap = false;
+                cfg.compilerOptions.declarationDir = context.outTypingsDir;
+            },
+        });
+        const dtsRoot = path.join(context.packageDir, context.entryPoint.replace(/\.ts$/, '.d.ts'));
+        context.outPkgJson.types = path.relative(context.tsconfig.options.rootDir, dtsRoot);
+    }
+}

package/builder/utils/esbuild-tsc.d.ts

@@ -0,0 +1,21 @@
+import type { Plugin } from 'esbuild';
+import typescript from 'typescript';
+declare function esbuildTsc(options?: esbuildTsc.Options & {
+    cwd?: string;
+    overwriteConfig?: (config: any) => any;
+}): Plugin;
+export default esbuildTsc;
+/**
+ * @namespace esbuildTsc
+ */
+declare namespace esbuildTsc {
+    interface Options {
+        tsconfig?: string | typescript.ParsedCommandLine;
+        filter?: RegExp | ((filename: string, tsconfig: typescript.ParsedCommandLine) => boolean);
+    }
+    function parseTsConfig(tsconfig: string, options?: {
+        cwd?: string;
+        overwriteConfig?: (config: any) => any;
+    }): typescript.ParsedCommandLine;
+    function printDiagnostics(...args: any[]): void;
+}

package/builder/utils/esbuild-tsc.js

@@ -0,0 +1,90 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { inspect } from 'node:util';
+import { SbError } from '@syncbridge/common';
+import typescript from 'typescript';
+function esbuildTsc(options) {
+    return {
+        name: 'tsc',
+        setup(build) {
+            const parsedTsConfig = options?.tsconfig && typeof options?.tsconfig === 'object'
+                ? options.tsconfig
+                : esbuildTsc.parseTsConfig((options?.tsconfig && String(options?.tsconfig)) ||
+                    'tsconfig.json', options);
+            if (parsedTsConfig.options?.sourceMap) {
+                parsedTsConfig.options.sourceMap = false;
+                parsedTsConfig.options.inlineSources = true;
+                parsedTsConfig.options.inlineSourceMap = true;
+            }
+            const filterFn = typeof options?.filter === 'function' ? options?.filter : undefined;
+            build.onLoad({
+                filter: typeof options?.filter === 'object' ? options.filter : /\.tsx?$/,
+            }, async (args) => {
+                if (filterFn) {
+                    if (!filterFn(args.path, parsedTsConfig))
+                        return;
+                }
+                else if (!parsedTsConfig?.options?.emitDecoratorMetadata) {
+                    return;
+                }
+                const fileContent = fs.readFileSync(args.path, 'utf8');
+                const program = typescript.transpileModule(fileContent, {
+                    compilerOptions: parsedTsConfig.options,
+                    fileName: path.basename(args.path),
+                });
+                const declarationDir = parsedTsConfig.options.declarationDir ||
+                    parsedTsConfig.options.outDir;
+                if (declarationDir && parsedTsConfig.options.declaration) {
+                    const declaration = typescript.transpileDeclaration(fileContent, {
+                        compilerOptions: parsedTsConfig.options,
+                        fileName: path.basename(args.path),
+                    });
+                    const relPath = path.dirname(path.relative(parsedTsConfig.options.rootDir || options?.cwd || process.cwd(), args.path));
+                    if (!relPath.startsWith('..')) {
+                        const filename = path.basename(args.path, path.extname(args.path)) + '.d.ts';
+                        const declarationPath = path.join(declarationDir, relPath, filename);
+                        fs.mkdirSync(path.dirname(declarationPath), { recursive: true });
+                        fs.writeFileSync(declarationPath, declaration.outputText, 'utf-8');
+                    }
+                }
+                return { contents: program.outputText };
+            });
+        },
+    };
+}
+export default esbuildTsc;
+/**
+ * @namespace esbuildTsc
+ */
+(function (esbuildTsc) {
+    function parseTsConfig(tsconfig, options) {
+        const cwd = options?.cwd ?? process.cwd();
+        const fileName = typescript.findConfigFile(cwd, typescript.sys.fileExists, tsconfig);
+        // if the value was provided, but no file, fail hard
+        if (tsconfig !== undefined && !fileName) {
+            throw new SbError(`Unable to locate tsconfig'`);
+        }
+        let loadedConfig = {};
+        let baseDir = cwd;
+        if (fileName) {
+            const text = typescript.sys.readFile(fileName);
+            if (text === undefined)
+                throw new SbError(`failed to read '${fileName}'`);
+            const result = typescript.parseConfigFileTextToJson(fileName, text);
+            loadedConfig = result.config;
+            baseDir = path.dirname(fileName);
+        }
+        if (options?.overwriteConfig)
+            loadedConfig = options.overwriteConfig(loadedConfig) || loadedConfig;
+        const parsedTsConfig = typescript.parseJsonConfigFileContent(loadedConfig, typescript.sys, baseDir);
+        if (parsedTsConfig.errors.length) {
+            printDiagnostics(parsedTsConfig.errors);
+        }
+        return parsedTsConfig;
+    }
+    esbuildTsc.parseTsConfig = parseTsConfig;
+    function printDiagnostics(...args) {
+        console.log(inspect(args, false, 10, true));
+    }
+    esbuildTsc.printDiagnostics = printDiagnostics;
+})(esbuildTsc || (esbuildTsc = {}));

package/builder/utils/resolve-promises.d.ts

@@ -0,0 +1 @@
+export declare function resolvePromisesDeep(obj: any): Promise<any>;

package/builder/utils/resolve-promises.js

@@ -0,0 +1,10 @@
+import { isPlainObject } from '@jsopen/objects';
+export async function resolvePromisesDeep(obj) {
+    obj = await obj;
+    if (obj && isPlainObject(obj)) {
+        for (const k of Object.keys(obj)) {
+            obj[k] = await resolvePromisesDeep(obj[k]);
+        }
+    }
+    return obj;
+}

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

@@ -0,0 +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;

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

@@ -0,0 +1,74 @@
+import fs from 'node:fs';
+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';
+export function scanNativeDeps(rootPath, pkgNames) {
+    const visited = new Set();
+    const externals = {};
+    pkgNames.forEach(pkgName => _scanNativeDeps(rootPath, pkgName, externals, visited));
+    return externals;
+}
+export function _scanNativeDeps(rootPath, pkgName, externals, visited, ignoreNotFount) {
+    if (visited.has(pkgName))
+        return;
+    visited.add(pkgName);
+    let pkgDir;
+    let pkgJson;
+    try {
+        try {
+            const location = import.meta.resolve(pkgName, pathToFileURL(rootPath));
+            if (location === pkgName || location.startsWith('node:'))
+                return;
+            pkgDir = path.dirname(fileURLToPath(location));
+        }
+        catch (e) {
+            if (e.code === 'ERR_INVALID_URL_SCHEME')
+                return;
+            if (!e.message?.includes(' find '))
+                throw e;
+            if (ignoreNotFount)
+                return;
+            throw new SbError(e);
+        }
+        let i = 3;
+        while (true) {
+            const pkgJsonPath = path.join(pkgDir, 'package.json');
+            if (fs.existsSync(pkgJsonPath)) {
+                pkgJson = jsonc.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+                break;
+            }
+            if (!i--)
+                break;
+            pkgDir = path.dirname(pkgDir);
+        }
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            console.warn('⚠ Unable to import package: ' + pkgName + '\n', e.message);
+            return;
+        }
+        throw e;
+    }
+    if (!pkgJson) {
+        console.warn(`⚠ Skipped unresolved dependency: ${pkgName}`);
+        return;
+    }
+    if (containsNativeBinary(pkgDir)) {
+        externals[pkgName] = '^' + pkgJson.version;
+    }
+    if (pkgJson.dependencies) {
+        for (const dep of Object.keys(pkgJson.dependencies)) {
+            _scanNativeDeps(rootPath, dep, externals, visited);
+        }
+    }
+    if (pkgJson.optionalDependencies) {
+        for (const dep of Object.keys(pkgJson.optionalDependencies)) {
+            _scanNativeDeps(rootPath, dep, externals, visited, true);
+        }
+    }
+}
+function containsNativeBinary(dir) {
+    return glob.sync('**/*.node', { cwd: dir, absolute: true }).length > 0;
+}

package/builder/zip-package.d.ts

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

package/builder/zip-package.js

@@ -0,0 +1,15 @@
+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));
+    }
+}

package/bundle-package.d.ts

@@ -0,0 +1,2 @@
+import { PackageBuildConfig } from './types.js';
+export declare function bundlePackage(config: PackageBuildConfig): Promise<void>;

package/bundle-package.js

@@ -0,0 +1,27 @@
+import fs from 'node:fs';
+import path from 'node:path';
+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);
+}

package/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const version = "1";
+export declare const NODE_ENV: string;

package/constants.js

@@ -0,0 +1,8 @@
+import process from 'node:process';
+export const version = '0.5.1';
+// Environment variables
+export const NODE_ENV = process.env.NODE_ENV === 'test'
+    ? 'test'
+    : (process.env.NODE_ENV || '').startsWith('dev')
+        ? 'dev'
+        : 'prod';

package/context.d.ts

@@ -0,0 +1,17 @@
+import type { PackageBuildConfig, PackageJson } from './types.js';
+export declare class Context {
+    pkgJson: PackageJson;
+    outPkgJson: PackageJson;
+    packageDir: 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;
+}

package/context.js

@@ -0,0 +1,2 @@
+export class Context {
+}

package/index.d.ts

@@ -0,0 +1,3 @@
+export * from './bundle-package.js';
+export * from './context.js';
+export * from './types.js';

package/index.js

@@ -0,0 +1,3 @@
+export * from './bundle-package.js';
+export * from './context.js';
+export * from './types.js';

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@syncbridge/syncbuild",
+  "version": "0.5.1",
+  "description": "SyncBridge Extension Package Builder",
+  "author": "Panates Inc",
+  "license": "MIT",
+  "dependencies": {
+    "@jsopen/objects": "^2.0.2",
+    "adm-zip": "^0.5.16",
+    "ansi-colors": "^4.1.3",
+    "commander": "^14.0.3",
+    "cross-dirname": "^0.1.0",
+    "esbuild": "^0.27.2",
+    "fast-glob": "^3.3.3",
+    "jsonc-parser": "^3.3.1",
+    "putil-varhelpers": "^1.7.0",
+    "reflect-metadata": "^0.2.2",
+    "rimraf": "^6.1.2",
+    "ts-gems": "^3.11.3",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "@syncbridge/common": "^0.5.1"
+  },
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "type": "module",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "engines": {
+    "node": ">=20.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/sycbuild-cli.d.ts

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

package/sycbuild-cli.js

@@ -0,0 +1,27 @@
+import * as console from 'node:console';
+import * as process from 'node:process';
+import { SbError } from '@syncbridge/common';
+import colors from 'ansi-colors';
+import { program } from 'commander';
+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('--tsconfig <fileName>', 'tsconfig file name', 'tsconfig.json')
+    .option('--no-color', 'Disables colors in logs messages')
+    .action(async (options) => {
+    if (!options.color)
+        colors.enabled = false;
+    bundlePackage({
+        packageDir: options.path,
+        tsconfig: options.tsconfig,
+    }).catch(e => {
+        if (e instanceof SbError)
+            console.error(colors.red(e.message));
+        else
+            console.error(e);
+    });
+});
+program.parse(process.argv);

package/types.d.ts

@@ -0,0 +1,67 @@
+export interface PackageBuildConfig {
+    /**
+     * Represents the directory of the package to be built.
+     */
+    packageDir: string;
+    /**
+     * Represents the output directory of the build.
+     */
+    outDir?: string;
+    /**
+     * Represents the path to the tsconfig file.
+     */
+    tsconfig?: string;
+    /**
+     * List of external dependencies to exclude from the build.
+     */
+    external?: Record<string, string>;
+    /**
+     * Minify the output bundle.
+     * Default: true
+     */
+    minify?: boolean;
+    /**
+     * Minify whitespace in the output bundle.
+     * Default: true
+     */
+    minifyWhitespace?: boolean;
+    /**
+     * Minify identifiers in the output bundle.
+     * Default: true
+     */
+    minifyIdentifiers?: boolean;
+    /**
+     * Minify syntax in the output bundle.
+     * Default: true
+     */
+    minifySyntax?: boolean;
+    /**
+     * Custom banner to prepend to the output bundle.
+     */
+    banner?: string;
+    /**
+     * Keep names of variables and functions in the output bundle.
+     * Default: false
+     */
+    keepNames?: boolean;
+}
+export interface PackageJson {
+    name: string;
+    version: string;
+    private?: boolean;
+    type?: string;
+    module?: string;
+    main?: string;
+    types?: string;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    scripts?: Record<string, string>;
+    exports?: any;
+    syncbridge?: {
+        version: string;
+        components?: any[];
+        processors?: any[];
+    };
+}

package/types.js

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