Struct StateManager 

pub struct StateManager {

    pub(crate) _state: PluginPass,
    pub(crate) import_paths: FxHashSet<String>,
    pub(crate) stylex_import: FxHashSet<ImportSources>,
    pub(crate) import_specifiers: Vec<String>,
    pub(crate) stylex_props_import: FxHashSet<Atom>,
    pub(crate) stylex_attrs_import: FxHashSet<Atom>,
    pub(crate) stylex_create_import: FxHashSet<Atom>,
    pub(crate) stylex_first_that_works_import: FxHashSet<Atom>,
    pub(crate) stylex_keyframes_import: FxHashSet<Atom>,
    pub(crate) stylex_define_vars_import: FxHashSet<Atom>,
    pub(crate) stylex_define_marker_import: FxHashSet<Atom>,
    pub(crate) stylex_define_consts_import: FxHashSet<Atom>,
    pub(crate) stylex_create_theme_import: FxHashSet<Atom>,
    pub(crate) stylex_position_try_import: FxHashSet<Atom>,
    pub(crate) stylex_view_transition_class_import: FxHashSet<Atom>,
    pub(crate) stylex_default_marker_import: FxHashSet<Atom>,
    pub(crate) stylex_when_import: FxHashSet<Atom>,
    pub(crate) stylex_types_import: FxHashSet<Atom>,
    pub(crate) stylex_env_import: FxHashSet<Atom>,
    pub(crate) inject_import_inserted: Option<(Ident, Ident)>,
    pub(crate) export_id: Option<String>,
    pub(crate) seen_module_source_code: Option<Box<(Program, Option<String>)>>,
    pub(crate) class_name_declarations: Vec<Ident>,
    pub(crate) function_name_declarations: Vec<Ident>,
    pub(crate) declarations: Vec<VarDeclarator>,
    pub(crate) top_level_expressions: Vec<TopLevelExpression>,
    pub all_call_expressions: FxHashMap<u64, CallExpr>,
    pub(crate) var_decl_count_map: FxHashMap<Atom, i16>,
    pub(crate) seen: FxHashMap<u64, Rc<SeenValueWithVarDeclCount>>,
    pub(crate) css_property_seen: FxHashMap<String, String>,
    pub(crate) span_cache: FxHashMap<u64, Span>,
    pub(crate) jsx_spread_attr_exprs_map: FxHashMap<Expr, Vec<JSXAttrOrSpread>>,
    pub(crate) style_map: FxHashMap<String, Rc<IndexMap<String, Rc<IndexMap<String, Rc<FlatCompiledStylesValue>>>>>>,
    pub(crate) style_vars: FxHashMap<String, VarDeclarator>,
    pub(crate) style_vars_to_keep: IndexSet<StyleVarsToKeep>,
    pub(crate) member_object_ident_count_map: FxHashMap<Atom, i16>,
    pub(crate) in_stylex_create: bool,
    pub(crate) options: StyleXStateOptions,
    pub metadata: IndexMap<String, IndexSet<MetaData>>,
    pub(crate) styles_to_inject: IndexMap<u64, Vec<ModuleItem>>,
    pub(crate) prepend_include_module_items: Vec<ModuleItem>,
    pub(crate) hoisted_module_items: Vec<ModuleItem>,
    pub(crate) prepend_import_module_items: Vec<ModuleItem>,
    pub(crate) other_injected_css_rules: IndexMap<String, Rc<InjectableStyleKind>>,
    pub(crate) top_imports: Vec<ImportDecl>,
    pub(crate) named_exports: FxHashSet<NamedExport>,
    pub cycle: TransformationCycle,
}

Fields

_state: PluginPass

import_paths: FxHashSet<String>

stylex_import: FxHashSet<ImportSources>

import_specifiers: Vec<String>

stylex_props_import: FxHashSet<Atom>

stylex_attrs_import: FxHashSet<Atom>

stylex_create_import: FxHashSet<Atom>

stylex_first_that_works_import: FxHashSet<Atom>

stylex_keyframes_import: FxHashSet<Atom>

stylex_define_vars_import: FxHashSet<Atom>

stylex_define_marker_import: FxHashSet<Atom>

stylex_define_consts_import: FxHashSet<Atom>

stylex_create_theme_import: FxHashSet<Atom>

stylex_position_try_import: FxHashSet<Atom>

stylex_view_transition_class_import: FxHashSet<Atom>

stylex_default_marker_import: FxHashSet<Atom>

stylex_when_import: FxHashSet<Atom>

stylex_types_import: FxHashSet<Atom>

stylex_env_import: FxHashSet<Atom>

inject_import_inserted: Option<(Ident, Ident)>

export_id: Option<String>

seen_module_source_code: Option<Box<(Program, Option<String>)>>

class_name_declarations: Vec<Ident>

function_name_declarations: Vec<Ident>

declarations: Vec<VarDeclarator>

top_level_expressions: Vec<TopLevelExpression>

all_call_expressions: FxHashMap<u64, CallExpr>

var_decl_count_map: FxHashMap<Atom, i16>

seen: FxHashMap<u64, Rc<SeenValueWithVarDeclCount>>

css_property_seen: FxHashMap<String, String>

span_cache: FxHashMap<u64, Span>

jsx_spread_attr_exprs_map: FxHashMap<Expr, Vec<JSXAttrOrSpread>>

style_map: FxHashMap<String, Rc<IndexMap<String, Rc<IndexMap<String, Rc<FlatCompiledStylesValue>>>>>>

style_vars: FxHashMap<String, VarDeclarator>

style_vars_to_keep: IndexSet<StyleVarsToKeep>

member_object_ident_count_map: FxHashMap<Atom, i16>

in_stylex_create: bool

options: StyleXStateOptions

metadata: IndexMap<String, IndexSet<MetaData>>

styles_to_inject: IndexMap<u64, Vec<ModuleItem>>

prepend_include_module_items: Vec<ModuleItem>

hoisted_module_items: Vec<ModuleItem>

prepend_import_module_items: Vec<ModuleItem>

other_injected_css_rules: IndexMap<String, Rc<InjectableStyleKind>>

top_imports: Vec<ImportDecl>

named_exports: FxHashSet<NamedExport>

cycle: TransformationCycle

Implementations

impl StateManager

pub fn new(stylex_options: StyleXOptions) -> Self

pub(crate) fn apply_stylex_env( &self, identifiers: &mut FxHashMap<Atom, Box<FunctionConfigType>>, member_expressions: &mut FxHashMap<ImportSources, Box<FxHashMap<Atom, Box<FunctionConfigType>>>>, )

Applies the env configuration to the given identifiers and member_expressions maps. This is the Rust equivalent of the JavaScript applyStylexEnv method.

pub(crate) fn get_seen_module_source_code( &self, ) -> Option<(&Module, &Option<String>)>

Gets the source code program if it exists and is not yet normalized

pub(crate) fn set_seen_module_source_code( &mut self, module: &Module, source_code: Option<String>, )

Sets the source code module (marks as not yet normalized)

pub fn import_as(&self, import: &str) -> Option<String>

pub fn import_sources(&self) -> Vec<ImportSources>

pub fn import_sources_stringified(&self) -> Vec<String>

pub fn stylex_import_stringified(&self) -> Vec<String>

pub(crate) fn is_test(&self) -> bool

pub(crate) fn is_dev(&self) -> bool

pub(crate) fn is_debug(&self) -> bool

pub(crate) fn enable_inlined_conditional_merge(&self) -> bool

pub(crate) fn get_short_filename(&self) -> String

pub(crate) fn get_filename(&self) -> &str

pub(crate) fn get_filename_for_hashing( &self, package_json_seen: &mut FxHashMap<String, PackageJsonExtended>, ) -> Option<String>

pub(crate) fn get_package_name_and_path( filepath: &str, package_json_seen: &mut FxHashMap<String, PackageJsonExtended>, ) -> Option<(Option<String>, String)>

pub(crate) fn get_canonical_file_path( &self, file_path: &str, package_json_seen: &mut FxHashMap<String, PackageJsonExtended>, ) -> String

pub(crate) fn import_path_resolver( &self, import_path: &str, package_json_seen: &mut FxHashMap<String, PackageJsonExtended>, ) -> ImportPathResolution

pub(crate) fn find_top_level_expr( &self, call: &CallExpr, extended_predicate_fn: impl Fn(&TopLevelExpression) -> bool, kind: Option<TopLevelExpressionKind>, ) -> Option<&TopLevelExpression>

pub(crate) fn find_call_declaration( &self, call: &CallExpr, ) -> Option<&VarDeclarator>

pub(crate) fn register_styles( &mut self, call: &CallExpr, style: &IndexMap<String, Rc<InjectableStyleKind>>, ast: &Expr, fallback_ast: Option<&Expr>, )

fn setup_injection_imports(&mut self) -> Ident

fn update_references( &mut self, call: &CallExpr, ast: &Expr, _fallback_ast: Option<&Expr>, )

fn add_style(&mut self, metadata: &MetaData)

fn add_style_to_inject( &mut self, metadata: &MetaData, inject_var_ident: &Ident, ast: &Expr, fallback_ast: Option<&Expr>, )

pub(crate) fn get_treeshake_compensation(&self) -> bool

pub fn combine(&mut self, other: &Self)

Trait Implementations

impl Clone for StateManager

fn clone(&self) -> StateManager

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for StateManager

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for StateManager

fn default() -> Self

Returns the “default value” for a type.

impl StyleOptions for StateManager

fn options(&self) -> &StyleXStateOptions

Access the StyleX configuration options.

fn css_property_seen(&self) -> &FxHashMap<String, String>

Map of CSS properties already processed, used to avoid duplicates.

fn css_property_seen_mut(&mut self) -> &mut FxHashMap<String, String>

Mutable access to the CSS properties map.

fn other_injected_css_rules(&self) -> &InjectableStylesMap

Access to injected CSS rules for keyframes, position-try, etc.

fn other_injected_css_rules_mut(&mut self) -> &mut InjectableStylesMap

Mutable access to injected CSS rules.

fn as_any_mut(&mut self) -> &mut dyn Any

Downcast to concrete type for bridge during migration.