@ifunny/ifunny-api-types 1.0.4 → 1.2.0

package/.devenv/bootstrap/resolve-lock.nix

@@ -0,0 +1,190 @@
+# Adapted from https://git.lix.systems/lix-project/flake-compat/src/branch/main/default.nix
+{
+  src,
+  lockFilePath,
+  system ? builtins.currentSystem or "unknown-system",
+}:
+
+let
+  lockFile = builtins.fromJSON (builtins.readFile lockFilePath);
+
+  rootSrc = {
+    lastModified = 0;
+    lastModifiedDate = formatSecondsSinceEpoch 0;
+    # *hacker voice*: it's definitely a store path, I promise (actually a
+    # nixlang path value, likely not pointing at the store).
+    outPath = src;
+  };
+
+  # Format number of seconds in the Unix epoch as %Y%m%d%H%M%S.
+  formatSecondsSinceEpoch =
+    t:
+    let
+      rem = x: y: x - x / y * y;
+      days = t / 86400;
+      secondsInDay = rem t 86400;
+      hours = secondsInDay / 3600;
+      minutes = (rem secondsInDay 3600) / 60;
+      seconds = rem t 60;
+
+      # Courtesy of https://stackoverflow.com/a/32158604.
+      z = days + 719468;
+      era = (if z >= 0 then z else z - 146096) / 146097;
+      doe = z - era * 146097;
+      yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
+      y = yoe + era * 400;
+      doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+      mp = (5 * doy + 2) / 153;
+      d = doy - (153 * mp + 2) / 5 + 1;
+      m = mp + (if mp < 10 then 3 else -9);
+      y' = y + (if m <= 2 then 1 else 0);
+
+      pad = s: if builtins.stringLength s < 2 then "0" + s else s;
+    in
+    "${toString y'}${pad (toString m)}${pad (toString d)}${pad (toString hours)}${pad (toString minutes)}${pad (toString seconds)}";
+
+  allNodes = builtins.mapAttrs (
+    key: node:
+    let
+      sourceInfo =
+        if key == lockFile.root then
+          rootSrc
+        # Path inputs pointing to project root (path = ".") should use rootSrc
+        # to avoid fetchTree hashing the entire project directory
+        else if node.locked.type or null == "path" && node.locked.path or null == "." then
+          rootSrc
+        else
+          let
+            locked = node.locked;
+            isRelativePath =
+              p: p != null && (builtins.substring 0 2 p == "./" || builtins.substring 0 3 p == "../");
+            # Resolve relative paths against src
+            resolvedLocked =
+              locked
+              // (
+                if locked.type or null == "path" && isRelativePath (locked.path or null) then
+                  { path = toString src + "/${locked.path}"; }
+                else
+                  { }
+              )
+              // (
+                if locked.type or null == "git" && isRelativePath (locked.url or null) then
+                  { url = toString src + "/${locked.url}"; }
+                else
+                  { }
+              );
+
+            # Local path inputs without a pinned narHash resolve to the live
+            # filesystem path instead of a fetchTree store copy. The lock file
+            # never carries a narHash for them (Nix strips volatile attributes
+            # from local inputs), so a store copy would hide edits from the
+            # eval cache: nothing in the cache key changes when the directory
+            # content changes. Evaluating from the live path makes the eval
+            # cache track every file that is read, so edits invalidate it.
+            isLivePath =
+              locked.type or null == "path"
+              && !(locked ? narHash)
+              && builtins.substring 0 1 (resolvedLocked.path or "") == "/";
+
+            fetchedSource = builtins.fetchTree (node.info or { } // removeAttrs resolvedLocked [ "dir" ]);
+          in
+          if isLivePath then
+            {
+              # Keep fetchTree's public metadata available to flakes that use
+              # self.narHash or self.lastModified. These inherited values stay
+              # lazy, so the live input is only hashed if metadata is read.
+              inherit (fetchedSource) lastModified lastModifiedDate narHash;
+              outPath = /. + resolvedLocked.path;
+            }
+          else
+            fetchedSource;
+
+      subdir = if key == lockFile.root then "" else node.locked.dir or "";
+
+      # Concatenate on sourceInfo.outPath directly (not the attrset, whose
+      # string coercion would turn live path values into context-free
+      # strings) so live path inputs keep a path-typed outPath. Path values
+      # copy to the store on string interpolation, which keeps derivation
+      # references to input files working.
+      outPath = sourceInfo.outPath + ((if subdir == "" then "" else "/") + subdir);
+
+      # Resolve a input spec into a node name. An input spec is
+      # either a node name, or a 'follows' path from the root
+      # node.
+      resolveInput =
+        inputSpec: if builtins.isList inputSpec then getInputByPath lockFile.root inputSpec else inputSpec;
+
+      # Follow an input path (e.g. ["dwarffs" "nixpkgs"]) from the
+      # root node, returning the final node.
+      getInputByPath =
+        nodeName: path:
+        if path == [ ] then
+          nodeName
+        else
+          getInputByPath
+            # Since this could be a 'follows' input, call resolveInput.
+            (resolveInput lockFile.nodes.${nodeName}.inputs.${builtins.head path})
+            (builtins.tail path);
+
+      inputs = builtins.mapAttrs (inputName: inputSpec: allNodes.${resolveInput inputSpec}) (
+        node.inputs or { }
+      );
+
+      # Only import flake.nix for non-root nodes (root doesn't need it)
+      flake = if key == lockFile.root then null else import (outPath + "/flake.nix");
+
+      outputs = if key == lockFile.root then { } else flake.outputs (inputs // { self = result; });
+
+      # Lazy devenv evaluation for this input
+      devenvEval =
+        let
+          bootstrapLib = import ./bootstrapLib.nix { inputs = inputs; };
+        in
+        bootstrapLib.mkDevenvForInput {
+          input = { inherit outPath sourceInfo; };
+          allInputs = inputs;
+          inherit system;
+        };
+
+      result =
+        outputs
+        // sourceInfo
+        // {
+          inherit outPath;
+          inherit inputs;
+          inherit outputs;
+          inherit sourceInfo;
+          _type = "flake";
+          devenv = devenvEval;
+        };
+
+      nonFlakeResult = sourceInfo // {
+        inherit outPath;
+        inherit inputs;
+        inherit sourceInfo;
+        _type = "flake";
+        devenv = devenvEval;
+      };
+
+    in
+    if node.flake or true && key != lockFile.root then
+      assert builtins.isFunction flake.outputs;
+      result
+    else
+      nonFlakeResult
+  ) lockFile.nodes;
+
+  result =
+    if !(builtins.pathExists lockFilePath) then
+      throw "${lockFilePath} does not exist"
+    else if lockFile.version >= 5 && lockFile.version <= 7 then
+      allNodes.${lockFile.root}
+    else
+      throw "lock file '${lockFilePath}' has unsupported version ${toString lockFile.version}";
+
+in
+{
+  inputs = result.inputs or { } // {
+    self = result;
+  };
+}

package/.devenv/changelog-cache.json

@@ -0,0 +1,9 @@
+{
+  "shown_hashes": [
+    "053d92e6228a113aaf85e8f544485eb3f64cc8b4ed6ec52abf21847cbc637b53",
+    "97c8d967408d5e8dbaefb984ff368930aa96af9c3655e6d867154992052f5881",
+    "c40a016aca4dd81dcdca91ff004d81492328aa4b5c49912d6b83a945c2feff84",
+    "e6825d4a5422d776d0eb3054f874bf73d8e32e9259f2d7be3a633cbce6bccdcd",
+    "5a589290b7df7d37070a19af3adb407d66ebcfeaa9cd6b628ea0c1998d7a6cde"
+  ]
+}

package/.devenv/devenv.fish

@@ -0,0 +1,252 @@
+# devenv fish init
+
+# If this shell was spawned by the devenv hook (marked by `_DEVENV_HOOK_DIR`),
+# `exit` when the user `cd`s outside the project so the parent shell can
+# follow. Handled here (devenv's own init file, not the user's hook.fish) so
+# it works regardless of whether the user's config.fish re-sources the hook
+# for this non-login shell. Erase the marker as soon as it is read so it
+# cannot leak into further descendants (a new tmux/zellij pane, a
+# manually started nested shell, ...) which would otherwise wrongly conclude
+# they too are hook-spawned.
+if set -q _DEVENV_HOOK_DIR
+    set -e _DEVENV_HOOK_DIR
+    function _devenv_shell_exit_on_cd_out --on-variable PWD
+        switch $PWD
+            case "$DEVENV_ROOT" "$DEVENV_ROOT/*"
+            case '*'
+                printf '%s' $PWD > "$DEVENV_ROOT/.devenv/exit-dir"
+                exit
+        end
+    end
+end
+
+# Restore devenv PATH after user config may have modified it.
+# _DEVENV_PATH is a colon-separated string from bash; split into fish list.
+set -gx PATH (string split ":" -- $_DEVENV_PATH)
+
+# Wrap fish_prompt for devenv reload hooks and prompt prefix.
+if functions -q fish_prompt
+    functions -c fish_prompt __devenv_user_fish_prompt
+    function fish_prompt
+        __devenv_user_fish_prompt
+        __devenv_reload_apply
+        __devenv_restore_path
+    end
+else
+    function fish_prompt
+        __devenv_reload_apply
+        __devenv_restore_path
+        echo -n "(devenv) > "
+    end
+end
+
+# Hot-reload hook
+
+function __devenv_reload_apply
+    # Source new environment if a reload is pending
+    if test -f "/tmp/devenv-reload-528741.sh"
+        # Shell out to bash to handle the env diff (bash syntax).
+        # The bash subprocess inherits our current environment, reverses
+        # the previous diff, sources the new devenv env, computes a new
+        # diff, and outputs the resulting environment via export -p.
+        set -l reload_output (bash -c '
+            
+# Environment diff helpers (inspired by direnv)
+# Diff is stored in _DEVENV_DIFF env var (not a file) so each shell has its own state
+# Uses gzip+base64 encoding for compact storage
+
+# Variables to ignore in diff (shell internals that change dynamically)
+__devenv_ignored_var() {
+    case "$1" in
+        _*|PWD|OLDPWD|SHLVL|SHELL|SHELLOPTS|BASHOPTS|BASH_*|HISTCMD|HISTFILE)
+            return 0 ;;
+        PS1|PS2|PS3|PS4|PROMPT|PROMPT_COMMAND|PROMPT_DIRTRIM)
+            return 0 ;;
+        COMP_*|READLINE_*|MAILCHECK|COLUMNS|LINES|RANDOM|SECONDS|LINENO|EPOCHSECONDS|EPOCHREALTIME|SRANDOM)
+            return 0 ;;
+        STARSHIP_*|__fish*|DIRENV_*|nix_saved_*)
+            return 0 ;;
+        *)
+            return 1 ;;
+    esac
+}
+
+__devenv_capture_env() {
+    # Capture exported variables using declare -p for proper escaping
+    declare -p -x 2>/dev/null | LC_ALL=C sort
+}
+
+__devenv_serialize_diff() {
+    # Serialize diff (stdin) to base64-encoded gzip
+    gzip -c | base64 -w0
+}
+
+__devenv_deserialize_diff() {
+    # Deserialize diff from base64-encoded gzip to stdout
+    echo "$1" | base64 -d | gzip -d 2>/dev/null
+}
+
+__devenv_compute_diff() {
+    # Compare before ($1) and current env, return diff via _DEVENV_DIFF env var
+    local before_file="$1"
+
+    # Create temp files
+    local after_file diff_content
+    after_file=$(mktemp)
+    diff_content=$(mktemp)
+    __devenv_capture_env > "$after_file"
+
+    # Build associative arrays for before/after
+    local -A before_vars after_vars
+    while IFS= read -r line; do
+        [[ "$line" != declare\ -x\ * ]] && continue
+        local vardef="${line#declare -x }"
+        local var="${vardef%%=*}"
+        [[ -z "$var" ]] && continue
+        __devenv_ignored_var "$var" && continue
+        before_vars["$var"]="$line"
+    done < "$before_file"
+
+    while IFS= read -r line; do
+        [[ "$line" != declare\ -x\ * ]] && continue
+        local vardef="${line#declare -x }"
+        local var="${vardef%%=*}"
+        [[ -z "$var" ]] && continue
+        __devenv_ignored_var "$var" && continue
+        after_vars["$var"]="$line"
+    done < "$after_file"
+
+    # Find PREV entries (vars that were modified or removed)
+    for var in "${!before_vars[@]}"; do
+        if [[ "${after_vars[$var]}" != "${before_vars[$var]}" ]]; then
+            echo "P:${before_vars[$var]}" >> "$diff_content"
+        fi
+    done
+
+    # Find NEXT entries (vars that were added or modified)
+    for var in "${!after_vars[@]}"; do
+        if [[ -z "${before_vars[$var]+x}" ]]; then
+            echo "N:$var" >> "$diff_content"
+        elif [[ "${after_vars[$var]}" != "${before_vars[$var]}" ]]; then
+            echo "N:$var" >> "$diff_content"
+        fi
+    done
+
+    # Serialize and store in env var
+    _DEVENV_DIFF=$(__devenv_serialize_diff < "$diff_content")
+    export _DEVENV_DIFF
+
+    rm -f "$after_file" "$diff_content"
+}
+
+__devenv_apply_reverse_diff() {
+    # Reverse the diff: restore PREV values, unset NEXT-only vars
+    [[ -z "$_DEVENV_DIFF" ]] && return
+
+    local -A prev_vars
+    local diff_content
+    diff_content=$(__devenv_deserialize_diff "$_DEVENV_DIFF")
+
+    # First pass: collect and restore PREV declarations
+    while IFS= read -r line; do
+        if [[ "$line" == P:declare\ * ]]; then
+            local decl="${line#P:}"
+            local var="${decl#declare -x }"
+            var="${var%%=*}"
+            prev_vars["$var"]=1
+            # Use export instead of evaluating the declare statement directly,
+            # because declare -x inside a function creates a local variable
+            # in bash 5.0+.
+            eval "export ${decl#declare -x }" 2>/dev/null
+        fi
+    done <<< "$diff_content"
+
+    # Second pass: unset NEXT vars that were not in PREV (added vars)
+    while IFS= read -r line; do
+        if [[ "$line" == N:* ]]; then
+            local var="${line#N:}"
+            if [[ -z "${prev_vars[$var]+x}" ]]; then
+                unset "$var"
+            fi
+        fi
+    done <<< "$diff_content"
+}
+
+
+# Reverse previous diff
+__devenv_apply_reverse_diff
+
+# Capture env before sourcing new devenv
+_before=$(mktemp)
+__devenv_capture_env > "$_before"
+
+# Send enterShell output to the terminal instead of the captured stdout.
+# Probe by actually opening /dev/tty: it can exist with writable permission
+# bits yet fail to open (ENXIO) when there is no controlling terminal.
+if { : >/dev/tty; } 2>/dev/null; then
+    _devenv_reload_out=/dev/tty
+else
+    _devenv_reload_out=/dev/null
+fi
+
+# Source new devenv environment
+source "/tmp/devenv-reload-528741.sh" >"$_devenv_reload_out" 2>"$_devenv_reload_out"
+rm -f "/tmp/devenv-reload-528741.sh"
+unset _devenv_reload_out
+
+# Compute new diff
+__devenv_compute_diff "$_before"
+rm -f "$_before"
+
+# Output current environment for the calling shell to parse
+export -p
+        ' 2>/dev/null)
+
+        # Parse bash export -p output (declare -x VAR="value") and apply
+        # each variable to the fish environment via set -gx.
+        for line in $reload_output
+            # Match lines of the form: declare -x VAR="value"
+            set -l parts (string match -r '^declare -x ([^=]+)="(.*)"$' -- $line)
+            if test (count $parts) -gt 0
+                set -l var $parts[2]
+                set -l val $parts[3]
+                # Skip fish read-only electric variables that bash exports.
+                # PWD and SHLVL are managed by fish; assigning to them errors.
+                if test "$var" = PWD -o "$var" = SHLVL
+                    continue
+                end
+                # PATH, MANPATH, CDPATH are list variables in fish;
+                # split colon-separated values into proper lists.
+                if test "$var" = PATH -o "$var" = MANPATH -o "$var" = CDPATH
+                    set -gx $var (string split ":" -- $val)
+                else
+                    set -gx $var $val
+                end
+            else
+                # Variable exported without a value: declare -x VAR
+                set -l noval (string match -r '^declare -x ([^=]+)$' -- $line)
+                if test (count $noval) -gt 0
+                    set -gx $noval[2] ""
+                end
+            end
+        end
+
+        # Update saved PATH
+        set -gx _DEVENV_PATH (string join ":" -- $PATH)
+    end
+end
+
+function __devenv_restore_path
+    # Restore devenv PATH (in case direnv or other tools modified it).
+    # _DEVENV_PATH is a colon-separated string; split into a list for fish.
+    set -gx PATH (string split ":" -- $_DEVENV_PATH)
+end
+
+# Keybinding for manual reload (Ctrl+Alt+R by default)
+function __devenv_reload_keybind_handler
+    __devenv_reload_apply
+    commandline -f repaint
+end
+bind (string unescape '\x1b\x12') __devenv_reload_keybind_handler
+
+

package/.devenv/input-paths.txt

@@ -0,0 +1,10 @@
+/home/shift/.config/nixpkgs/overlays
+/home/shift/.config/nixpkgs/overlays.nix
+/media/Code/@Open-iFunny/ifunny-api-types/.devenv/bootstrap/bootstrapLib.nix
+/media/Code/@Open-iFunny/ifunny-api-types/.devenv/bootstrap/default.nix
+/media/Code/@Open-iFunny/ifunny-api-types/.devenv/bootstrap/resolve-lock.nix
+/media/Code/@Open-iFunny/ifunny-api-types/.env
+/media/Code/@Open-iFunny/ifunny-api-types/devenv.local.nix
+/media/Code/@Open-iFunny/ifunny-api-types/devenv.lock
+/media/Code/@Open-iFunny/ifunny-api-types/devenv.nix
+/media/Code/@Open-iFunny/ifunny-api-types/devenv.yaml

package/.devenv/load-exports

@@ -0,0 +1 @@
+

package/.devenv/nixpkgs-config-99f33fda17d41bc9.nix

@@ -0,0 +1,17 @@
+let
+  cfg = {};
+  getName = pkg: (builtins.parseDrvName (pkg.name or pkg.pname or "")).name;
+in cfg // {
+  allowUnfreePredicate =
+    if cfg.allowUnfree or false then
+      (_: true)
+    else if (cfg.permittedUnfreePackages or []) != [] then
+      (pkg: builtins.elem (getName pkg) (cfg.permittedUnfreePackages or []))
+    else
+      (_: false);
+  allowInsecurePredicate =
+    if (cfg.permittedInsecurePackages or []) != [] then
+      (pkg: builtins.elem (getName pkg) (cfg.permittedInsecurePackages or []))
+    else
+      (_: false);
+}

package/.devenv/nixpkgs-config-c46eff8321b73149.nix

@@ -0,0 +1,29 @@
+let
+  cfg = {};
+  getName = pkg: (builtins.parseDrvName (pkg.name or pkg.pname or "")).name;
+  unfreePackageError = pkg:
+    let
+      name = getName pkg;
+    in
+      throw ''
+        devenv: package '${name}' has an unfree license.
+
+        To allow all unfree packages, add this to devenv.yaml:
+
+          allow_unfree: true
+
+        To allow only this package, add this to devenv.yaml:
+
+          nixpkgs:
+            permitted_unfree_packages:
+              - ${name}
+      '';
+in cfg // {
+  allowUnfreePredicate =
+    if cfg.allowUnfree or false then
+      (_: true)
+    else if (cfg.permittedUnfreePackages or []) != [] then
+      (pkg: builtins.elem (getName pkg) (cfg.permittedUnfreePackages or []) || unfreePackageError pkg)
+    else
+      unfreePackageError;
+}