@ifunny/ifunny-api-types 1.0.4 → 1.2.2

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

@@ -0,0 +1,123 @@
+# Source resolution shared by YAML discovery and full flake evaluation.
+{
+  src,
+  lockFile,
+  rootSrc ? {
+    outPath = src;
+  },
+}:
+let
+  sourceInfo =
+    key: node:
+    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 "") == "/";
+
+        sourceAttrs = node.info or { } // removeAttrs resolvedLocked [ "dir" ];
+        # Final fetches trust the lock's metadata and can substitute the
+        # source from a binary cache. Keep ordinary fetches for inputs
+        # whose missing metadata still needs to be supplied by the fetcher.
+        hasLockedMetadata =
+          sourceAttrs ? narHash
+          && (
+            sourceAttrs.type == "file"
+            || (
+              builtins.elem sourceAttrs.type [
+                "git"
+                "github"
+                "gitlab"
+                "sourcehut"
+                "tarball"
+              ]
+              && sourceAttrs ? lastModified
+              && (sourceAttrs.type == "tarball" || sourceAttrs ? rev)
+              && (sourceAttrs.type != "git" || (sourceAttrs.shallow or true) || sourceAttrs ? revCount)
+            )
+          );
+        fetchTree =
+          if hasLockedMetadata then builtins.fetchFinalTree or builtins.fetchTree else builtins.fetchTree;
+        fetchedSource = fetchTree sourceAttrs;
+      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;
+
+  # 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);
+
+  nodeSource =
+    key:
+    let
+      node = lockFile.nodes.${key};
+    in
+    {
+      repository_root = (sourceInfo key node).outPath;
+      dir = if key == lockFile.root then "" else node.locked.dir or "";
+    };
+in
+{
+  inherit sourceInfo resolveInput nodeSource;
+  nodePath =
+    key:
+    let
+      source = nodeSource key;
+    in
+    source.repository_root + (if source.dir == "" then "" else "/${source.dir}");
+}

package/.devenv/bootstrap/resolve-input-paths.nix

@@ -0,0 +1,34 @@
+{
+  src,
+  names,
+  lockFileJSON,
+  sourceResolver ? import ./lock-sources.nix,
+}:
+let
+  lockFilePath = src + "/devenv.lock";
+  lockFile = builtins.fromJSON lockFileJSON;
+  sources = sourceResolver { inherit src lockFile; };
+  rootInputs = lockFile.nodes.${lockFile.root}.inputs or { };
+in
+if lockFile.version < 5 || lockFile.version > 7 then
+  throw "lock file '${lockFilePath}' has unsupported version ${toString lockFile.version}"
+else
+  builtins.listToAttrs (
+    map (
+      name:
+      if !(builtins.hasAttr name rootInputs) then
+        throw "input '${name}' is missing from ${lockFilePath}"
+      else
+        {
+          inherit name;
+          value =
+            let
+              source = sources.nodeSource (sources.resolveInput rootInputs.${name});
+            in
+            {
+              repository_root = toString source.repository_root;
+              inherit (source) dir;
+            };
+        }
+    ) names
+  )

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

@@ -0,0 +1,116 @@
+# 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)}";
+
+  sources = import ./lock-sources.nix { inherit src lockFile rootSrc; };
+
+  allNodes = builtins.mapAttrs (
+    key: node:
+    let
+      sourceInfo = sources.sourceInfo key node;
+      outPath = sources.nodePath key;
+      inherit (sources) resolveInput;
+
+      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,13 @@
+{
+  "shown_hashes": [
+    "c40a016aca4dd81dcdca91ff004d81492328aa4b5c49912d6b83a945c2feff84",
+    "8839032c01350edeedfc4b3a2a745aa492e52c72f312cea40001db7ddd425a0c",
+    "e6825d4a5422d776d0eb3054f874bf73d8e32e9259f2d7be3a633cbce6bccdcd",
+    "97c8d967408d5e8dbaefb984ff368930aa96af9c3655e6d867154992052f5881",
+    "c676d28e6e161c0158c0f01f391da5d29a407d0a84fca705572b092ef839ee04",
+    "053d92e6228a113aaf85e8f544485eb3f64cc8b4ed6ec52abf21847cbc637b53",
+    "7e644d0388477d89d10f791e1509430c333b9585ad4215f913f292e10e248575",
+    "5a589290b7df7d37070a19af3adb407d66ebcfeaa9cd6b628ea0c1998d7a6cde",
+    "b81b889e24497f586305db7e9d9f0a4cfc0f802a8ef0a4c72b367ae6a70e5047"
+  ]
+}

package/.devenv/devenv.fish

@@ -0,0 +1,252 @@
+# devenv fish init
+
+# If this shell was spawned by the devenv hook, `exit` when the user `cd`s
+# outside the project so the parent shell can follow. The user's config.fish
+# may already have moved `_DEVENV_HOOK_DIR` to the non-exported
+# `_devenv_hook_dir` before this init file runs. Accept either marker so the
+# exit happens on PWD change, before prompt handlers can query the terminal.
+# Erase the exported marker so it cannot leak into further descendants.
+if set -q _DEVENV_HOOK_DIR; or 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-283714.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-283714.sh" >"$_devenv_reload_out" 2>"$_devenv_reload_out"
+rm -f "/tmp/devenv-reload-283714.sh"
+unset _devenv_reload_out
+
+# Compute new diff
+__devenv_compute_diff "$_before"
+rm -f "$_before"
+
+# Output environment data for the calling shell to apply
+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,8 @@
+/home/shift/.config/nixpkgs/overlays
+/home/shift/.config/nixpkgs/overlays.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
+/run/user/1000/devenv-02bb315/processes/native-manager.pid

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;
+}