decoration_change_event_emitter: vscode_sys::reference::EventEmitterRef,

pub fn handle_fs_watcher_event(env: &napi::Env, uri: vscode_sys::Uri) -> Result<(), napi::Error> {
    let mut extension_state = crate::ExtensionState::get()?;
    let decoration_change_event_emitter = extension_state
        .decoration_change_event_emitter
        .get_inner(env)?;

pub fn handle_fs_watcher_event(
    _env: &napi::Env,
    vscode_uri: vscode_sys::Uri,
) -> Result<(), napi::Error> {
    let uri = uri::from_vscode(&vscode_uri)?;
    event_loop::send(Event::ChangedFilesystemContents { uri });

    if let Some((repository_path, open_repository)) = extension_state
        .repositories
        .get_open_repository_mut(env, &uri)?
    {
        let absolute_file_path = Utf8PathBuf::from(uri.get_fs_path()?);
        let relative_file_path = absolute_file_path
            .strip_prefix(&repository_path)
            .map_err(|error| {
                napi::Error::from_reason(format!(
                    "Failed to strip prefix {repository_path} from {absolute_file_path}: {error}"
                ))
            })?
            .to_path_buf();
        open_repository
            .repository
            .update_path_state(relative_file_path)
            .map_err(|error| {
                napi::Error::from_reason(format!("Failed to update path state: {error:?}"))
            })?;
        decoration_change_event_emitter.fire(uri.inner)?;
        open_repository.update_resource_states(env, &repository_path)?;
    }

    let decoration_change_event_emitter = extension_state
        .decoration_change_event_emitter
        .get_inner(env)?;

            decoration_change_event_emitter.fire(new_uri.inner)?;

    let decoration_change_event_emitter = vscode_sys::EventEmitter::new(env)?;
    let decoration_change_event = decoration_change_event_emitter.get_event()?;

    event_loop::start(env, &vscode_object)?;

    event_loop::start(env, &vscode_object, decoration_change_event_emitter)?;

    let decoration_change_event_emitter = vscode_sys::EventEmitter::new(env)?;
    let decoration_change_event = decoration_change_event_emitter.get_event()?;
    let extension_state = ExtensionState {
        decoration_change_event_emitter: decoration_change_event_emitter.create_ref()?,
        repositories,
    };

    let extension_state = ExtensionState { repositories };

    decoration_change_event_emitter: Rc<vscode_sys::reference::EventEmitterRef>,

    decoration_change_event_emitter: vscode_sys::reference::EventEmitterRef,

        decoration_change_event_emitter: Rc::new(decoration_change_event_emitter),

                }
                Event::ChangedFilesystemContents { uri } => {
                    event::changed_filesystem_contents::handle(
                        uri,
                        &mut extension_state,
                        &js_functions,
                    )
                    .await

    decoration_change_event_emitter: vscode_sys::EventEmitter,

    let decoration_change_event_emitter_ref = decoration_change_event_emitter.create_ref()?;
    let decoration_type = crate::inline_credit::create_decoration_type(env)?.create_ref()?;

    let decoration_type = crate::inline_credit::create_decoration_type(env)?.create_ref()?;

        runtime.block_on(event_loop(decoration_type, js_functions, sender, receiver))

        runtime.block_on(event_loop(
            decoration_change_event_emitter_ref,
            decoration_type,
            js_functions,
            sender,
            receiver,
        ))

use iri_string::types::UriAbsoluteString;

pub mod fire_decoration_change_event;

    fire_decoration_change_event: fire_decoration_change_event::Prototype,

            fire_decoration_change_event: fire_decoration_change_event::build(env)?,

    pub async fn fire_decoration_change_event(
        &self,
        uri: UriAbsoluteString,
        event_emitter_reference: &Rc<vscode_sys::reference::EventEmitterRef>,
    ) -> Result<(), napi::Error> {
        let arguments = fire_decoration_change_event::Arguments {
            uri,
            event_emitter_reference: Rc::clone(event_emitter_reference),
        };
        self.fire_decoration_change_event
            .call_async(External::new(arguments))
            .await
    }

use std::rc::Rc;
use iri_string::types::UriAbsoluteString;
use napi::bindgen_prelude::{External, FunctionCallContext};
use napi::threadsafe_function::ThreadsafeFunction;
use crate::vscode_sys;
pub struct Arguments {
    pub uri: UriAbsoluteString,
    pub event_emitter_reference: Rc<vscode_sys::reference::EventEmitterRef>,
}
pub type Prototype =
    ThreadsafeFunction<External<Arguments>, (), External<Arguments>, napi::Status, false, false, 0>;
pub fn build(env: &napi::Env) -> Result<Prototype, napi::Error> {
    env.create_function_from_closure("fire_event", callback)?
        .build_threadsafe_function()
        .build()
}
fn callback(function_call_context: FunctionCallContext) -> Result<(), napi::Error> {
    let (external,): (&External<Arguments>,) = function_call_context.args()?;
    let Arguments {
        uri,
        event_emitter_reference,
    } = &**external;
    let event_emitter = event_emitter_reference.get_inner(function_call_context.env)?;
    let vscode_uri = crate::uri::to_vscode(function_call_context.env, uri)?;
    event_emitter.fire(vscode_uri.inner)
}

pub mod changed_filesystem_contents;

    },
    ChangedFilesystemContents {
        uri: UriAbsoluteString,

use iri_string::types::UriAbsoluteString;
use crate::event_loop::ExtensionState;
use crate::event_loop::js_function::Functions;
#[tracing::instrument(skip(extension_state, js_functions))]
pub async fn handle(
    uri: UriAbsoluteString,
    extension_state: &mut ExtensionState,
    js_functions: &Functions,
) {
    let Some((_repository_path, relative_path, repository)) =
        extension_state.get_repository_mut(&uri)
    else {
        tracing::info!(message = "Ignoring filesystem changes");
        return;
    };
    match repository
        .repository
        .update_path_state(relative_path.to_path_buf())
    {
        Ok(()) => tracing::debug!(message = "Updated path state"),
        Err(error) => {
            tracing::error!(
                message = "Failed to update path states",
                ?relative_path,
                ?error
            );
            return;
        }
    }
    match js_functions
        .fire_decoration_change_event(uri, &extension_state.decoration_change_event_emitter)
        .await
    {
        Ok(()) => {
            tracing::debug!(message = "Fired onDidChangeFileDecorations");
        }
        Err(error) => {
            tracing::warn!(
                message = "Failed to fire onDidChangeFileDecorations",
                ?error
            );
        }
    }
}