@lakutata/builder 3.1.5 → 3.1.6

package/dist/types/lib/mobile/Addons.d.ts

@@ -0,0 +1,154 @@
+import type { NativeFile } from '../Native.js';
+import { type AndroidAbi } from './Node.js';
+/**
+ * The SDKs of iOS the native addons are built for: the architectures built and the slice of the framework of the
+ * Node.js of the application (NodeMobile.xcframework) they link
+ */
+declare const IOS_SDKS: {
+    readonly iphoneos: {
+        readonly archs: "arm64";
+        readonly slice: "ios-arm64";
+        readonly platform: "iPhoneOS";
+    };
+    readonly iphonesimulator: {
+        readonly archs: "arm64";
+        readonly slice: "ios-arm64-simulator";
+        readonly platform: "iPhoneSimulator";
+    };
+};
+/**
+ * A SDK of iOS: iphoneos (the devices) or iphonesimulator (the simulators of the Macs of Apple silicon)
+ */
+export type IosSdk = keyof typeof IOS_SDKS;
+/**
+ * The file of a Node.js project mapping the placeholders of its addons (their paths in the native tree) to the libraries
+ * the system loads instead (the frameworks of the application on iOS, the libraries of the HAP on HarmonyOS):
+ * {directory, files}, the directory relative to the project or absolute
+ */
+export declare const MOBILE_ADDONS_FILE: string;
+/**
+ * What was done to the native addons of a mobile application
+ */
+export type MobileAddons = {
+    /**
+     * The packages built from their sources (now, or before: the cache), with the target built for:
+     * `@lakutata/math (arm64-v8a)`
+     */
+    built: string[];
+    /**
+     * The packages whose prebuilt addons of the system were kept (prebuilds/android-<arch>)
+     */
+    prebuilt: string[];
+    /**
+     * The frameworks made of the addons (iOS), for each SDK: `iphonesimulator/lakutata-math-math.framework`
+     */
+    frameworks: string[];
+    /**
+     * The libraries made of the addons (HarmonyOS), in the libraries of the HAP: `liblakutata-math-math.so`
+     */
+    libraries: string[];
+};
+/**
+ * The options of the native addons of a mobile application
+ */
+export type MobileAddonOptions = {
+    /**
+     * The architectures of Android built for, the ones of libnode by default
+     */
+    abis?: AndroidAbi[];
+    /**
+     * The SDKs of iOS built for, both by default (iphoneos, iphonesimulator)
+     */
+    sdks?: IosSdk[];
+    /**
+     * Called with what is done, the builds taking a while
+     */
+    progress?: (message: string) => void;
+};
+/**
+ * Build the native addons of a mobile application of Android: a native tree per architecture (<directory>-<arch>, the
+ * one of process.arch loaded by the bundle), each package of addons built for it from its sources (node-gyp, the NDK,
+ * the headers and the library of libnode), or keeping its prebuilt addons of the architecture
+ * (prebuilds/android-<arch>, node-gyp-build). The tree of the build is removed once they are made
+ * @param project
+ * @param directory the native tree
+ * @param files the files of the tree
+ * @param node the export of the libnode of Android
+ * @param options
+ * @internal
+ */
+export declare function prepareAndroidAddons(project: string, directory: string, files: NativeFile[], node: string, options?: MobileAddonOptions): Promise<MobileAddons>;
+/**
+ * The name of the framework of an addon: its package and its file, in the characters of the names and of the
+ * identifiers of the bundles (letters, digits and hyphens)
+ * @param name the name of its package
+ * @param file its file
+ * @internal
+ */
+export declare function frameworkName(name: string, file: string): string;
+/**
+ * The Info.plist of the framework of an addon: the keys the frameworks embedded in an application of the App Store
+ * have
+ * @param name
+ * @param version the version of its package
+ * @param sdk
+ * @internal
+ */
+export declare function frameworkInfo(name: string, version: string, sdk: IosSdk): string;
+/**
+ * The headers of a libnode as node-gyp builds the addons against them, linked but for these:
+ * - node_object_wrap.h without the calls of the cleanup hooks of node::ObjectWrap (OBJECT_WRAP_HOOKS), as in the headers
+ *   of Node.js 24.18: an addon built on node::ObjectWrap (better-sqlite3, the addons of NAN) would abort the application
+ *   whenever the garbage collector frees one of its objects. A header without them is copied as it is;
+ * - for iOS, config.gypi with OS "mac": the libnode of iOS is configured with OS "ios", for which the common.gypi of
+ *   Node.js turns the exceptions and the RTTI of C++ off in the projects of Xcode as it does for macOS, while the addons
+ *   (and node-addon-api) give their settings of Xcode (the exceptions, the RTTI, the standard of C++) to OS "mac" only.
+ *   Built as for macOS, an addon keeps them; the SDK, the architectures and the deployment target of iOS are given to
+ *   xcodebuild
+ * @param node the export of the libnode
+ * @param work a directory of the build
+ * @param os "mac" for iOS: the OS given to config.gypi
+ * @returns the directory of the headers (the nodedir of node-gyp)
+ */
+export declare function addonNodeHeaders(node: string, work: string, os?: 'mac'): Promise<string>;
+/**
+ * Build the native addons of a mobile application of iOS: each package of addons built for the SDKs from its sources
+ * (node-gyp, xcodebuild, linking the framework of the Node.js of the application), each addon made a framework, which
+ * the project of iOS embeds in the application; its files in the native tree replaced by placeholders (no library of
+ * the App Store outside of its frameworks), which the entry of the project loads from the frameworks of the application
+ * (MOBILE_ADDONS_FILE: the project is in the application, next to its frameworks). The frameworks of the SDKs made
+ * before are removed
+ * @param project
+ * @param stage the Node.js project
+ * @param directory its native tree
+ * @param files the files of the tree
+ * @param frameworks the directory of the frameworks, a directory per SDK (the NodeAddons of the project of iOS)
+ * @param node the export of the libnode of iOS
+ * @param options
+ * @internal
+ */
+export declare function prepareIosAddons(project: string, stage: string, directory: string, files: NativeFile[], frameworks: string, node: string, options?: MobileAddonOptions): Promise<MobileAddons>;
+/**
+ * The name of the library of an addon in the HAP: libaddon-<package>-<file>.so, in letters, digits, hyphens and
+ * underscores (the libraries made before are the libaddon-*.so of the directory)
+ * @param name the name of its package
+ * @param file its file
+ * @internal
+ */
+export declare function harmonyLibraryName(name: string, file: string): string;
+/**
+ * Build the native addons of a mobile application of HarmonyOS: each package of addons built from its sources (node-gyp,
+ * the LLVM of the native SDK, linking libnode.so), each addon made a library of the HAP (libaddon-<package>-<file>.so in
+ * its libs/arm64-v8a: the addons cannot be loaded from the resources of the HAP); its files in the native tree replaced
+ * by placeholders, which the entry of the project loads from the libraries of the HAP (MOBILE_ADDONS_FILE)
+ * @param project
+ * @param stage the Node.js project
+ * @param directory its native tree
+ * @param files the files of the tree
+ * @param libraries the directory of the libraries of the HAP (the libs/arm64-v8a of its module)
+ * @param node the export of the libnode of HarmonyOS
+ * @param options
+ * @internal
+ */
+export declare function prepareHarmonyAddons(project: string, stage: string, directory: string, files: NativeFile[], libraries: string, node: string, options?: MobileAddonOptions): Promise<MobileAddons>;
+export {};

package/dist/types/lib/mobile/Node.d.ts

@@ -0,0 +1,89 @@
+/**
+ * The version of Node.js of the mobile applications when their libnode does not tell it: the one of the release of
+ * lakutata/libnode they download (MOBILE_NODE_RELEASE)
+ */
+export declare const MOBILE_NODE_VERSION: string;
+/**
+ * The systems of the mobile applications of React Native
+ */
+export type MobilePlatform = 'android' | 'ios' | 'harmony';
+/**
+ * The architectures of Android of a libnode built for them (the arch of Node.js names the native tree of the
+ * architecture, the target names the compilers of the NDK)
+ */
+export declare const ANDROID_ABIS: {
+    readonly 'arm64-v8a': {
+        readonly arch: "arm64";
+        readonly target: "aarch64-linux-android";
+    };
+    readonly 'armeabi-v7a': {
+        readonly arch: "arm";
+        readonly target: "armv7a-linux-androideabi";
+    };
+    readonly x86_64: {
+        readonly arch: "x64";
+        readonly target: "x86_64-linux-android";
+    };
+};
+/**
+ * An architecture of Android (an ABI): arm64-v8a, armeabi-v7a or x86_64
+ */
+export type AndroidAbi = keyof typeof ANDROID_ABIS;
+/**
+ * The version of Node.js of a libnode: the one of its headers (include/node/node_version.h)
+ * @param directory the export of the libnode
+ * @internal
+ */
+export declare function mobileNodeVersion(directory: string): string;
+/**
+ * The architectures of Android a libnode is built for (libs/<abi>/libnode.so)
+ * @param directory the export of the libnode of Android
+ * @internal
+ */
+export declare function mobileNodeAbis(directory: string): AndroidAbi[];
+/**
+ * Check the export of a libnode of a system: its headers, and its libraries (Android: libs/<abi>/libnode.so, HarmonyOS:
+ * libs/arm64-v8a/libnode.so) or its framework (iOS: NodeMobile.xcframework)
+ * @param platform
+ * @param directory
+ * @internal
+ */
+export declare function checkMobileNode(platform: MobilePlatform, directory: string): void;
+/**
+ * The release of lakutata/libnode the mobile applications download their libnode from: its tag is v<release> (the
+ * version of Node.js, then -<revision> for a release of the same version built again)
+ */
+export declare const MOBILE_NODE_RELEASE: string;
+/**
+ * The options of {@link downloadMobileNode}
+ */
+export type MobileNodeDownloadOptions = {
+    /**
+     * The system downloaded for
+     */
+    platform: MobilePlatform;
+    /**
+     * The architectures of Android downloaded for, arm64-v8a and x86_64 by default (the devices, the emulators of the
+     * computers of Intel)
+     */
+    abis?: AndroidAbi[];
+    /**
+     * Called with what is being downloaded
+     */
+    progress?: (line: string) => void;
+};
+/**
+ * Download the libnode of a mobile system from the releases of lakutata/libnode (LAKUTATA_LIBNODE_MIRROR: a mirror of
+ * them), once: its archives are checked with the SHA256SUMS of the release and kept in the cache
+ * (~/.cache/lakutata/mobile, LAKUTATA_CACHE_DIR). LAKUTATA_MOBILE_NODE_DIR gives exports of a libnode of your own instead
+ * (a directory per system: android, ios, harmony; built with the repository of lakutata/libnode)
+ * @param options
+ * @returns the directory of the export: its headers (include/node) and its libraries (libs/<abi>/libnode.so) or its
+ * framework (NodeMobile.xcframework)
+ * @example
+ * import {downloadMobileNode} from '@lakutata/builder'
+ *
+ * const directory = await downloadMobileNode({platform: 'android', abis: ['arm64-v8a'], progress: console.log})
+ * console.log(directory)
+ */
+export declare function downloadMobileNode(options: MobileNodeDownloadOptions): Promise<string>;

package/dist/types/lib/mobile/Stage.d.ts

@@ -0,0 +1,111 @@
+import { type BundleResult } from '../Bundle.js';
+import { type IosSdk, type MobileAddons } from './Addons.js';
+import { type AndroidAbi, type MobilePlatform } from './Node.js';
+/**
+ * The options of {@link stageMobileApp}
+ */
+export type MobileStageOptions = {
+    /**
+     * The system the project is made for: Android (copied from the assets of the application into its files at its
+     * first launch), iOS (in the bundle of the application) or HarmonyOS (in the resources of the HAP)
+     */
+    platform: MobilePlatform;
+    /**
+     * The directory of the application (its package.json), the current one by default
+     */
+    project?: string;
+    /**
+     * The directory of the Node.js project made, which the native project of the system packs into the application
+     * (android/app/src/main/assets/nodejs, ios/nodejs, harmony/entry/src/main/resources/resfile/nodejs in the projects
+     * of the mobile-react template); made again at each stage
+     */
+    outdir: string;
+    /**
+     * The compiled entry of the application (the "main" of the package.json by default)
+     */
+    entry?: string;
+    /**
+     * Minify the bundle (true by default)
+     */
+    minify?: boolean;
+    /**
+     * The modules left out of the bundle, besides `@lakutata/netif` (the listening on network interfaces, which the
+     * mobile systems do not have)
+     */
+    external?: string[];
+    /**
+     * The libnode of the system: the directory it is put into (packages/ipc/native/node/out/<platform> in the projects
+     * of the mobile-react template), its headers (include/node) and its libraries. The bundle targets its version of
+     * Node.js (24.20.0 without it); the native addons are built against it, and need it
+     */
+    node?: string;
+    /**
+     * The architectures of Android the native addons are built for, the ones of the libnode by default
+     */
+    abis?: AndroidAbi[];
+    /**
+     * The SDKs of iOS the native addons are built for: iphoneos and iphonesimulator by default
+     */
+    sdks?: IosSdk[];
+    /**
+     * The directory of the frameworks of the native addons of iOS, a directory per SDK, which the project of iOS embeds
+     * in the application (`ios/NodeAddons` in the projects of the template); required by the native addons of iOS, the
+     * frameworks of the SDKs built made again at each stage
+     */
+    frameworks?: string;
+    /**
+     * The directory of the libraries of the HAP the native addons of HarmonyOS are put in
+     * (`harmony/entry/libs/arm64-v8a` in the projects of the template); required by the native addons of HarmonyOS, the
+     * libraries of the addons made before (libaddon-*.so) removed at each stage
+     */
+    libraries?: string;
+    /**
+     * Called with what is done (the native addons built, which takes a while)
+     */
+    progress?: (message: string) => void;
+};
+/**
+ * The Node.js project made by {@link stageMobileApp}
+ */
+export type MobileStage = {
+    /**
+     * Its directory: its manifest (package.json), its entry (main.js), the bundle of the application (app.cjs) and its
+     * resources (resources)
+     */
+    directory: string;
+    /**
+     * The system it is made for
+     */
+    platform: MobilePlatform;
+    /**
+     * The version of Node.js it is made for
+     */
+    node: string;
+    bundle: BundleResult;
+    /**
+     * What was done to the native addons of the application, undefined without addon
+     */
+    addons?: MobileAddons;
+};
+/**
+ * Make the Node.js project of a mobile application of React Native (Android, iOS, HarmonyOS), which the native module
+ * of the application runs in its libnode: the bundle of the application (CommonJS, for the version of Node.js of the
+ * libnode) and its resources (lakutata.resources), its manifest and its entry. The bundle holds the dependencies: the
+ * project is packed into the application as it is. The native addons are built for the system from the sources of their
+ * packages, against the headers and the libraries of the libnode: on Android, a native tree per architecture (node-gyp
+ * and the NDK of Android); on iOS, a framework per addon for each SDK (node-gyp and Xcode), in the directory of the
+ * frameworks the project of iOS embeds; on HarmonyOS, a library per addon (node-gyp and the native SDK of HarmonyOS),
+ * in the libraries of the HAP
+ * @param options
+ * @example
+ * import {stageMobileApp} from '@lakutata/builder'
+ *
+ * //In packages/app of a project of the mobile-react template, before the application of Android is built
+ * const stage = await stageMobileApp({
+ *     platform: 'android',
+ *     outdir: '../../android/app/src/main/assets/nodejs',
+ *     node: '../ipc/native/node/out/android'
+ * })
+ * console.log(stage.directory, stage.node)
+ */
+export declare function stageMobileApp(options: MobileStageOptions): Promise<MobileStage>;

package/dist/types/lib/nwjs/Addons.d.ts

@@ -37,6 +37,24 @@ export type NwjsAddons = {
      */
     rebuilt: string[];
 };
+/**
+ * node-gyp: the one of the project, of the builder, else the one of npm
+ * @param project
+ * @internal
+ */
+export declare function nodeGyp(project: string): string;
+/**
+ * The directory of the package of a file (the one holding its package.json)
+ * @param file
+ * @internal
+ */
+export declare function packageOf(file: string): string | undefined;
+/**
+ * The .node files under a directory
+ * @param directory
+ * @internal
+ */
+export declare function nodeFiles(directory: string): Promise<string[]>;
 /**
  * Make the addons of the native tree of an application of NW.js load in its runtime: the packages whose addons are not
  * for the architecture of the runtime (built with the headers of its Node.js), or use V8 (NW.js 0.111.3 and later: the

package/dist/types/lib/nwjs/Package.d.ts

@@ -8,6 +8,10 @@ export type NwjsAppOptions = Omit<NwjsStageOptions, 'outdir'> & {
      * The directory of the application made (dist/nwjs by default): <program>-<build of NW.js> in it
      */
     outdir?: string;
+    /**
+     * Called with what is being downloaded (the runtime of NW.js)
+     */
+    progress?: (line: string) => void;
 };
 /**
  * The application of NW.js made by {@link buildNwjsApp}, distributed as it is or by its installers

package/dist/types/lib/nwjs/Runtime.d.ts

@@ -49,6 +49,10 @@ export type NwjsRuntimeOptions = {
      * a release without osx-arm64 (before 0.77) is the x64 one, run by Rosetta
      */
     arch?: string;
+    /**
+     * Called with what is being downloaded
+     */
+    progress?: (line: string) => void;
 };
 /**
  * A runtime of NW.js, downloaded into the cache

package/dist/types/lib/win/Windows.d.ts

@@ -40,8 +40,9 @@ export declare function wixSource(plan: InstallerPlan, stage: string, serviceDir
  * @param targets
  * @param work
  * @param outdir
+ * @param progress Called with what is being downloaded (WinSW, NSIS, WiX)
  */
-export declare function buildWindowsPackages(plan: InstallerPlan, targets: WindowsTarget[], work: string, outdir: string): Promise<{
+export declare function buildWindowsPackages(plan: InstallerPlan, targets: WindowsTarget[], work: string, outdir: string, progress?: (line: string) => void): Promise<{
     target: string;
     file: string;
     size: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lakutata/builder",
-  "version": "3.1.5",
+  "version": "3.1.6",
   "description": "The builder of the applications of the lakutata framework: their bundles, their executables (Node.js, Bun) with their native addons and their resources.",
   "keywords": [
     "lakutata",