commit 77dca5875a4d305ed163ef081d9a9b82a2a99c9f · pyrox.dev/nixpkgs

+45

lib/systems/default.nix

···

       562
       562
        
                   # See https://go.dev/wiki/GoArm

     

       563
       563
        
                   GOARM = toString (lib.intersectLists [ (final.parsed.cpu.version or "") ] [ "5" "6" "7" ]);

     

       564
       564
        
                 };

     

       565
       565
       +
       

     

       566
       566
       +
                 node = {

     

       567
       567
       +
                   # See these locations for a list of known architectures/platforms:

     

       568
       568
       +
                   # - https://nodejs.org/api/os.html#osarch

     

       569
       569
       +
                   # - https://nodejs.org/api/os.html#osplatform

     

       570
       570
       +
                   arch =

     

       571
       571
       +
                     if final.isAarch then

     

       572
       572
       +
                       "arm" + lib.optionalString final.is64bit "64"

     

       573
       573
       +
                     else if final.isMips32 then

     

       574
       574
       +
                       "mips" + lib.optionalString final.isLittleEndian "el"

     

       575
       575
       +
                     else if final.isMips64 && final.isLittleEndian then

     

       576
       576
       +
                       "mips64el"

     

       577
       577
       +
                     else if final.isPower then

     

       578
       578
       +
                       "ppc" + lib.optionalString final.is64bit "64"

     

       579
       579
       +
                     else if final.isx86_64 then

     

       580
       580
       +
                       "x64"

     

       581
       581
       +
                     else if final.isx86_32 then

     

       582
       582
       +
                       "ia32"

     

       583
       583
       +
                     else if final.isS390x then

     

       584
       584
       +
                       "s390x"

     

       585
       585
       +
                     else if final.isRiscV64 then

     

       586
       586
       +
                       "riscv64"

     

       587
       587
       +
                     else if final.isLoongArch64 then

     

       588
       588
       +
                       "loong64"

     

       589
       589
       +
                     else

     

       590
       590
       +
                       null;

     

       591
       591
       +
       

     

       592
       592
       +
                   platform =

     

       593
       593
       +
                     if final.isAndroid then

     

       594
       594
       +
                       "android"

     

       595
       595
       +
                     else if final.isDarwin then

     

       596
       596
       +
                       "darwin"

     

       597
       597
       +
                     else if final.isFreeBSD then

     

       598
       598
       +
                       "freebsd"

     

       599
       599
       +
                     else if final.isLinux then

     

       600
       600
       +
                       "linux"

     

       601
       601
       +
                     else if final.isOpenBSD then

     

       602
       602
       +
                       "openbsd"

     

       603
       603
       +
                     else if final.isSunOS then

     

       604
       604
       +
                       "sunos"

     

       605
       605
       +
                     else if final.isWindows then

     

       606
       606
       +
                       "win32"

     

       607
       607
       +
                     else

     

       608
       608
       +
                       null;

     

       609
       609
       +
                 };

     

       565
       610
        
               };

     

       566
       611
        
           in

     

       567
       612
        
           assert final.useAndroidPrebuilt -> final.isAndroid;

-10

pkgs/build-support/node/build-npm-package/default.nix

···

       103
       103
        
             # Stripping takes way too long with the amount of files required by a typical Node.js project.

     

       104
       104
        
             dontStrip = args.dontStrip or true;

     

       105
       105
        
       

     

       106
       106
       -
             env = {

     

       107
       107
       -
               npm_config_arch =

     

       108
       108
       -
                 {

     

       109
       109
       -
                   "x86_64" = "x64";

     

       110
       110
       -
                   "aarch64" = "arm64";

     

       111
       111
       -
                 }

     

       112
       112
       -
                 .${stdenv.hostPlatform.parsed.cpu.name} or stdenv.hostPlatform.parsed.cpu.name;

     

       113
       113
       -
               npm_config_platform = stdenv.hostPlatform.parsed.kernel.name;

     

       114
       114
       -
             } // (args.env or { });

     

       115
       115
       -
       

     

       116
       106
        
             meta = (args.meta or { }) // {

     

       117
       107
        
               platforms = args.meta.platforms or nodejs.meta.platforms;

     

       118
       108
        
             };

+3

pkgs/build-support/node/build-npm-package/hooks/default.nix

···

       1
       1
        
       {

     

       2
       2
        
         lib,

     

       3
       3
        
         srcOnly,

     

       4
       4
       +
         stdenv,

     

       4
       5
        
         makeSetupHook,

     

       5
       6
        
         makeWrapper,

     

       6
       7
        
         nodejs,

     
···

       18
       19
        
           substitutions = {

     

       19
       20
        
             nodeSrc = srcOnly nodejs;

     

       20
       21
        
             nodeGyp = "${nodejs}/lib/node_modules/npm/node_modules/node-gyp/bin/node-gyp.js";

     

       22
       22
       +
             npmArch = stdenv.targetPlatform.node.arch;

     

       23
       23
       +
             npmPlatform = stdenv.targetPlatform.node.platform;

     

       21
       24
        
       

     

       22
       25
        
             # Specify `diff`, `jq`, and `prefetch-npm-deps` by abspath to ensure that the user's build

     

       23
       26
        
             # inputs do not cause us to find the wrong binaries.

+2

pkgs/build-support/node/build-npm-package/hooks/npm-config-hook.sh

···

       16
       16
        
           export HOME="$TMPDIR"

     

       17
       17
        
           export npm_config_nodedir="@nodeSrc@"

     

       18
       18
        
           export npm_config_node_gyp="@nodeGyp@"

     

       19
       19
       +
           export npm_config_arch="@npmArch@"

     

       20
       20
       +
           export npm_config_platform="@npmPlatform@"

     

       19
       21
        
       

     

       20
       22
        
           if [ -z "${npmDeps-}" ]; then

     

       21
       23
        
               echo

+2 -8

pkgs/by-name/af/affine-bin/package.nix

···

       13
       13
        
       }:

     

       14
       14
        
       let

     

       15
       15
        
         hostPlatform = stdenvNoCC.hostPlatform;

     

       16
       16
       -
         nodePlatform = hostPlatform.parsed.kernel.name; # nodejs's `process.platform`

     

       17
       17
       -
         nodeArch = # nodejs's `process.arch`

     

       18
       18
       -
           {

     

       19
       19
       -
             "x86_64" = "x64";

     

       20
       20
       -
             "aarch64" = "arm64";

     

       21
       21
       -
           }

     

       22
       22
       -
           .${hostPlatform.parsed.cpu.name}

     

       23
       23
       -
             or (throw "affine-bin(${buildType}): unsupported CPU family ${hostPlatform.parsed.cpu.name}");

     

       16
       16
       +
         nodePlatform = hostPlatform.node.platform;

     

       17
       17
       +
         nodeArch = hostPlatform.node.arch;

     

       24
       18
        
       in

     

       25
       19
        
       stdenvNoCC.mkDerivation (

     

       26
       20
        
         finalAttrs:

+2 -8

pkgs/by-name/af/affine/package.nix

···

       26
       26
        
       }:

     

       27
       27
        
       let

     

       28
       28
        
         hostPlatform = stdenvNoCC.hostPlatform;

     

       29
       29
       -
         nodePlatform = hostPlatform.parsed.kernel.name; # nodejs's `process.platform`

     

       30
       30
       -
         nodeArch = # nodejs's `process.arch`

     

       31
       31
       -
           {

     

       32
       32
       -
             "x86_64" = "x64";

     

       33
       33
       -
             "aarch64" = "arm64";

     

       34
       34
       -
           }

     

       35
       35
       -
           .${hostPlatform.parsed.cpu.name}

     

       36
       36
       -
             or (throw "affine(${buildType}): unsupported CPU family ${hostPlatform.parsed.cpu.name}");

     

       29
       29
       +
         nodePlatform = hostPlatform.node.platform;

     

       30
       30
       +
         nodeArch = hostPlatform.node.arch;

     

       37
       31
        
         electron = electron_35;

     

       38
       32
        
         nodejs = nodejs_22;

     

       39
       33
        
         yarn-berry = yarn-berry_4.override { inherit nodejs; };

+1 -10

pkgs/by-name/el/element-desktop/keytar/default.nix

···

       52
       52
        
           # Make sure the native modules are built against electron's ABI

     

       53
       53
        
           "--nodedir=${electron.headers}"

     

       54
       54
        
           # https://nodejs.org/api/os.html#osarch

     

       55
       55
       -
           "--arch=${

     

       56
       56
       -
             if stdenv.hostPlatform.parsed.cpu.name == "i686" then

     

       57
       57
       -
               "ia32"

     

       58
       58
       -
             else if stdenv.hostPlatform.parsed.cpu.name == "x86_64" then

     

       59
       59
       -
               "x64"

     

       60
       60
       -
             else if stdenv.hostPlatform.parsed.cpu.name == "aarch64" then

     

       61
       61
       -
               "arm64"

     

       62
       62
       -
             else

     

       63
       63
       -
               stdenv.hostPlatform.parsed.cpu.name

     

       64
       64
       -
           }"

     

       55
       55
       +
           "--arch=${stdenv.hostPlatform.node.arch}"

     

       65
       56
        
         ];

     

       66
       57
        
       

     

       67
       58
        
         installPhase = ''

+4

pkgs/development/tools/pnpm/fetch-deps/default.nix

···

       157
       157
        
         configHook = makeSetupHook {

     

       158
       158
        
           name = "pnpm-config-hook";

     

       159
       159
        
           propagatedBuildInputs = [ pnpm ];

     

       160
       160
       +
           substitutions = {

     

       161
       161
       +
             npmArch = stdenvNoCC.targetPlatform.node.arch;

     

       162
       162
       +
             npmPlatform = stdenvNoCC.targetPlatform.node.platform;

     

       163
       163
       +
           };

     

       160
       164
        
         } ./pnpm-config-hook.sh;

     

       161
       165
        
       }

+2

pkgs/development/tools/pnpm/fetch-deps/pnpm-config-hook.sh

···

       23
       23
        
       

     

       24
       24
        
           export HOME=$(mktemp -d)

     

       25
       25
        
           export STORE_PATH=$(mktemp -d)

     

       26
       26
       +
           export npm_config_arch="@npmArch@"

     

       27
       27
       +
           export npm_config_platform="@npmPlatform@"

     

       26
       28
        
       

     

       27
       29
        
           cp -Tr "$pnpmDeps" "$STORE_PATH"

     

       28
       30
        
           chmod -R +w "$STORE_PATH"

+1 -25

pkgs/development/web/nodejs/nodejs.nix

···

       70
       70
        
             "freebsd"

     

       71
       71
        
           else

     

       72
       72
        
             throw "unsupported os ${platform.uname.system}";

     

       73
       73
       -
         destCPU =

     

       74
       74
       -
           let

     

       75
       75
       -
             platform = stdenv.hostPlatform;

     

       76
       76
       -
           in

     

       77
       77
       -
           if platform.isAarch then

     

       78
       78
       -
             "arm" + lib.optionalString platform.is64bit "64"

     

       79
       79
       -
           else if platform.isMips32 then

     

       80
       80
       -
             "mips" + lib.optionalString platform.isLittleEndian "le"

     

       81
       81
       -
           else if platform.isMips64 && platform.isLittleEndian then

     

       82
       82
       -
             "mips64el"

     

       83
       83
       -
           else if platform.isPower then

     

       84
       84
       -
             "ppc" + lib.optionalString platform.is64bit "64"

     

       85
       85
       -
           else if platform.isx86_64 then

     

       86
       86
       -
             "x64"

     

       87
       87
       -
           else if platform.isx86_32 then

     

       88
       88
       -
             "ia32"

     

       89
       89
       -
           else if platform.isS390x then

     

       90
       90
       -
             "s390x"

     

       91
       91
       -
           else if platform.isRiscV64 then

     

       92
       92
       -
             "riscv64"

     

       93
       93
       -
           else if platform.isLoongArch64 then

     

       94
       94
       -
             "loong64"

     

       95
       95
       -
           else

     

       96
       96
       -
             throw "unsupported cpu ${platform.uname.processor}";

     

       97
       73
        
         destARMFPU =

     

       98
       74
        
           let

     

       99
       75
        
             platform = stdenv.hostPlatform;

     
···

       258
       234
        
                 # --cross-compiling flag enables use of CC_host et. al

     

       259
       235
        
                 (if canExecute || canEmulate then "--no-cross-compiling" else "--cross-compiling")

     

       260
       236
        
                 "--dest-os=${destOS}"

     

       261
       261
       -
                 "--dest-cpu=${destCPU}"

     

       237
       237
       +
                 "--dest-cpu=${stdenv.hostPlatform.node.arch}"

     

       262
       238
        
               ]

     

       263
       239
        
               ++ lib.optionals (destARMFPU != null) [ "--with-arm-fpu=${destARMFPU}" ]

     

       264
       240
        
               ++ lib.optionals (destARMFloatABI != null) [ "--with-arm-float-abi=${destARMFloatABI}" ]