@neon-rs/cli 0.0.180 → 0.0.182

package/index.js

@@ -7,6 +7,261 @@ import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "module";
 
 var __webpack_unused_export__;
 
+__webpack_unused_export__ = ({ value: true });
+__webpack_unused_export__ = __webpack_unused_export__ = __webpack_unused_export__ = __webpack_unused_export__ = __webpack_unused_export__ = __webpack_unused_export__ = exports.ob = void 0;
+function currentPlatform() {
+    let os = null;
+    switch (process.platform) {
+        case 'android':
+            switch (process.arch) {
+                case 'arm':
+                    return 'android-arm-eabi';
+                case 'arm64':
+                    return 'android-arm64';
+            }
+            os = 'Android';
+            break;
+        case 'win32':
+            switch (process.arch) {
+                case 'x64':
+                    return 'win32-x64-msvc';
+                case 'arm64':
+                    return 'win32-arm64-msvc';
+                case 'ia32':
+                    return 'win32-ia32-msvc';
+            }
+            os = 'Windows';
+            break;
+        case 'darwin':
+            switch (process.arch) {
+                case 'x64':
+                    return 'darwin-x64';
+                case 'arm64':
+                    return 'darwin-arm64';
+            }
+            os = 'macOS';
+            break;
+        case 'linux':
+            switch (process.arch) {
+                case 'x64':
+                case 'arm64':
+                    return isGlibc()
+                        ? `linux-${process.arch}-gnu`
+                        : `linux-${process.arch}-musl`;
+                case 'arm':
+                    return 'linux-arm-gnueabihf';
+            }
+            os = 'Linux';
+            break;
+        case 'freebsd':
+            if (process.arch === 'x64') {
+                return 'freebsd-x64';
+            }
+            os = 'FreeBSD';
+            break;
+    }
+    if (os) {
+        throw new Error(`Neon: unsupported ${os} architecture: ${process.arch}`);
+    }
+    throw new Error(`Neon: unsupported system: ${process.platform}`);
+}
+exports.ob = currentPlatform;
+// DEPRECATE(0.1)
+function currentTarget() {
+    return currentPlatform();
+}
+__webpack_unused_export__ = currentTarget;
+function isGlibc() {
+    // Cast to unknown to work around a bug in the type definition:
+    // https://github.com/DefinitelyTyped/DefinitelyTyped/issues/40140
+    const report = process.report?.getReport();
+    if ((typeof report !== 'object') || !report || (!('header' in report))) {
+        return false;
+    }
+    const header = report.header;
+    return (typeof header === 'object') &&
+        !!header &&
+        ('glibcVersionRuntime' in header);
+}
+// export function debug(...components: string[]) {
+//   if (components.length === 0 || !components[components.length - 1].endsWith(".node")) {
+//     components.push("index.node");
+//   }
+//   const pathSpec = path.join(...components);
+//   return fs.existsSync(pathSpec) ? require(pathSpec) : null;
+// }
+function* interleave(a1, a2) {
+    const length = Math.max(a1.length, a2.length);
+    for (let i = 0; i < length; i++) {
+        if (i < a1.length) {
+            yield a1[i];
+        }
+        if (i < a2.length) {
+            yield a2[i];
+        }
+    }
+}
+function bin(scope, ...rest) {
+    return [...interleave(scope, rest)].join("") + "/" + currentPlatform();
+}
+__webpack_unused_export__ = bin;
+// DEPRECATE(0.1)
+function lazyV1(loaders, exports) {
+    return lazyV2({
+        targets: loaders,
+        exports
+    });
+}
+// DEPRECATE(0.1)
+function lazyV2(options) {
+    return lazyV3({
+        platforms: options.targets,
+        exports: options.exports,
+        debug: options.debug
+    });
+}
+function lazyV3(options) {
+    const loaders = options.platforms;
+    let loaded = null;
+    function load() {
+        if (loaded) {
+            return loaded;
+        }
+        const platform = currentPlatform();
+        if (!loaders.hasOwnProperty(platform)) {
+            throw new Error(`no precompiled module found for ${platform}`);
+        }
+        if (options.debug) {
+            try {
+                loaded = options.debug();
+            }
+            catch (_e) {
+                loaded = null;
+            }
+        }
+        if (!loaded) {
+            loaded = loaders[platform]();
+        }
+        return loaded;
+    }
+    let module = {};
+    for (const key of options.exports) {
+        Object.defineProperty(module, key, { get() { return load()[key]; } });
+    }
+    return module;
+}
+function lazy(optionsOrLoaders, exports) {
+    return (!exports && !('targets' in optionsOrLoaders))
+        ? lazyV3(optionsOrLoaders)
+        : !exports
+            ? lazyV2(optionsOrLoaders)
+            : lazyV1(optionsOrLoaders, exports);
+}
+__webpack_unused_export__ = lazy;
+function __UNSTABLE_loader(loaders) {
+    const platform = currentPlatform();
+    if (!loaders.hasOwnProperty(platform)) {
+        throw new Error(`no precompiled module found for ${platform}`);
+    }
+    const loader = loaders[platform];
+    let loaded = null;
+    return () => {
+        if (loaded) {
+            return loaded;
+        }
+        loaded = loader();
+        return loaded;
+    };
+}
+__webpack_unused_export__ = __UNSTABLE_loader;
+// DEPRECATE(0.1)
+function isDeprecatedProxyOptions(options) {
+    return 'targets' in options;
+}
+function isProxyOptions(options) {
+    return 'platforms' in options;
+}
+function proxy(options) {
+    const opts = isProxyOptions(options)
+        ? options
+        : !isDeprecatedProxyOptions(options)
+            ? { platforms: options }
+            : { platforms: options.targets, debug: options.debug };
+    const platform = currentPlatform();
+    const loaders = opts.platforms;
+    if (!loaders.hasOwnProperty(platform)) {
+        throw new Error(`no precompiled module found for ${platform}`);
+    }
+    const loader = loaders[platform];
+    let loaded = null;
+    function load() {
+        if (!loaded) {
+            if (options.debug) {
+                try {
+                    loaded = options.debug();
+                }
+                catch (_e) {
+                    loaded = null;
+                }
+            }
+            if (!loaded) {
+                loaded = loader();
+            }
+        }
+        return loaded;
+    }
+    const handler = {
+        has(_target, key) {
+            return Reflect.has(load(), key);
+        },
+        get(_target, key) {
+            return Reflect.get(load(), key);
+        },
+        ownKeys(_target) {
+            return Reflect.ownKeys(load());
+        },
+        defineProperty(_target, _key, _descriptor) {
+            throw new Error('attempt to modify read-only Neon module proxy');
+        },
+        deleteProperty(_target, _key) {
+            throw new Error('attempt to modify read-only Neon module proxy');
+        },
+        set(_target, _key, _val) {
+            throw new Error('attempt to modify read-only Neon module proxy');
+        },
+        setPrototypeOf(_target, _proto) {
+            throw new Error('attempt to modify read-only Neon module proxy');
+        },
+        getPrototypeOf(_target) {
+            return Object.getPrototypeOf(load());
+        },
+        isExtensible(_target) {
+            return Reflect.isExtensible(load());
+        },
+        preventExtensions(_target) {
+            return Reflect.preventExtensions(load());
+        },
+        getOwnPropertyDescriptor(_target, key) {
+            return Reflect.getOwnPropertyDescriptor(load(), key);
+        }
+    };
+    return new Proxy({}, handler);
+}
+__webpack_unused_export__ = proxy;
+// DEPRECATE(0.1)
+function __UNSTABLE_proxy(options) {
+    return proxy(options);
+}
+__webpack_unused_export__ = __UNSTABLE_proxy;
+
+
+/***/ }),
+
+/***/ 8372:
+/***/ ((__unused_webpack_module, exports) => {
+
+var __webpack_unused_export__;
+
 __webpack_unused_export__ = ({ value: true });
 __webpack_unused_export__ = exports.sj = __webpack_unused_export__ = __webpack_unused_export__ = __webpack_unused_export__ = __webpack_unused_export__ = __webpack_unused_export__ = void 0;
 function currentPlatform() {
@@ -44194,7 +44449,7 @@ function wrappy (fn, cb) {
 
 /***/ }),
 
-/***/ 5834:
+/***/ 5291:
 /***/ ((__unused_webpack_module, __webpack_exports__, __nccwpck_require__) => {
 
 
@@ -46416,6 +46671,9 @@ class SourceManifest extends AbstractManifest {
         }
         return undefined;
     }
+    allPlatforms() {
+        return this._expandedPlatforms;
+    }
     rustTargetFor(node) {
         return this._expandedPlatforms[node];
     }
@@ -46729,7 +46987,7 @@ class Tarball {
             this.log(`npm pack failed with exit code ${result.exitCode}`);
             process.exit(result.exitCode);
         }
-        // FIXME: comment linking to the npm issue this fixes
+        // NOTE: This is a workaround for https://github.com/npm/cli/issues/3405
         const tarball = JSON.parse(result.stdout)[0].filename.replace('@', '').replace('/', '-');
         this.log(`tarball filename: ${tarball}`);
         const dest = external_node_path_namespaceObject.join(this._outDir, tarball);
@@ -46937,6 +47195,89 @@ class UpdatePlatforms {
     }
 }
 
+;// CONCATENATED MODULE: ./src/commands/list-platforms.ts
+
+
+const list_platforms_OPTIONS = [
+    { name: 'verbose', alias: 'v', type: Boolean, defaultValue: false }
+];
+class ListPlatforms {
+    static summary() { return 'Display the JSON target data for this project\'s platforms.'; }
+    static syntax() { return 'neon list-platforms [-v]'; }
+    static options() {
+        return [
+            { name: '-v, --verbose', summary: 'Enable verbose logging. (Default: false)' }
+        ];
+    }
+    static seeAlso() { }
+    static extraSection() { }
+    _verbose;
+    constructor(argv) {
+        const options = dist_default()(list_platforms_OPTIONS, { argv });
+        this._verbose = !!options.verbose;
+    }
+    log(msg) {
+        if (this._verbose) {
+            console.error("[neon list-platforms] " + msg);
+        }
+    }
+    async run() {
+        this.log(`reading package.json`);
+        const sourceManifest = await SourceManifest.load();
+        this.log(`manifest: ${sourceManifest.stringify()}`);
+        const platforms = sourceManifest.allPlatforms();
+        console.log(JSON.stringify(platforms, null, 2));
+    }
+}
+
+// EXTERNAL MODULE: ./node_modules/@neon-rs/load/dist/index.js
+var load_dist = __nccwpck_require__(8938);
+;// CONCATENATED MODULE: ./src/commands/current-platform.ts
+
+
+const current_platform_OPTIONS = [
+    { name: 'json', type: Boolean, defaultValue: false },
+    { name: 'verbose', alias: 'v', type: Boolean, defaultValue: false }
+];
+class CurrentPlatform {
+    static summary() { return 'Display the current device\'s platform info.'; }
+    static syntax() { return 'neon current-platform [--json] [-v]'; }
+    static options() {
+        return [
+            { name: '--json', summary: 'Display platform info in JSON format. (Default: false)' },
+            { name: '-v, --verbose', summary: 'Enable verbose logging. (Default: false)' }
+        ];
+    }
+    static seeAlso() { }
+    static extraSection() { }
+    _json;
+    _verbose;
+    constructor(argv) {
+        const options = dist_default()(current_platform_OPTIONS, { argv });
+        this._json = options.json || false;
+        this._verbose = !!options.verbose;
+    }
+    log(msg) {
+        if (this._verbose) {
+            console.error("[neon current-platform] " + msg);
+        }
+    }
+    async run() {
+        if (this._json) {
+            const [os, arch, abi] = (0,load_dist/* currentPlatform */.ob)().split('-');
+            const json = {
+                os,
+                arch,
+                abi: abi || null
+            };
+            console.log(JSON.stringify(json, null, 2));
+        }
+        else {
+            console.log((0,load_dist/* currentPlatform */.ob)());
+        }
+    }
+}
+
 ;// CONCATENATED MODULE: ./src/commands/rust-target.ts
 
 
@@ -47020,27 +47361,24 @@ class RustTarget {
 
 
 const preset_OPTIONS = [
-    { name: 'pretty', alias: 'p', type: Boolean, defaultValue: false },
+    { name: 'pretty', alias: 'p', type: Boolean, defaultValue: true },
     { name: 'verbose', alias: 'v', type: Boolean, defaultValue: false }
 ];
 class Preset {
     static summary() { return 'Display the JSON target data for a platform preset.'; }
-    static syntax() { return 'neon preset [-p] [-v] <preset>'; }
+    static syntax() { return 'neon preset [-v] <preset>'; }
     static options() {
         return [
             { name: '<preset>', summary: 'The target family preset to look up.' },
-            { name: '-p, --pretty', summary: 'Pretty-print the JSON output. (Default: false)' },
             { name: '-v, --verbose', summary: 'Enable verbose logging. (Default: false)' }
         ];
     }
     static seeAlso() { }
     static extraSection() { }
-    _pretty;
     _verbose;
     _preset;
     constructor(argv) {
         const options = dist_default()(preset_OPTIONS, { argv, partial: true });
-        this._pretty = options.pretty || false;
         this._verbose = !!options.verbose;
         if (!options._unknown || options._unknown.length === 0) {
             throw new Error("Missing argument, expected <preset>");
@@ -47058,10 +47396,7 @@ class Preset {
     }
     async run() {
         const map = expandPlatformPreset(this._preset);
-        const output = this._pretty
-            ? JSON.stringify(map, null, 2)
-            : JSON.stringify(map);
-        console.log(output);
+        console.log(JSON.stringify(map, null, 2));
     }
 }
 
@@ -47106,6 +47441,8 @@ class Help {
 
 
 
+
+
 var CommandName;
 (function (CommandName) {
     CommandName["Help"] = "help";
@@ -47118,6 +47455,8 @@ var CommandName;
     CommandName["InstallBuilds"] = "install-builds";
     CommandName["UpdateTargets"] = "update-targets";
     CommandName["UpdatePlatforms"] = "update-platforms";
+    CommandName["ListPlatforms"] = "list-platforms";
+    CommandName["CurrentPlatform"] = "current-platform";
     CommandName["RustTarget"] = "rust-target";
     CommandName["Preset"] = "preset";
 })(CommandName || (CommandName = {}));
@@ -47143,6 +47482,8 @@ const COMMANDS = {
     [CommandName.InstallBuilds]: UpdatePlatforms,
     [CommandName.UpdateTargets]: UpdatePlatforms,
     [CommandName.UpdatePlatforms]: UpdatePlatforms,
+    [CommandName.ListPlatforms]: ListPlatforms,
+    [CommandName.CurrentPlatform]: CurrentPlatform,
     [CommandName.RustTarget]: RustTarget,
     [CommandName.Preset]: Preset
 };
@@ -47154,10 +47495,10 @@ function summaries() {
         { name: CommandName.Help, summary: Help.summary() },
         { name: CommandName.Dist, summary: Dist.summary() },
         { name: CommandName.Bump, summary: Bump.summary() },
-        { name: CommandName.Tarball, summary: Tarball.summary() },
         { name: CommandName.AddPlatform, summary: AddPlatform.summary() },
         { name: CommandName.UpdatePlatforms, summary: UpdatePlatforms.summary() },
-        { name: CommandName.RustTarget, summary: RustTarget.summary() },
+        { name: CommandName.ListPlatforms, summary: ListPlatforms.summary() },
+        { name: CommandName.CurrentPlatform, summary: CurrentPlatform.summary() },
         { name: CommandName.Preset, summary: Preset.summary() }
     ];
 }
@@ -47172,7 +47513,7 @@ __nccwpck_require__.a(module, async (__webpack_handle_async_dependencies__, __we
 /* harmony import */ var command_line_commands__WEBPACK_IMPORTED_MODULE_0__ = __nccwpck_require__(5046);
 /* harmony import */ var command_line_commands__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__nccwpck_require__.n(command_line_commands__WEBPACK_IMPORTED_MODULE_0__);
 /* harmony import */ var _print_js__WEBPACK_IMPORTED_MODULE_1__ = __nccwpck_require__(9050);
-/* harmony import */ var _command_js__WEBPACK_IMPORTED_MODULE_2__ = __nccwpck_require__(5834);
+/* harmony import */ var _command_js__WEBPACK_IMPORTED_MODULE_2__ = __nccwpck_require__(5291);
 /* harmony import */ var node_module__WEBPACK_IMPORTED_MODULE_3__ = __nccwpck_require__(2033);
 /* harmony import */ var node_module__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__nccwpck_require__.n(node_module__WEBPACK_IMPORTED_MODULE_3__);
 
@@ -50195,8 +50536,8 @@ const chalkStderr = createChalk({level: stderrColor ? stderrColor.level : 0});
 
 /* harmony default export */ const chalk_source = (chalk);
 
-// EXTERNAL MODULE: ./src/command.ts + 40 modules
-var command = __nccwpck_require__(5834);
+// EXTERNAL MODULE: ./src/command.ts + 42 modules
+var command = __nccwpck_require__(5291);
 ;// CONCATENATED MODULE: ./src/print.ts
 
 
@@ -65069,7 +65410,7 @@ module.exports = {
 /***/ 6459:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
-module.exports = (__nccwpck_require__(8938)/* .proxy */ .sj)({
+module.exports = (__nccwpck_require__(8372)/* .proxy */ .sj)({
   'darwin-x64': () => __nccwpck_require__(2990),
   'win32-x64-msvc': () => __nccwpck_require__(1324),
   'win32-arm64-msvc': () => __nccwpck_require__(7894),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neon-rs/cli",
-  "version": "0.0.180",
+  "version": "0.0.182",
   "description": "Command-line build tool for Neon modules.",
   "type": "module",
   "exports": "./index.js",
@@ -27,12 +27,12 @@
   },
   "homepage": "https://github.com/dherman/neon-rs#readme",
   "optionalDependencies": {
-    "@cargo-messages/android-arm-eabi": "0.0.180",
-    "@cargo-messages/darwin-arm64": "0.0.180",
-    "@cargo-messages/darwin-x64": "0.0.180",
-    "@cargo-messages/linux-arm-gnueabihf": "0.0.180",
-    "@cargo-messages/linux-x64-gnu": "0.0.180",
-    "@cargo-messages/win32-arm64-msvc": "0.0.180",
-    "@cargo-messages/win32-x64-msvc": "0.0.180"
+    "@cargo-messages/android-arm-eabi": "0.0.182",
+    "@cargo-messages/darwin-arm64": "0.0.182",
+    "@cargo-messages/darwin-x64": "0.0.182",
+    "@cargo-messages/linux-arm-gnueabihf": "0.0.182",
+    "@cargo-messages/linux-x64-gnu": "0.0.182",
+    "@cargo-messages/win32-arm64-msvc": "0.0.182",
+    "@cargo-messages/win32-x64-msvc": "0.0.182"
   }
 }