From 1866ce4ea9ac40b22ce68b5200ae4c38cb52d9cf Mon Sep 17 00:00:00 2001 From: foosinn Date: Fri, 8 Oct 2021 00:33:24 +0200 Subject: [PATCH] tuxedo control center working (only 1.0.14) --- hardware/vison14.nix | 8 +- packages/tuxedo-cc.nix | 122 + packages/tuxedo-control-center/default.nix | 159 + .../node-composition.nix | 18 + packages/tuxedo-control-center/node-env.nix | 573 + .../tuxedo-control-center/node-packages.nix | 12215 ++++++++++++++++ 6 files changed, 13092 insertions(+), 3 deletions(-) create mode 100644 packages/tuxedo-cc.nix create mode 100644 packages/tuxedo-control-center/default.nix create mode 100644 packages/tuxedo-control-center/node-composition.nix create mode 100644 packages/tuxedo-control-center/node-env.nix create mode 100644 packages/tuxedo-control-center/node-packages.nix diff --git a/hardware/vison14.nix b/hardware/vison14.nix index d20e1f1..85ed6d9 100644 --- a/hardware/vison14.nix +++ b/hardware/vison14.nix @@ -5,9 +5,8 @@ let tuxedo-keyboard = pkgs.callPackage (import ../packages/tuxedo-keyboard.nix) {}; -in - -{ + tuxedo-cc = pkgs.callPackage (import ../packages/tuxedo-control-center/default.nix) {}; +in { imports = [ (modulesPath + "/installer/scan/not-detected.nix") ]; @@ -18,6 +17,9 @@ in boot.extraModulePackages = [ tuxedo-keyboard ]; + environment.systemPackages = with pkgs; [ + tuxedo-cc + ]; fileSystems."/" = { device = "tank/root/nixos"; diff --git a/packages/tuxedo-cc.nix b/packages/tuxedo-cc.nix new file mode 100644 index 0000000..a0c88ad --- /dev/null +++ b/packages/tuxedo-cc.nix @@ -0,0 +1,122 @@ +{ lib +, stdenv +, makeWrapper +, fetchurl +, rpmextract +, autoPatchelfHook +, alsa-lib +, cups +, gdk-pixbuf +, glib +, gtk3 +, libnotify +, libuuid +, libX11 +, libXScrnSaver +, libXcomposite +, libXcursor +, libXdamage +, libXext +, libXfixes +, libXi +, libXrandr +, libXrender +, libXtst +, libxcb +, libxshmfence +, mesa +, nspr +, nss +, pango +, systemd +, libappindicator-gtk3 +, libdbusmenu + +}: + +stdenv.mkDerivation rec { + pname = "tuxedo-control-center"; + version = "1.1.0"; + + src = fetchurl { + url = "https://rpm.tuxedocomputers.com/opensuse/15.2/x86_64/tuxedo-control-center_${version}.rpm"; + sha256 = "0rqhfi1slnh0kkn1vnxqynxm6yb4w1mhk4vi92vj0lrxlwdxf80c"; + }; + + + nativeBuildInputs = [ + rpmextract + makeWrapper + alsa-lib + autoPatchelfHook + cups + libXdamage + libX11 + libXScrnSaver + libXtst + libxshmfence + mesa + nss + libXrender + gdk-pixbuf + gtk3 + systemd + ]; + + libPath = lib.makeLibraryPath [ + alsa-lib + gdk-pixbuf + glib + gtk3 + libnotify + libX11 + libXcomposite + libuuid + libXcursor + libXdamage + libXext + libXfixes + libXi + libXrandr + libXrender + libXtst + nspr + nss + libxcb + pango + systemd + libXScrnSaver + libappindicator-gtk3 + libdbusmenu + ]; + + unpackPhase = '' + mkdir -p $out/bin + cd $out + rpmextract $src + ''; + + installPhase = '' + runHook preInstall + + #wrapProgram $out/opt/${pname}/${pname} \ + # --prefix LD_LIBRARY_PATH : ${libPath}:$out/opt/${pname} + + #wrapProgram $out/opt/${pname}/resources/dist/${pname}/data/service/tccd \ + # --prefix LD_LIBRARY_PATH : ${libPath}:$out/opt/${pname} + + ln -s $out/opt/${pname}/${pname} $out/bin/ + ln -s $out/opt/${pname}/resources/dist/${pname}/data/service/tccd $out/bin/ + find $out + + runHook postInstall + ''; + + + meta = with lib; { + description = "A tool to help you control performance, energy, fan and comfort settings on TUXEDO laptops."; + homepage = "github.com/tuxedocomputers/tuxedo-control-center"; + license = licenses.gpl3Only; + maintainers = with maintainers; [ ]; + }; +} diff --git a/packages/tuxedo-control-center/default.nix b/packages/tuxedo-control-center/default.nix new file mode 100644 index 0000000..ea7c0e3 --- /dev/null +++ b/packages/tuxedo-control-center/default.nix @@ -0,0 +1,159 @@ +{ pkgs, lib, stdenv, makeDesktopItem, desktop-file-utils, + + python, + + makeWrapper, nodejs, electron_9, fetchFromGitHub +}: + +let + baseName = "tuxedo-control-center"; + version = "1.0.14"; + + baseNodePackages = (import ./node-composition.nix { + inherit pkgs nodejs; + inherit (stdenv.hostPlatform) system; + }); + + nodePackages = baseNodePackages.package.override { + src = fetchFromGitHub { + owner = "tuxedocomputers"; + repo = "tuxedo-control-center"; + rev = "v${version}"; + sha256 = "00gpsvjbli9f6vj31lbs7flmcz215r91iz6rg1kbzklc3y5k2ifj"; + }; + + # Electron tries to download itself if this isn't set. We don't + # like that in nix so let's prevent it. + # + # This means we have to provide our own electron binaries when + # wrapping this program. + ELECTRON_SKIP_BINARY_DOWNLOAD=1; + + # Angular prompts for analytics, which in turn fails the build. + # + # We can disable analytics using false or empty string + # (See https://github.com/angular/angular-cli/blob/1a39c5202a6fe159f8d7db85a1c186176240e437/packages/angular/cli/models/analytics.ts#L506) + NG_CLI_ANALYTICS="false"; + }; + + desktopItem = makeDesktopItem { + name = "tuxedo-control-center"; + exec = "tuxedo-control-center %U"; + comment = "An application helping you to tune your TUXEDO"; + desktopName = "TUXEDO Control Center"; + icon = "tuxedo-control-center"; + categories = "System;"; + }; +in + +stdenv.mkDerivation rec { + name = "${baseName}-${version}"; + src = "${nodePackages}/lib/node_modules/tuxedo-control-center/"; + + nativeBuildInputs = [ + desktop-file-utils # for desktop-file-validate + ]; + + buildInputs = [ + nodejs + makeWrapper + + # For node-gyp + python + ]; + + # TCC by default writes its config to /etc/tcc, which is + # inconvenient. Change this to a more standard location. + # + # It also hardcodes binary path. + postPatch = '' + substituteInPlace src/common/classes/TccPaths.ts \ + --replace "/etc/tcc" "/var/lib/tcc" \ + --replace "/opt/tuxedo-control-center/resources/dist/tuxedo-control-center/data/service/tccd" "$out/bin/tccd" + ''; + + buildPhase = '' + set -x + # We already have `node_modules` in the current directory but we + # need it's binaries on `PATH` so we can use them! + export PATH="./node_modules/.bin:$PATH" + + # Prevent npm from checking for updates + export NO_UPDATE_NOTIFIER=true + + # The order of `npm` commands matches what `npm run build-prod` does but we split + # it out so we can customise the native builds in `npm run build-service`. + npm run clean + npm run build-electron + + # We don't use `npm run build-service` here because it uses `pkg` which packages + # node binaries in a way unsuitable for nix. Instead we're doing it ourself. + tsc -p ./src/service-app + cp ./src/package.json ./dist/tuxedo-control-center/service-app/package.json + + # We need to tell npm where to find node or `node-gyp` will try to download it. + # This also _needs_ to be lowercase or `npm` won't detect it + export npm_config_nodedir=${nodejs} + npm run build-native # Builds to ./build/Release/TuxedoIOAPI.node + + npm run build-ng-prod + ''; + + installPhase = '' + mkdir -p $out + cp -R ./dist/tuxedo-control-center/* $out + + ln -s $src/node_modules $out/node_modules + + # Parts of the code expect the icons to live under `data/dist-data`. Let's just + # copy the whole thing since the system assumes it has access to all the `dist-data` + # files. + mkdir -p $out/data/dist-data + cp -R ./src/dist-data/* $out/data/dist-data/ + + # Install `tccd` + mkdir -p $out/data/service + cp ./build/Release/TuxedoIOAPI.node $out/data/service/TuxedoIOAPI.node + makeWrapper ${nodejs}/bin/node $out/data/service/tccd \ + --add-flags "$out/service-app/service-app/main.js" \ + --prefix NODE_PATH : $out/data/service \ + --prefix NODE_PATH : $out/node_modules + mkdir -p $out/bin + ln -s $out/data/service/tccd $out/bin/tccd + + # Install `tuxedo-control-center` + # + # We use `--no-tccd-version-check` because the app uses the electron context + # to determine the app version, but the electron context is wrong if electron + # is invoked directly on a JavaScript file. + # + # The fix is to run electron on a folder with a `package.json` but the `tuxedo-control-center` + # package.json expects all files to live under `dist/` and I'm not a huge fan of that + # structure so we just disable the check and call it a day. + makeWrapper ${electron_9}/bin/electron $out/bin/tuxedo-control-center \ + --add-flags "$out/e-app/e-app/main.js" \ + --add-flags "--no-tccd-version-check" \ + --prefix NODE_PATH : $out/node_modules + + mkdir -p $out/share/polkit-1/actions/ + cp $out/data/dist-data/de.tuxedocomputers.tcc.policy $out/share/polkit-1/actions/de.tuxedocomputers.tcc.policy + + mkdir -p $out/etc/dbus-1/system.d/ + cp $out/data/dist-data/com.tuxedocomputers.tccd.conf $out/etc/dbus-1/system.d/com.tuxedocomputers.tccd.conf + + # Put our icons in the right spot + mkdir -p $out/share/icons/hicolor/scalable/apps/ + cp $out/data/dist-data/tuxedo-control-center_256.svg \ + $out/share/icons/hicolor/scalable/apps/tuxedo-control-center.svg + + ${desktopItem.buildCommand} + ''; + + meta = with lib; { + description = "Fan and power management GUI for Tuxedo laptops"; + homepage = "https://github.com/tuxedocomputers/tuxedo-control-center/"; + license = licenses.gpl3Plus; + maintainers = [ maintainers.blitz ]; + platforms = [ "x86_64-linux" ]; + }; +} diff --git a/packages/tuxedo-control-center/node-composition.nix b/packages/tuxedo-control-center/node-composition.nix new file mode 100644 index 0000000..7cd99e8 --- /dev/null +++ b/packages/tuxedo-control-center/node-composition.nix @@ -0,0 +1,18 @@ +# This file has been generated by node2nix 1.9.0. Do not edit! + +{pkgs ? import { + inherit system; + }, system ? builtins.currentSystem, nodejs ? pkgs."nodejs-14_x"}: + +let + nodeEnv = import ./node-env.nix { + inherit (pkgs) stdenv lib python2 runCommand writeTextFile; + inherit pkgs nodejs; + libtool = if pkgs.stdenv.isDarwin then pkgs.darwin.cctools else null; + }; +in +import ./node-packages.nix { + inherit (pkgs) fetchurl nix-gitignore stdenv lib fetchgit; + inherit nodeEnv; +} + diff --git a/packages/tuxedo-control-center/node-env.nix b/packages/tuxedo-control-center/node-env.nix new file mode 100644 index 0000000..21089c4 --- /dev/null +++ b/packages/tuxedo-control-center/node-env.nix @@ -0,0 +1,573 @@ +# This file originates from node2nix + +{lib, stdenv, nodejs, python2, pkgs, libtool, runCommand, writeTextFile}: + +let + # Workaround to cope with utillinux in Nixpkgs 20.09 and util-linux in Nixpkgs master + utillinux = if pkgs ? utillinux then pkgs.utillinux else pkgs.util-linux; + + python = if nodejs ? python then nodejs.python else python2; + + # Create a tar wrapper that filters all the 'Ignoring unknown extended header keyword' noise + tarWrapper = runCommand "tarWrapper" {} '' + mkdir -p $out/bin + + cat > $out/bin/tar <> $out/nix-support/hydra-build-products + ''; + }; + + includeDependencies = {dependencies}: + lib.optionalString (dependencies != []) + (lib.concatMapStrings (dependency: + '' + # Bundle the dependencies of the package + mkdir -p node_modules + cd node_modules + + # Only include dependencies if they don't exist. They may also be bundled in the package. + if [ ! -e "${dependency.name}" ] + then + ${composePackage dependency} + fi + + cd .. + '' + ) dependencies); + + # Recursively composes the dependencies of a package + composePackage = { name, packageName, src, dependencies ? [], ... }@args: + builtins.addErrorContext "while evaluating node package '${packageName}'" '' + DIR=$(pwd) + cd $TMPDIR + + unpackFile ${src} + + # Make the base dir in which the target dependency resides first + mkdir -p "$(dirname "$DIR/${packageName}")" + + if [ -f "${src}" ] + then + # Figure out what directory has been unpacked + packageDir="$(find . -maxdepth 1 -type d | tail -1)" + + # Restore write permissions to make building work + find "$packageDir" -type d -exec chmod u+x {} \; + chmod -R u+w "$packageDir" + + # Move the extracted tarball into the output folder + mv "$packageDir" "$DIR/${packageName}" + elif [ -d "${src}" ] + then + # Get a stripped name (without hash) of the source directory. + # On old nixpkgs it's already set internally. + if [ -z "$strippedName" ] + then + strippedName="$(stripHash ${src})" + fi + + # Restore write permissions to make building work + chmod -R u+w "$strippedName" + + # Move the extracted directory into the output folder + mv "$strippedName" "$DIR/${packageName}" + fi + + # Unset the stripped name to not confuse the next unpack step + unset strippedName + + # Include the dependencies of the package + cd "$DIR/${packageName}" + ${includeDependencies { inherit dependencies; }} + cd .. + ${lib.optionalString (builtins.substring 0 1 packageName == "@") "cd .."} + ''; + + pinpointDependencies = {dependencies, production}: + let + pinpointDependenciesFromPackageJSON = writeTextFile { + name = "pinpointDependencies.js"; + text = '' + var fs = require('fs'); + var path = require('path'); + + function resolveDependencyVersion(location, name) { + if(location == process.env['NIX_STORE']) { + return null; + } else { + var dependencyPackageJSON = path.join(location, "node_modules", name, "package.json"); + + if(fs.existsSync(dependencyPackageJSON)) { + var dependencyPackageObj = JSON.parse(fs.readFileSync(dependencyPackageJSON)); + + if(dependencyPackageObj.name == name) { + return dependencyPackageObj.version; + } + } else { + return resolveDependencyVersion(path.resolve(location, ".."), name); + } + } + } + + function replaceDependencies(dependencies) { + if(typeof dependencies == "object" && dependencies !== null) { + for(var dependency in dependencies) { + var resolvedVersion = resolveDependencyVersion(process.cwd(), dependency); + + if(resolvedVersion === null) { + process.stderr.write("WARNING: cannot pinpoint dependency: "+dependency+", context: "+process.cwd()+"\n"); + } else { + dependencies[dependency] = resolvedVersion; + } + } + } + } + + /* Read the package.json configuration */ + var packageObj = JSON.parse(fs.readFileSync('./package.json')); + + /* Pinpoint all dependencies */ + replaceDependencies(packageObj.dependencies); + if(process.argv[2] == "development") { + replaceDependencies(packageObj.devDependencies); + } + replaceDependencies(packageObj.optionalDependencies); + + /* Write the fixed package.json file */ + fs.writeFileSync("package.json", JSON.stringify(packageObj, null, 2)); + ''; + }; + in + '' + node ${pinpointDependenciesFromPackageJSON} ${if production then "production" else "development"} + + ${lib.optionalString (dependencies != []) + '' + if [ -d node_modules ] + then + cd node_modules + ${lib.concatMapStrings (dependency: pinpointDependenciesOfPackage dependency) dependencies} + cd .. + fi + ''} + ''; + + # Recursively traverses all dependencies of a package and pinpoints all + # dependencies in the package.json file to the versions that are actually + # being used. + + pinpointDependenciesOfPackage = { packageName, dependencies ? [], production ? true, ... }@args: + '' + if [ -d "${packageName}" ] + then + cd "${packageName}" + ${pinpointDependencies { inherit dependencies production; }} + cd .. + ${lib.optionalString (builtins.substring 0 1 packageName == "@") "cd .."} + fi + ''; + + # Extract the Node.js source code which is used to compile packages with + # native bindings + nodeSources = runCommand "node-sources" {} '' + tar --no-same-owner --no-same-permissions -xf ${nodejs.src} + mv node-* $out + ''; + + # Script that adds _integrity fields to all package.json files to prevent NPM from consulting the cache (that is empty) + addIntegrityFieldsScript = writeTextFile { + name = "addintegrityfields.js"; + text = '' + var fs = require('fs'); + var path = require('path'); + + function augmentDependencies(baseDir, dependencies) { + for(var dependencyName in dependencies) { + var dependency = dependencies[dependencyName]; + + // Open package.json and augment metadata fields + var packageJSONDir = path.join(baseDir, "node_modules", dependencyName); + var packageJSONPath = path.join(packageJSONDir, "package.json"); + + if(fs.existsSync(packageJSONPath)) { // Only augment packages that exist. Sometimes we may have production installs in which development dependencies can be ignored + console.log("Adding metadata fields to: "+packageJSONPath); + var packageObj = JSON.parse(fs.readFileSync(packageJSONPath)); + + if(dependency.integrity) { + packageObj["_integrity"] = dependency.integrity; + } else { + packageObj["_integrity"] = "sha1-000000000000000000000000000="; // When no _integrity string has been provided (e.g. by Git dependencies), add a dummy one. It does not seem to harm and it bypasses downloads. + } + + if(dependency.resolved) { + packageObj["_resolved"] = dependency.resolved; // Adopt the resolved property if one has been provided + } else { + packageObj["_resolved"] = dependency.version; // Set the resolved version to the version identifier. This prevents NPM from cloning Git repositories. + } + + if(dependency.from !== undefined) { // Adopt from property if one has been provided + packageObj["_from"] = dependency.from; + } + + fs.writeFileSync(packageJSONPath, JSON.stringify(packageObj, null, 2)); + } + + // Augment transitive dependencies + if(dependency.dependencies !== undefined) { + augmentDependencies(packageJSONDir, dependency.dependencies); + } + } + } + + if(fs.existsSync("./package-lock.json")) { + var packageLock = JSON.parse(fs.readFileSync("./package-lock.json")); + + if(![1, 2].includes(packageLock.lockfileVersion)) { + process.stderr.write("Sorry, I only understand lock file versions 1 and 2!\n"); + process.exit(1); + } + + if(packageLock.dependencies !== undefined) { + augmentDependencies(".", packageLock.dependencies); + } + } + ''; + }; + + # Reconstructs a package-lock file from the node_modules/ folder structure and package.json files with dummy sha1 hashes + reconstructPackageLock = writeTextFile { + name = "addintegrityfields.js"; + text = '' + var fs = require('fs'); + var path = require('path'); + + var packageObj = JSON.parse(fs.readFileSync("package.json")); + + var lockObj = { + name: packageObj.name, + version: packageObj.version, + lockfileVersion: 1, + requires: true, + dependencies: {} + }; + + function augmentPackageJSON(filePath, dependencies) { + var packageJSON = path.join(filePath, "package.json"); + if(fs.existsSync(packageJSON)) { + var packageObj = JSON.parse(fs.readFileSync(packageJSON)); + dependencies[packageObj.name] = { + version: packageObj.version, + integrity: "sha1-000000000000000000000000000=", + dependencies: {} + }; + processDependencies(path.join(filePath, "node_modules"), dependencies[packageObj.name].dependencies); + } + } + + function processDependencies(dir, dependencies) { + if(fs.existsSync(dir)) { + var files = fs.readdirSync(dir); + + files.forEach(function(entry) { + var filePath = path.join(dir, entry); + var stats = fs.statSync(filePath); + + if(stats.isDirectory()) { + if(entry.substr(0, 1) == "@") { + // When we encounter a namespace folder, augment all packages belonging to the scope + var pkgFiles = fs.readdirSync(filePath); + + pkgFiles.forEach(function(entry) { + if(stats.isDirectory()) { + var pkgFilePath = path.join(filePath, entry); + augmentPackageJSON(pkgFilePath, dependencies); + } + }); + } else { + augmentPackageJSON(filePath, dependencies); + } + } + }); + } + } + + processDependencies("node_modules", lockObj.dependencies); + + fs.writeFileSync("package-lock.json", JSON.stringify(lockObj, null, 2)); + ''; + }; + + prepareAndInvokeNPM = {packageName, bypassCache, reconstructLock, npmFlags, production}: + let + forceOfflineFlag = if bypassCache then "--offline" else "--registry http://www.example.com"; + in + '' + # Pinpoint the versions of all dependencies to the ones that are actually being used + echo "pinpointing versions of dependencies..." + source $pinpointDependenciesScriptPath + + # Patch the shebangs of the bundled modules to prevent them from + # calling executables outside the Nix store as much as possible + patchShebangs . + + # Deploy the Node.js package by running npm install. Since the + # dependencies have been provided already by ourselves, it should not + # attempt to install them again, which is good, because we want to make + # it Nix's responsibility. If it needs to install any dependencies + # anyway (e.g. because the dependency parameters are + # incomplete/incorrect), it fails. + # + # The other responsibilities of NPM are kept -- version checks, build + # steps, postprocessing etc. + + export HOME=$TMPDIR + cd "${packageName}" + runHook preRebuild + + ${lib.optionalString bypassCache '' + ${lib.optionalString reconstructLock '' + if [ -f package-lock.json ] + then + echo "WARNING: Reconstruct lock option enabled, but a lock file already exists!" + echo "This will most likely result in version mismatches! We will remove the lock file and regenerate it!" + rm package-lock.json + else + echo "No package-lock.json file found, reconstructing..." + fi + + node ${reconstructPackageLock} + ''} + + node ${addIntegrityFieldsScript} + ''} + + npm ${forceOfflineFlag} --nodedir=${nodeSources} ${npmFlags} ${lib.optionalString production "--production"} rebuild + + if [ "''${dontNpmInstall-}" != "1" ] + then + # NPM tries to download packages even when they already exist if npm-shrinkwrap is used. + rm -f npm-shrinkwrap.json + + npm ${forceOfflineFlag} --nodedir=${nodeSources} ${npmFlags} ${lib.optionalString production "--production"} install + fi + ''; + + # Builds and composes an NPM package including all its dependencies + buildNodePackage = + { name + , packageName + , version + , dependencies ? [] + , buildInputs ? [] + , production ? true + , npmFlags ? "" + , dontNpmInstall ? false + , bypassCache ? false + , reconstructLock ? false + , preRebuild ? "" + , dontStrip ? true + , unpackPhase ? "true" + , buildPhase ? "true" + , meta ? {} + , ... }@args: + + let + extraArgs = removeAttrs args [ "name" "dependencies" "buildInputs" "dontStrip" "dontNpmInstall" "preRebuild" "unpackPhase" "buildPhase" "meta" ]; + in + stdenv.mkDerivation ({ + name = "${name}-${version}"; + buildInputs = [ tarWrapper python nodejs ] + ++ lib.optional (stdenv.isLinux) utillinux + ++ lib.optional (stdenv.isDarwin) libtool + ++ buildInputs; + + inherit nodejs; + + inherit dontStrip; # Stripping may fail a build for some package deployments + inherit dontNpmInstall preRebuild unpackPhase buildPhase; + + compositionScript = composePackage args; + pinpointDependenciesScript = pinpointDependenciesOfPackage args; + + passAsFile = [ "compositionScript" "pinpointDependenciesScript" ]; + + installPhase = '' + # Create and enter a root node_modules/ folder + mkdir -p $out/lib/node_modules + cd $out/lib/node_modules + + # Compose the package and all its dependencies + source $compositionScriptPath + + ${prepareAndInvokeNPM { inherit packageName bypassCache reconstructLock npmFlags production; }} + + # Create symlink to the deployed executable folder, if applicable + if [ -d "$out/lib/node_modules/.bin" ] + then + ln -s $out/lib/node_modules/.bin $out/bin + fi + + # Create symlinks to the deployed manual page folders, if applicable + if [ -d "$out/lib/node_modules/${packageName}/man" ] + then + mkdir -p $out/share + for dir in "$out/lib/node_modules/${packageName}/man/"* + do + mkdir -p $out/share/man/$(basename "$dir") + for page in "$dir"/* + do + ln -s $page $out/share/man/$(basename "$dir") + done + done + fi + + # Run post install hook, if provided + runHook postInstall + ''; + + meta = { + # default to Node.js' platforms + platforms = nodejs.meta.platforms; + } // meta; + } // extraArgs); + + # Builds a node environment (a node_modules folder and a set of binaries) + buildNodeDependencies = + { name + , packageName + , version + , src + , dependencies ? [] + , buildInputs ? [] + , production ? true + , npmFlags ? "" + , dontNpmInstall ? false + , bypassCache ? false + , reconstructLock ? false + , dontStrip ? true + , unpackPhase ? "true" + , buildPhase ? "true" + , ... }@args: + + let + extraArgs = removeAttrs args [ "name" "dependencies" "buildInputs" ]; + in + stdenv.mkDerivation ({ + name = "node-dependencies-${name}-${version}"; + + buildInputs = [ tarWrapper python nodejs ] + ++ lib.optional (stdenv.isLinux) utillinux + ++ lib.optional (stdenv.isDarwin) libtool + ++ buildInputs; + + inherit dontStrip; # Stripping may fail a build for some package deployments + inherit dontNpmInstall unpackPhase buildPhase; + + includeScript = includeDependencies { inherit dependencies; }; + pinpointDependenciesScript = pinpointDependenciesOfPackage args; + + passAsFile = [ "includeScript" "pinpointDependenciesScript" ]; + + installPhase = '' + mkdir -p $out/${packageName} + cd $out/${packageName} + + source $includeScriptPath + + # Create fake package.json to make the npm commands work properly + cp ${src}/package.json . + chmod 644 package.json + ${lib.optionalString bypassCache '' + if [ -f ${src}/package-lock.json ] + then + cp ${src}/package-lock.json . + fi + ''} + + # Go to the parent folder to make sure that all packages are pinpointed + cd .. + ${lib.optionalString (builtins.substring 0 1 packageName == "@") "cd .."} + + ${prepareAndInvokeNPM { inherit packageName bypassCache reconstructLock npmFlags production; }} + + # Expose the executables that were installed + cd .. + ${lib.optionalString (builtins.substring 0 1 packageName == "@") "cd .."} + + mv ${packageName} lib + ln -s $out/lib/node_modules/.bin $out/bin + ''; + } // extraArgs); + + # Builds a development shell + buildNodeShell = + { name + , packageName + , version + , src + , dependencies ? [] + , buildInputs ? [] + , production ? true + , npmFlags ? "" + , dontNpmInstall ? false + , bypassCache ? false + , reconstructLock ? false + , dontStrip ? true + , unpackPhase ? "true" + , buildPhase ? "true" + , ... }@args: + + let + nodeDependencies = buildNodeDependencies args; + in + stdenv.mkDerivation { + name = "node-shell-${name}-${version}"; + + buildInputs = [ python nodejs ] ++ lib.optional (stdenv.isLinux) utillinux ++ buildInputs; + buildCommand = '' + mkdir -p $out/bin + cat > $out/bin/shell <