@lingva/build-tools 0.0.0-stage → 0.1.0

package/LICENSE.md

@@ -0,0 +1,24 @@
+# Lingva SDK License 1.0
+
+Copyright (c) Yury Saukou. All rights reserved.
+
+Permission is granted, without charge, to install, execute, and internally modify
+this Lingva SDK package for the purpose of integrating applications with Lingva
+or using its local localization features.
+
+You may redistribute the unmodified package, or compiled portions of it, only as
+a dependency or component of an application that provides substantial
+functionality beyond the SDK itself. You may not sell, sublicense, republish, or
+distribute the SDK as a standalone product; remove or alter copyright and
+license notices; use the SDK to provide a competing localization platform or
+SDK; or circumvent access controls, usage limits, or commercial entitlements of
+Lingva services.
+
+Access to hosted Lingva services, paid features, support, and self-hosted Lingva
+software is governed separately and is not granted by this license.
+
+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
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY ARISING
+FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR ITS USE.

package/README.md

@@ -1,3 +1,5 @@
-# Temporary Holding Version
+# Lingva build tools
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Shared package build lock, package-local tsdown launcher, and production source-map removal. Both Lingva repositories consume the same release. `LINGVA_DEV_BUILD=true` enables developer source maps; production builds remove map files and references.
+
+Run `lingva-build` from a package directory. Import `defineLingvaPackageBuildConfig` from `@lingva/build-tools/config` for tsdown configuration.

package/build-package.mjs

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+import { spawn } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const BUILD_LOCK_FILE = '.lingva-build.lock';
+const BUILD_LOCK_RETRY_MS = 100;
+const BUILD_LOCK_METADATA = 'owner.json';
+const STALE_LOCK_METADATA_MS = 60_000;
+const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
+
+function wait(durationMs) {
+  return new Promise((resolve) => setTimeout(resolve, durationMs));
+}
+
+async function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (cause) {
+    return cause?.code !== 'ESRCH';
+  }
+}
+
+async function clearStaleLock(lockPath) {
+  try {
+    const value = JSON.parse(await fs.readFile(path.join(lockPath, BUILD_LOCK_METADATA), 'utf8'));
+
+    if (!Number.isInteger(value.pid) || !(await isProcessRunning(value.pid))) {
+      await fs.rm(lockPath, { force: true, recursive: true });
+    }
+  } catch (cause) {
+    if (cause?.code === 'ENOENT') {
+      return;
+    }
+
+    const stats = await fs.stat(lockPath).catch(() => null);
+    if (stats && Date.now() - stats.mtimeMs > STALE_LOCK_METADATA_MS) {
+      await fs.rm(lockPath, { force: true, recursive: true });
+    }
+  }
+}
+
+async function acquireBuildLock(lockPath) {
+  const token = randomUUID();
+  const value = JSON.stringify({ pid: process.pid, token });
+
+  while (true) {
+    try {
+      await fs.mkdir(lockPath);
+      await fs.writeFile(path.join(lockPath, BUILD_LOCK_METADATA), value, 'utf8');
+      return token;
+    } catch (cause) {
+      if (cause?.code !== 'EEXIST') {
+        throw cause;
+      }
+
+      await clearStaleLock(lockPath);
+      await wait(BUILD_LOCK_RETRY_MS);
+    }
+  }
+}
+
+async function releaseBuildLock(lockPath, token) {
+  try {
+    const current = JSON.parse(await fs.readFile(path.join(lockPath, BUILD_LOCK_METADATA), 'utf8'));
+    if (current.token === token) {
+      await fs.rm(lockPath, { force: true, recursive: true });
+    }
+  } catch (cause) {
+    if (cause?.code !== 'ENOENT') {
+      throw cause;
+    }
+  }
+}
+
+function run(command, args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { cwd: process.cwd(), stdio: 'inherit' });
+    child.once('error', reject);
+    child.once('exit', (code, signal) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+
+      reject(new Error(`${command} exited with ${signal ?? `code ${code}`}.`));
+    });
+  });
+}
+
+export async function runPackageBuild({ copyTemplates } = {}) {
+  const lockPath = path.join(process.cwd(), BUILD_LOCK_FILE);
+  const token = await acquireBuildLock(lockPath);
+
+  try {
+    // Launch the package's own CLI with Node: Windows cannot directly spawn
+    // a .cmd shim, and shell interpolation would break paths containing spaces.
+    const require = createRequire(path.join(process.cwd(), 'package.json'));
+    await run(process.execPath, [require.resolve('tsdown/run')]);
+
+    if (copyTemplates) await copyTemplates();
+
+    await run(process.execPath, [path.join(scriptDirectory, 'protect-build.mjs'), 'dist']);
+  } finally {
+    await releaseBuildLock(lockPath, token);
+  }
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  void runPackageBuild().catch((cause) => {
+    console.error(cause);
+    process.exitCode = 1;
+  });
+}

package/config.d.mts

@@ -0,0 +1,4 @@
+import type { Options } from 'tsdown';
+export declare function defineLingvaPackageBuildConfig(
+  config: Omit<Options, 'minify' | 'sourcemap' | 'clean'>
+): Options;

package/config.mjs

@@ -0,0 +1,9 @@
+import process from 'node:process';
+import { defineConfig } from 'tsdown';
+
+const isDeveloperBuild = process.env.LINGVA_DEV_BUILD === 'true';
+
+/** @param {import('tsdown').Options} config */
+export function defineLingvaPackageBuildConfig(config) {
+  return defineConfig({ ...config, clean: true, minify: !isDeveloperBuild, sourcemap: isDeveloperBuild });
+}

package/package.json

@@ -1,6 +1,35 @@
 {
   "name": "@lingva/build-tools",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Shared protected package builds for Lingva workspaces",
+  "type": "module",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "files": [
+    "build-package.mjs",
+    "protect-build.mjs",
+    "config.mjs",
+    "config.d.mts"
+  ],
+  "bin": {
+    "lingva-build": "./build-package.mjs"
+  },
+  "exports": {
+    "./build": "./build-package.mjs",
+    "./config": {
+      "types": "./config.d.mts",
+      "import": "./config.mjs"
+    }
+  },
+  "peerDependencies": {
+    "tsdown": "^0.21.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/usausoft/lingva.git",
+    "directory": "packages/build-tools"
+  }
 }

package/protect-build.mjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+
+async function collectFiles(targetPath) {
+  const stats = await fs.stat(targetPath);
+
+  if (stats.isFile()) {
+    return [targetPath];
+  }
+
+  if (!stats.isDirectory()) {
+    return [];
+  }
+
+  const entries = await fs.readdir(targetPath, { withFileTypes: true });
+  const files = await Promise.all(
+    entries.map(async (entry) => {
+      const entryPath = path.join(targetPath, entry.name);
+
+      if (entry.isDirectory()) {
+        return collectFiles(entryPath);
+      }
+
+      if (entry.isFile()) {
+        return [entryPath];
+      }
+
+      return [];
+    })
+  );
+
+  return files.flat();
+}
+
+async function stripSourceMapReference(filePath) {
+  let content = await fs.readFile(filePath, 'utf8');
+  content = content.replace(/\n\/\/# sourceMappingURL=.*$/u, '');
+  await fs.writeFile(filePath, content, 'utf8');
+}
+
+async function main() {
+  if (process.env.LINGVA_DEV_BUILD === 'true') {
+    process.exit(0);
+  }
+
+  const distPath = process.argv[2];
+
+  if (!distPath) {
+    console.error('Usage: node scripts/protect-build.mjs <dist-dir>');
+    process.exit(1);
+  }
+
+  const absoluteDistPath = path.resolve(process.cwd(), distPath);
+  const files = await collectFiles(absoluteDistPath);
+
+  await Promise.all(
+    files.map(async (filePath) => {
+      if (filePath.endsWith('.map')) {
+        await fs.rm(filePath, { force: true });
+        return;
+      }
+
+      if (/\.(?:[cm]?[jt]s)$/u.test(filePath)) {
+        await stripSourceMapReference(filePath);
+      }
+    })
+  );
+}
+
+void main();