Grcov report - xml.rs

1

//! XML and XHTML parsing for declarative UI definitions.

2

//!

3

//! This module provides comprehensive XML parsing and manipulation for Azul's XML-based

4

//! UI format (`.azul` files). It supports:

5

//!

6

//! - **XHTML parsing**: Parse HTML-like syntax into DOM structures

7

//! - **CSS extraction**: Extract `<style>` blocks and inline styles

8

//! - **Component system**: Define reusable UI components with arguments

9

//! - **Hot reload**: Track file changes and rebuild UI incrementally

10

//! - **Error reporting**: Detailed syntax error messages with line/column info

11

//!

12

//! # Examples

13

//!

14

//! ```rust,no_run,ignore

15

//! use azul_core::xml::{XmlNode, XmlParseOptions};

16

//!

17

//! let xml = "<div>Hello</div>";

18

//! // let node = XmlNode::parse(xml)?;

19

//! ```

20

21

use alloc::{

22

    boxed::Box,

23

    collections::BTreeMap,

24

    string::{String, ToString},

25

    vec::Vec,

26

};

27

use core::{fmt, hash::Hash};

28

29

use azul_css::{

30

    css::{

31

        Css, CssDeclaration, CssPath, CssPathPseudoSelector, CssPathSelector, CssRuleBlock,

32

        NodeTypeTag,

33

},

34

    format_rust_code::VecContents,

35

    parser2::{CssParseErrorOwned, ErrorLocation},

36

    props::{

37

        basic::{ColorU, StyleFontFamilyVec},

38

        property::CssProperty,

39

        style::{

40

            NormalizedLinearColorStopVec, NormalizedRadialColorStopVec, StyleBackgroundContentVec,

41

            StyleBackgroundPositionVec, StyleBackgroundRepeatVec, StyleBackgroundSizeVec,

42

            StyleTransformVec,

43

},

44

},

45

    AzString, OptionString, StringVec, U8Vec,

46

};

47

48

use crate::{

49

    dom::{Dom, NodeType, OptionNodeType},

50

    styled_dom::StyledDom,

51

    window::{AzStringPair, StringPairVec},

52

};

53

54

/// Error that can occur during XML parsing or hot-reload.

55

///

56

/// Stringified for error reporting; not part of the public API.

57

pub type SyntaxError = String;

58

59

/// Tag of an XML node, such as the "button" in `<button>Hello</button>`.

60

#[derive(Default, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

61

#[repr(C)]

62

pub struct XmlTagName {

63

    pub inner: AzString,

64

65

66

impl From<AzString> for XmlTagName {

67

    fn from(s: AzString) -> Self {

68

        Self { inner: s }

69

70

71

72

impl From<String> for XmlTagName {

73

35315

    fn from(s: String) -> Self {

74

35315

        Self { inner: s.into() }

75

35315

76

77

78

impl From<&str> for XmlTagName {

79

3

    fn from(s: &str) -> Self {

80

3

        Self { inner: s.into() }

81

3

82

83

84

impl core::ops::Deref for XmlTagName {

85

    type Target = AzString;

86

128858

    fn deref(&self) -> &Self::Target {

87

128858

        &self.inner

88

128858

89

90

91

/// (Unparsed) text content of an XML node, such as the "Hello" in `<button>Hello</button>`.

92

pub type XmlTextContent = OptionString;

93

94

/// Attributes of an XML node, such as `["color" => "blue"]` in `<button color="blue" />`.

95

#[derive(Default, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

96

#[repr(C)]

97

pub struct XmlAttributeMap {

98

    pub inner: StringPairVec,

99

100

101

impl From<StringPairVec> for XmlAttributeMap {

102

35316

    fn from(v: StringPairVec) -> Self {

103

35316

        Self { inner: v }

104

35316

105

106

107

impl core::ops::Deref for XmlAttributeMap {

108

    type Target = StringPairVec;

109

175568

    fn deref(&self) -> &Self::Target {

110

175568

        &self.inner

111

175568

112

113

114

impl core::ops::DerefMut for XmlAttributeMap {

115

47320

    fn deref_mut(&mut self) -> &mut Self::Target {

116

47320

        &mut self.inner

117

47320

118

119

120

/// Name of a component argument (e.g. `"text"`, `"href"`).

121

type ComponentArgumentName = String;

122

/// Type of a component argument as a string (e.g. `"String"`, `"bool"`).

123

type ComponentArgumentType = String;

124

/// Zero-based position of an argument in the component's argument list.

125

type ComponentArgumentOrder = usize;

126

127

/// FFI-safe replacement for `(ComponentArgumentName, ComponentArgumentType)` tuple.

128

#[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

129

#[repr(C)]

130

pub struct ComponentArgument {

131

    pub name: AzString,

132

    pub arg_type: AzString,

133

134

135

impl_vec!(ComponentArgument, ComponentArgumentVec, ComponentArgumentVecDestructor, ComponentArgumentVecDestructorType, ComponentArgumentVecSlice, OptionComponentArgument);

136

impl_option!(ComponentArgument, OptionComponentArgument, copy = false, [Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]);

137

impl_vec_debug!(ComponentArgument, ComponentArgumentVec);

138

impl_vec_partialeq!(ComponentArgument, ComponentArgumentVec);

139

impl_vec_eq!(ComponentArgument, ComponentArgumentVec);

140

impl_vec_partialord!(ComponentArgument, ComponentArgumentVec);

141

impl_vec_ord!(ComponentArgument, ComponentArgumentVec);

142

impl_vec_hash!(ComponentArgument, ComponentArgumentVec);

143

impl_vec_clone!(ComponentArgument, ComponentArgumentVec, ComponentArgumentVecDestructor);

144

impl_vec_mut!(ComponentArgument, ComponentArgumentVec);

145

146

/// Holds the list of arguments and whether the component accepts text content.

147

/// Used by the compile pipeline to generate Rust function signatures.

148

#[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

149

pub struct ComponentArguments {

150

    pub args: ComponentArgumentVec,

151

    pub accepts_text: bool,

152

153

154

/// Name of an XML/HTML component (e.g. `"button"`, `"my-widget"`).

155

type ComponentName = String;

156

/// Compiled source code string for a component.

157

type CompiledComponent = String;

158

159

/// Universal HTML attribute names that are handled by the framework

160

/// and should not be passed through to component-specific argument lists.

161

const DEFAULT_ARGS: [&str; 8] = [

162

    "id",

163

    "class",

164

    "tabindex",

165

    "focusable",

166

    "accepts_text",

167

    "name",

168

    "style",

169

    "args",

170

];

171

172

/// Opaque void type for FFI pointers. Uses a custom definition instead of

173

/// `core::ffi::c_void` for `#[repr(C)]` compatibility in the generated API.

174

#[allow(non_camel_case_types)]

175

pub enum c_void {}

176

177

/// Type of an XML node in the parsed tree.

178

#[repr(C)]

179

pub enum XmlNodeType {

180

    Root,

181

    Element,

182

PI,

183

    Comment,

184

    Text,

185

186

187

/// A namespace-qualified XML name (e.g. `svg:rect` has namespace `"svg"` and local name `"rect"`).

188

#[repr(C)]

189

pub struct XmlQualifiedName {

190

    pub local_name: AzString,

191

    pub namespace: OptionString,

192

193

194

/// Classification of an external resource referenced in HTML/XML

195

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

196

#[repr(C)]

197

pub enum ExternalResourceKind {

198

    /// Image resource (img src, background-image, etc.)

199

    Image,

200

    /// Font resource (@font-face src, link rel="preload" as="font")

201

    Font,

202

    /// Stylesheet (link rel="stylesheet", @import)

203

    Stylesheet,

204

    /// Script (script src)

205

    Script,

206

    /// Favicon or icon

207

    Icon,

208

    /// Video source

209

    Video,

210

    /// Audio source

211

    Audio,

212

    /// Generic link or unknown resource type

213

    Unknown,

214

215

216

/// MIME type hint for an external resource

217

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

218

#[repr(C)]

219

pub struct MimeTypeHint {

220

    pub inner: AzString,

221

222

223

impl MimeTypeHint {

224

    pub fn new(s: &str) -> Self {

225

        Self { inner: AzString::from(s) }

226

227

228

    pub fn from_extension(ext: &str) -> Self {

229

        let mime = match ext.to_lowercase().as_str() {

230

            // Images

231

            "png" => "image/png",

232

            "jpg" | "jpeg" => "image/jpeg",

233

            "gif" => "image/gif",

234

            "webp" => "image/webp",

235

            "svg" => "image/svg+xml",

236

            "ico" => "image/x-icon",

237

            "bmp" => "image/bmp",

238

            "avif" => "image/avif",

239

            // Fonts

240

            "ttf" => "font/ttf",

241

            "otf" => "font/otf",

242

            "woff" => "font/woff",

243

            "woff2" => "font/woff2",

244

            "eot" => "application/vnd.ms-fontobject",

245

            // Stylesheets

246

            "css" => "text/css",

247

            // Scripts

248

            "js" => "application/javascript",

249

            "mjs" => "application/javascript",

250

            // Video

251

            "mp4" => "video/mp4",

252

            "webm" => "video/webm",

253

            "ogg" => "video/ogg",

254

            // Audio

255

            "mp3" => "audio/mpeg",

256

            "wav" => "audio/wav",

257

            "flac" => "audio/flac",

258

            // Default

259

            _ => "application/octet-stream",

260

};

261

        Self { inner: AzString::from(mime) }

262

263

264

265

impl_option!(

266

    MimeTypeHint,

267

    OptionMimeTypeHint,

268

    copy = false,

269

    [Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]

270

);

271

272

/// An external resource URL found in an XML/HTML document

273

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

274

#[repr(C)]

275

pub struct ExternalResource {

276

    /// The URL as found in the document (may be relative or absolute)

277

    pub url: AzString,

278

    /// Classification of the resource type

279

    pub kind: ExternalResourceKind,

280

    /// MIME type hint (from type attribute, file extension, or heuristics)

281

    pub mime_type: OptionMimeTypeHint,

282

    /// The HTML element that referenced this resource (e.g., "img", "link", "script")

283

    pub source_element: AzString,

284

    /// The attribute that contained the URL (e.g., "src", "href")

285

    pub source_attribute: AzString,

286

287

288

impl_option!(

289

    ExternalResource,

290

    OptionExternalResource,

291

    copy = false,

292

    [Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]

293

);

294

295

impl_vec!(ExternalResource, ExternalResourceVec, ExternalResourceVecDestructor, ExternalResourceVecDestructorType, ExternalResourceVecSlice, OptionExternalResource);

296

impl_vec_mut!(ExternalResource, ExternalResourceVec);

297

impl_vec_debug!(ExternalResource, ExternalResourceVec);

298

impl_vec_partialeq!(ExternalResource, ExternalResourceVec);

299

impl_vec_eq!(ExternalResource, ExternalResourceVec);

300

impl_vec_partialord!(ExternalResource, ExternalResourceVec);

301

impl_vec_ord!(ExternalResource, ExternalResourceVec);

302

impl_vec_hash!(ExternalResource, ExternalResourceVec);

303

impl_vec_clone!(ExternalResource, ExternalResourceVec, ExternalResourceVecDestructor);

304

305

#[derive(Debug, PartialEq, PartialOrd, Clone)]

306

#[repr(C)]

307

pub struct Xml {

308

    pub root: XmlNodeChildVec,

309

310

311

impl Xml {

312

    /// Scan the XML/HTML document for external resource URLs.

313

///

314

    /// This function traverses the entire document tree and extracts URLs from:

315

    /// - `<img src="...">` - Images

316

    /// - `<link href="...">` - Stylesheets, icons, fonts

317

    /// - `<script src="...">` - Scripts

318

    /// - `<video src="...">`, `<source src="...">` - Video

319

    /// - `<audio src="...">` - Audio

320

    /// - `<a href="...">` - Links (classified as Unknown)

321

    /// - CSS `url()` in style attributes

322

    /// - `<style>` blocks with @import or url()

323

    pub fn scan_external_resources(&self) -> ExternalResourceVec {

324

        let mut resources = Vec::new();

325

326

        for child in self.root.as_ref().iter() {

327

            Self::scan_node_child(child, &mut resources);

328

329

330

        resources.into()

331

332

333

    fn scan_node_child(child: &XmlNodeChild, resources: &mut Vec<ExternalResource>) {

334

        match child {

335

            XmlNodeChild::Text(text) => {

336

                // Check for CSS @import or url() in text content (inside <style> tags)

337

                Self::extract_css_urls(text.as_str(), resources);

338

339

            XmlNodeChild::Element(node) => {

340

                Self::scan_node(node, resources);

341

342

343

344

345

    fn scan_node(node: &XmlNode, resources: &mut Vec<ExternalResource>) {

346

        let tag_name = node.node_type.inner.as_str().to_lowercase();

347

348

        // Get attribute lookup helper

349

        let get_attr = |name: &str| -> Option<String> {

350

            node.attributes.inner.as_ref().iter()

351

                .find(|pair| pair.key.as_str().eq_ignore_ascii_case(name))

352

                .map(|pair| pair.value.as_str().to_string())

353

};

354

355

        match tag_name.as_str() {

356

            "img" => {

357

                if let Some(src) = get_attr("src") {

358

                    let mime = Self::guess_mime_from_url(&src, "image");

359

                    resources.push(ExternalResource {

360

                        url: AzString::from(src),

361

                        kind: ExternalResourceKind::Image,

362

                        mime_type: mime.into(),

363

                        source_element: AzString::from("img"),

364

                        source_attribute: AzString::from("src"),

365

});

366

367

                // Also check srcset

368

                if let Some(srcset) = get_attr("srcset") {

369

                    for src in Self::parse_srcset(&srcset) {

370

                        let mime = Self::guess_mime_from_url(&src, "image");

371

                        resources.push(ExternalResource {

372

                            url: AzString::from(src),

373

                            kind: ExternalResourceKind::Image,

374

                            mime_type: mime.into(),

375

                            source_element: AzString::from("img"),

376

                            source_attribute: AzString::from("srcset"),

377

});

378

379

380

381

            "link" => {

382

                if let Some(href) = get_attr("href") {

383

                    let rel = get_attr("rel").unwrap_or_default().to_lowercase();

384

                    let type_attr = get_attr("type");

385

                    let as_attr = get_attr("as").unwrap_or_default().to_lowercase();

386

387

                    let (kind, category) = if rel.contains("stylesheet") {

388

                        (ExternalResourceKind::Stylesheet, "stylesheet")

389

                    } else if rel.contains("icon") || rel.contains("apple-touch-icon") {

390

                        (ExternalResourceKind::Icon, "image")

391

                    } else if as_attr == "font" {

392

                        (ExternalResourceKind::Font, "font")

393

                    } else if as_attr == "script" {

394

                        (ExternalResourceKind::Script, "script")

395

                    } else if as_attr == "image" {

396

                        (ExternalResourceKind::Image, "image")

397

                    } else {

398

                        (ExternalResourceKind::Unknown, "")

399

};

400

401

                    let mime = type_attr.map(|t| MimeTypeHint::new(&t))

402

                        .or_else(|| Self::guess_mime_from_url(&href, category));

403

404

                    resources.push(ExternalResource {

405

                        url: AzString::from(href),

406

                        kind,

407

                        mime_type: mime.into(),

408

                        source_element: AzString::from("link"),

409

                        source_attribute: AzString::from("href"),

410

});

411

412

413

            "script" => {

414

                if let Some(src) = get_attr("src") {

415

                    let type_attr = get_attr("type");

416

                    let mime = type_attr.map(|t| MimeTypeHint::new(&t))

417

                        .or_else(|| Some(MimeTypeHint::new("application/javascript")));

418

419

                    resources.push(ExternalResource {

420

                        url: AzString::from(src),

421

                        kind: ExternalResourceKind::Script,

422

                        mime_type: mime.into(),

423

                        source_element: AzString::from("script"),

424

                        source_attribute: AzString::from("src"),

425

});

426

427

428

            "video" => {

429

                if let Some(src) = get_attr("src") {

430

                    let mime = Self::guess_mime_from_url(&src, "video");

431

                    resources.push(ExternalResource {

432

                        url: AzString::from(src),

433

                        kind: ExternalResourceKind::Video,

434

                        mime_type: mime.into(),

435

                        source_element: AzString::from("video"),

436

                        source_attribute: AzString::from("src"),

437

});

438

439

                if let Some(poster) = get_attr("poster") {

440

                    let mime = Self::guess_mime_from_url(&poster, "image");

441

                    resources.push(ExternalResource {

442

                        url: AzString::from(poster),

443

                        kind: ExternalResourceKind::Image,

444

                        mime_type: mime.into(),

445

                        source_element: AzString::from("video"),

446

                        source_attribute: AzString::from("poster"),

447

});

448

449

450

            "audio" => {

451

                if let Some(src) = get_attr("src") {

452

                    let mime = Self::guess_mime_from_url(&src, "audio");

453

                    resources.push(ExternalResource {

454

                        url: AzString::from(src),

455

                        kind: ExternalResourceKind::Audio,

456

                        mime_type: mime.into(),

457

                        source_element: AzString::from("audio"),

458

                        source_attribute: AzString::from("src"),

459

});

460

461

462

            "source" => {

463

                if let Some(src) = get_attr("src") {

464

                    let type_attr = get_attr("type");

465

                    // Determine kind based on type or parent (heuristic: assume video)

466

                    let kind = if type_attr.as_ref().map(|t| t.starts_with("audio")).unwrap_or(false) {

467

                        ExternalResourceKind::Audio

468

                    } else {

469

                        ExternalResourceKind::Video

470

};

471

                    let mime = type_attr.map(|t| MimeTypeHint::new(&t))

472

                        .or_else(|| Self::guess_mime_from_url(&src, if kind == ExternalResourceKind::Audio { "audio" } else { "video" }));

473

474

                    resources.push(ExternalResource {

475

                        url: AzString::from(src),

476

                        kind,

477

                        mime_type: mime.into(),

478

                        source_element: AzString::from("source"),

479

                        source_attribute: AzString::from("src"),

480

});

481

482

                // Also handle srcset for picture elements

483

                if let Some(srcset) = get_attr("srcset") {

484

                    for src in Self::parse_srcset(&srcset) {

485

                        let mime = Self::guess_mime_from_url(&src, "image");

486

                        resources.push(ExternalResource {

487

                            url: AzString::from(src),

488

                            kind: ExternalResourceKind::Image,

489

                            mime_type: mime.into(),

490

                            source_element: AzString::from("source"),

491

                            source_attribute: AzString::from("srcset"),

492

});

493

494

495

496

            "a" => {

497

                if let Some(href) = get_attr("href") {

498

                    // Only include if it looks like a resource, not a page link

499

                    if Self::looks_like_resource(&href) {

500

                        let mime = Self::guess_mime_from_url(&href, "");

501

                        resources.push(ExternalResource {

502

                            url: AzString::from(href),

503

                            kind: ExternalResourceKind::Unknown,

504

                            mime_type: mime.into(),

505

                            source_element: AzString::from("a"),

506

                            source_attribute: AzString::from("href"),

507

});

508

509

510

511

            "virtualized-view" | "embed" | "object" => {

512

                let src_attr = if tag_name == "object" { "data" } else { "src" };

513

                if let Some(src) = get_attr(src_attr) {

514

                    resources.push(ExternalResource {

515

                        url: AzString::from(src),

516

                        kind: ExternalResourceKind::Unknown,

517

                        mime_type: OptionMimeTypeHint::None,

518

                        source_element: AzString::from(tag_name.clone()),

519

                        source_attribute: AzString::from(src_attr),

520

});

521

522

523

            "style" => {

524

                // Scan text content for CSS URLs

525

                for child in node.children.as_ref().iter() {

526

                    if let XmlNodeChild::Text(text) = child {

527

                        Self::extract_css_urls(text.as_str(), resources);

528

529

530

531

            _ => {}

532

533

534

        // Check inline style attribute for url()

535

        if let Some(style) = get_attr("style") {

536

            Self::extract_css_urls(&style, resources);

537

538

539

        // Check for background attribute (deprecated but still used)

540

        if let Some(bg) = get_attr("background") {

541

            let mime = Self::guess_mime_from_url(&bg, "image");

542

            resources.push(ExternalResource {

543

                url: AzString::from(bg),

544

                kind: ExternalResourceKind::Image,

545

                mime_type: mime.into(),

546

                source_element: AzString::from(tag_name),

547

                source_attribute: AzString::from("background"),

548

});

549

550

551

        // Recurse into children

552

        for child in node.children.as_ref().iter() {

553

            Self::scan_node_child(child, resources);

554

555

556

557

    /// Extract URLs from CSS content (handles url() and @import)

558

    fn extract_css_urls(css: &str, resources: &mut Vec<ExternalResource>) {

559

        // Simple regex-like parsing for url(...) and @import

560

        let mut remaining = css;

561

562

        while let Some(pos) = remaining.find("url(") {

563

            let after_url = &remaining[pos + 4..];

564

            if let Some(url) = Self::extract_url_value(after_url) {

565

                let mime = Self::guess_mime_from_url(&url, "");

566

                let kind = Self::guess_kind_from_url(&url);

567

                resources.push(ExternalResource {

568

                    url: AzString::from(url),

569

                    kind,

570

                    mime_type: mime.into(),

571

                    source_element: AzString::from("style"),

572

                    source_attribute: AzString::from("url()"),

573

});

574

575

            remaining = after_url;

576

577

578

        // Handle @import "url" or @import url(...)

579

        remaining = css;

580

        while let Some(pos) = remaining.to_lowercase().find("@import") {

581

            let after_import = &remaining[pos + 7..];

582

            let trimmed = after_import.trim_start();

583

584

            if trimmed.starts_with("url(") {

585

                if let Some(url) = Self::extract_url_value(&trimmed[4..]) {

586

                    resources.push(ExternalResource {

587

                        url: AzString::from(url),

588

                        kind: ExternalResourceKind::Stylesheet,

589

                        mime_type: Some(MimeTypeHint::new("text/css")).into(),

590

                        source_element: AzString::from("style"),

591

                        source_attribute: AzString::from("@import"),

592

});

593

594

            } else if let Some(url) = Self::extract_quoted_string(trimmed) {

595

                resources.push(ExternalResource {

596

                    url: AzString::from(url),

597

                    kind: ExternalResourceKind::Stylesheet,

598

                    mime_type: Some(MimeTypeHint::new("text/css")).into(),

599

                    source_element: AzString::from("style"),

600

                    source_attribute: AzString::from("@import"),

601

});

602

603

604

            remaining = after_import;

605

606

607

608

    /// Extract value from url(...) - handles quoted and unquoted URLs

609

    fn extract_url_value(s: &str) -> Option<String> {

610

        let trimmed = s.trim_start();

611

        if trimmed.starts_with('"') {

612

            Self::extract_quoted_string(trimmed)

613

        } else if trimmed.starts_with('\'') {

614

            let end = trimmed[1..].find('\'')?;

615

            Some(trimmed[1..1+end].to_string())

616

        } else {

617

            let end = trimmed.find(')')?;

618

            Some(trimmed[..end].trim().to_string())

619

620

621

622

    /// Extract a quoted string value

623

    fn extract_quoted_string(s: &str) -> Option<String> {

624

        if s.starts_with('"') {

625

            let end = s[1..].find('"')?;

626

            Some(s[1..1+end].to_string())

627

        } else if s.starts_with('\'') {

628

            let end = s[1..].find('\'')?;

629

            Some(s[1..1+end].to_string())

630

        } else {

631

            None

632

633

634

635

    /// Parse srcset attribute into individual URLs

636

    fn parse_srcset(srcset: &str) -> Vec<String> {

637

        srcset.split(',')

638

            .filter_map(|entry| {

639

                let trimmed = entry.trim();

640

                // srcset format: "url 1x" or "url 100w"

641

                trimmed.split_whitespace().next().map(|s| s.to_string())

642

})

643

            .filter(|url| !url.is_empty())

644

            .collect()

645

646

647

    /// Check if a URL looks like a downloadable resource (not a page)

648

    fn looks_like_resource(url: &str) -> bool {

649

        let lower = url.to_lowercase();

650

        // Check for common resource extensions

651

        let resource_exts = [

652

            ".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg", ".ico", ".bmp",

653

            ".ttf", ".otf", ".woff", ".woff2", ".eot",

654

            ".css", ".js",

655

            ".mp4", ".webm", ".ogg", ".mp3", ".wav",

656

            ".pdf", ".zip", ".tar", ".gz",

657

];

658

        resource_exts.iter().any(|ext| lower.ends_with(ext))

659

660

661

    /// Guess the resource kind from URL based on file extension.

662

    fn guess_kind_from_url(url: &str) -> ExternalResourceKind {

663

        let lower = url.to_lowercase();

664

        // Strip query string before checking extension

665

        let path = lower.split('?').next().unwrap_or(&lower);

666

        if path.ends_with(".png") || path.ends_with(".jpg") || path.ends_with(".jpeg")

667

            || path.ends_with(".gif") || path.ends_with(".webp") || path.ends_with(".svg")

668

            || path.ends_with(".bmp") || path.ends_with(".avif") {

669

            ExternalResourceKind::Image

670

        } else if path.ends_with(".ttf") || path.ends_with(".otf") || path.ends_with(".woff")

671

            || path.ends_with(".woff2") || path.ends_with(".eot") {

672

            ExternalResourceKind::Font

673

        } else if path.ends_with(".css") {

674

            ExternalResourceKind::Stylesheet

675

        } else if path.ends_with(".js") || path.ends_with(".mjs") {

676

            ExternalResourceKind::Script

677

        } else if path.ends_with(".mp4") || path.ends_with(".webm") || path.ends_with(".ogg") {

678

            ExternalResourceKind::Video

679

        } else if path.ends_with(".mp3") || path.ends_with(".wav") || path.ends_with(".flac") {

680

            ExternalResourceKind::Audio

681

        } else if path.ends_with(".ico") {

682

            ExternalResourceKind::Icon

683

        } else {

684

            ExternalResourceKind::Unknown

685

686

687

688

    /// Guess MIME type from URL based on extension

689

    fn guess_mime_from_url(url: &str, category: &str) -> Option<MimeTypeHint> {

690

        let lower = url.to_lowercase();

691

        // Find extension

692

        let ext = lower.rsplit('.').next()?;

693

        // Remove query string if present

694

        let ext = ext.split('?').next()?;

695

696

        // Check if it's a valid extension

697

        let valid_exts = [

698

            "png", "jpg", "jpeg", "gif", "webp", "svg", "ico", "bmp", "avif",

699

            "ttf", "otf", "woff", "woff2", "eot",

700

            "css", "js", "mjs",

701

            "mp4", "webm", "ogg", "mp3", "wav", "flac",

702

];

703

704

        if valid_exts.contains(&ext) {

705

            Some(MimeTypeHint::from_extension(ext))

706

        } else if !category.is_empty() {

707

            // Use category hint for default

708

            match category {

709

                "image" => Some(MimeTypeHint::new("image/*")),

710

                "font" => Some(MimeTypeHint::new("font/*")),

711

                "stylesheet" => Some(MimeTypeHint::new("text/css")),

712

                "script" => Some(MimeTypeHint::new("application/javascript")),

713

                "video" => Some(MimeTypeHint::new("video/*")),

714

                "audio" => Some(MimeTypeHint::new("audio/*")),

715

                _ => None,

716

717

        } else {

718

            None

719

720

721

722

723

#[derive(Debug, PartialEq, PartialOrd, Clone)]

724

#[repr(C)]

725

pub struct NonXmlCharError {

726

    pub ch: u32, /* u32 = char, but ABI stable */

727

    pub pos: XmlTextPos,

728

729

730

#[derive(Debug, PartialEq, PartialOrd, Clone)]

731

#[repr(C)]

732

pub struct InvalidCharError {

733

    pub expected: u8,

734

    pub got: u8,

735

    pub pos: XmlTextPos,

736

737

738

#[derive(Debug, PartialEq, PartialOrd, Clone)]

739

#[repr(C)]

740

pub struct InvalidCharMultipleError {

741

    pub expected: u8,

742

    pub got: U8Vec,

743

    pub pos: XmlTextPos,

744

745

746

#[derive(Debug, PartialEq, PartialOrd, Clone)]

747

#[repr(C)]

748

pub struct InvalidQuoteError {

749

    pub got: u8,

750

    pub pos: XmlTextPos,

751

752

753

#[derive(Debug, PartialEq, PartialOrd, Clone)]

754

#[repr(C)]

755

pub struct InvalidSpaceError {

756

    pub got: u8,

757

    pub pos: XmlTextPos,

758

759

760

#[derive(Debug, PartialEq, PartialOrd, Clone)]

761

#[repr(C)]

762

pub struct InvalidStringError {

763

    pub got: AzString,

764

    pub pos: XmlTextPos,

765

766

767

#[derive(Debug, PartialEq, PartialOrd, Clone)]

768

#[repr(C, u8)]

769

pub enum XmlStreamError {

770

    UnexpectedEndOfStream,

771

    InvalidName,

772

    NonXmlChar(NonXmlCharError),

773

    InvalidChar(InvalidCharError),

774

    InvalidCharMultiple(InvalidCharMultipleError),

775

    InvalidQuote(InvalidQuoteError),

776

    InvalidSpace(InvalidSpaceError),

777

    InvalidString(InvalidStringError),

778

    InvalidReference,

779

    InvalidExternalID,

780

    InvalidCommentData,

781

    InvalidCommentEnd,

782

    InvalidCharacterData,

783

784

785

impl fmt::Display for XmlStreamError {

786

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

787

        use self::XmlStreamError::*;

788

        match self {

789

            UnexpectedEndOfStream => write!(f, "Unexpected end of stream"),

790

            InvalidName => write!(f, "Invalid name"),

791

            NonXmlChar(nx) => write!(

792

f,

793

                "Non-XML character: {:?} at {}",

794

                core::char::from_u32(nx.ch),

795

                nx.pos

796

),

797

            InvalidChar(ic) => write!(

798

f,

799

                "Invalid character: expected: {}, got: {} at {}",

800

                ic.expected as char, ic.got as char, ic.pos

801

),

802

            InvalidCharMultiple(imc) => write!(

803

f,

804

                "Multiple invalid characters: expected: {}, got: {:?} at {}",

805

                imc.expected,

806

                imc.got.as_ref(),

807

                imc.pos

808

),

809

            InvalidQuote(iq) => write!(f, "Invalid quote: got {} at {}", iq.got as char, iq.pos),

810

            InvalidSpace(is) => write!(f, "Invalid space: got {} at {}", is.got as char, is.pos),

811

            InvalidString(ise) => write!(

812

f,

813

                "Invalid string: got \"{}\" at {}",

814

                ise.got.as_str(),

815

                ise.pos

816

),

817

            InvalidReference => write!(f, "Invalid reference"),

818

            InvalidExternalID => write!(f, "Invalid external ID"),

819

            InvalidCommentData => write!(f, "Invalid comment data"),

820

            InvalidCommentEnd => write!(f, "Invalid comment end"),

821

            InvalidCharacterData => write!(f, "Invalid character data"),

822

823

824

825

826

#[derive(Debug, PartialEq, PartialOrd, Clone, Ord, Hash, Eq)]

827

#[repr(C)]

828

pub struct XmlTextPos {

829

    pub row: u32,

830

    pub col: u32,

831

832

833

impl fmt::Display for XmlTextPos {

834

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

835

        write!(f, "line {}:{}", self.row, self.col)

836

837

838

839

#[derive(Debug, PartialEq, PartialOrd, Clone)]

840

#[repr(C)]

841

pub struct XmlTextError {

842

    pub stream_error: XmlStreamError,

843

    pub pos: XmlTextPos,

844

845

846

#[derive(Debug, PartialEq, PartialOrd, Clone)]

847

#[repr(C, u8)]

848

pub enum XmlParseError {

849

    InvalidDeclaration(XmlTextError),

850

    InvalidComment(XmlTextError),

851

    InvalidPI(XmlTextError),

852

    InvalidDoctype(XmlTextError),

853

    InvalidEntity(XmlTextError),

854

    InvalidElement(XmlTextError),

855

    InvalidAttribute(XmlTextError),

856

    InvalidCdata(XmlTextError),

857

    InvalidCharData(XmlTextError),

858

    UnknownToken(XmlTextPos),

859

860

861

impl fmt::Display for XmlParseError {

862

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

863

        use self::XmlParseError::*;

864

        match self {

865

            InvalidDeclaration(e) => {

866

                write!(f, "Invalid declaration: {} at {}", e.stream_error, e.pos)

867

868

            InvalidComment(e) => write!(f, "Invalid comment: {} at {}", e.stream_error, e.pos),

869

            InvalidPI(e) => write!(

870

f,

871

                "Invalid processing instruction: {} at {}",

872

                e.stream_error, e.pos

873

),

874

            InvalidDoctype(e) => write!(f, "Invalid doctype: {} at {}", e.stream_error, e.pos),

875

            InvalidEntity(e) => write!(f, "Invalid entity: {} at {}", e.stream_error, e.pos),

876

            InvalidElement(e) => write!(f, "Invalid element: {} at {}", e.stream_error, e.pos),

877

            InvalidAttribute(e) => write!(f, "Invalid attribute: {} at {}", e.stream_error, e.pos),

878

            InvalidCdata(e) => write!(f, "Invalid CDATA: {} at {}", e.stream_error, e.pos),

879

            InvalidCharData(e) => write!(f, "Invalid char data: {} at {}", e.stream_error, e.pos),

880

            UnknownToken(e) => write!(f, "Unknown token at {}", e),

881

882

883

884

885

impl_result!(

886

    Xml,

887

    XmlError,

888

    ResultXmlXmlError,

889

    copy = false,

890

    [Debug, PartialEq, PartialOrd, Clone]

891

);

892

893

#[derive(Debug, PartialEq, PartialOrd, Clone)]

894

#[repr(C)]

895

pub struct DuplicatedNamespaceError {

896

    pub ns: AzString,

897

    pub pos: XmlTextPos,

898

899

900

#[derive(Debug, PartialEq, PartialOrd, Clone)]

901

#[repr(C)]

902

pub struct UnknownNamespaceError {

903

    pub ns: AzString,

904

    pub pos: XmlTextPos,

905

906

907

#[derive(Debug, PartialEq, PartialOrd, Clone)]

908

#[repr(C)]

909

pub struct UnexpectedCloseTagError {

910

    pub expected: AzString,

911

    pub actual: AzString,

912

    pub pos: XmlTextPos,

913

914

915

#[derive(Debug, PartialEq, PartialOrd, Clone)]

916

#[repr(C)]

917

pub struct UnknownEntityReferenceError {

918

    pub entity: AzString,

919

    pub pos: XmlTextPos,

920

921

922

#[derive(Debug, PartialEq, PartialOrd, Clone)]

923

#[repr(C)]

924

pub struct DuplicatedAttributeError {

925

    pub attribute: AzString,

926

    pub pos: XmlTextPos,

927

928

929

/// Error for mismatched open/close tags in XML hierarchy

930

#[derive(Debug, PartialEq, PartialOrd, Clone)]

931

#[repr(C)]

932

pub struct MalformedHierarchyError {

933

    /// The tag that was expected (from the opening tag)

934

    pub expected: AzString,

935

    /// The tag that was actually found (the closing tag)

936

    pub got: AzString,

937

938

939

#[derive(Debug, PartialEq, PartialOrd, Clone)]

940

#[repr(C, u8)]

941

pub enum XmlError {

942

    NoParserAvailable,

943

    InvalidXmlPrefixUri(XmlTextPos),

944

    UnexpectedXmlUri(XmlTextPos),

945

    UnexpectedXmlnsUri(XmlTextPos),

946

    InvalidElementNamePrefix(XmlTextPos),

947

    DuplicatedNamespace(DuplicatedNamespaceError),

948

    UnknownNamespace(UnknownNamespaceError),

949

    UnexpectedCloseTag(UnexpectedCloseTagError),

950

    UnexpectedEntityCloseTag(XmlTextPos),

951

    UnknownEntityReference(UnknownEntityReferenceError),

952

    MalformedEntityReference(XmlTextPos),

953

    EntityReferenceLoop(XmlTextPos),

954

    InvalidAttributeValue(XmlTextPos),

955

    DuplicatedAttribute(DuplicatedAttributeError),

956

    NoRootNode,

957

    SizeLimit,

958

    DtdDetected,

959

    /// Invalid hierarchy close tags, i.e `<app></p></app>`

960

    MalformedHierarchy(MalformedHierarchyError),

961

    ParserError(XmlParseError),

962

    UnclosedRootNode,

963

    UnexpectedDeclaration(XmlTextPos),

964

    NodesLimitReached,

965

    AttributesLimitReached,

966

    NamespacesLimitReached,

967

    InvalidName(XmlTextPos),

968

    NonXmlChar(XmlTextPos),

969

    InvalidChar(XmlTextPos),

970

    InvalidChar2(XmlTextPos),

971

    InvalidString(XmlTextPos),

972

    InvalidExternalID(XmlTextPos),

973

    InvalidComment(XmlTextPos),

974

    InvalidCharacterData(XmlTextPos),

975

    UnknownToken(XmlTextPos),

976

    UnexpectedEndOfStream,

977

978

979

impl fmt::Display for XmlError {

980

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

981

        use self::XmlError::*;

982

        match self {

983

            NoParserAvailable => write!(

984

f,

985

                "Library was compiled without XML parser (XML parser not available)"

986

),

987

            InvalidXmlPrefixUri(pos) => {

988

                write!(f, "Invalid XML Prefix URI at line {}:{}", pos.row, pos.col)

989

990

            UnexpectedXmlUri(pos) => {

991

                write!(f, "Unexpected XML URI at line {}:{}", pos.row, pos.col)

992

993

            UnexpectedXmlnsUri(pos) => write!(

994

f,

995

                "Unexpected XML namespace URI at line {}:{}",

996

                pos.row, pos.col

997

),

998

            InvalidElementNamePrefix(pos) => write!(

999

f,

1000

                "Invalid element name prefix at line {}:{}",

1001

                pos.row, pos.col

1002

),

1003

            DuplicatedNamespace(ns) => write!(

1004

f,

1005

                "Duplicated namespace: \"{}\" at {}",

1006

                ns.ns.as_str(),

1007

                ns.pos

1008

),

1009

            UnknownNamespace(uns) => write!(

1010

f,

1011

                "Unknown namespace: \"{}\" at {}",

1012

                uns.ns.as_str(),

1013

                uns.pos

1014

),

1015

            UnexpectedCloseTag(ct) => write!(

1016

f,

1017

                "Unexpected close tag: expected \"{}\", got \"{}\" at {}",

1018

                ct.expected.as_str(),

1019

                ct.actual.as_str(),

1020

                ct.pos

1021

),

1022

            UnexpectedEntityCloseTag(pos) => write!(

1023

f,

1024

                "Unexpected entity close tag at line {}:{}",

1025

                pos.row, pos.col

1026

),

1027

            UnknownEntityReference(uer) => write!(

1028

f,

1029

                "Unexpected entity reference: \"{}\" at {}",

1030

                uer.entity, uer.pos

1031

),

1032

            MalformedEntityReference(pos) => write!(

1033

f,

1034

                "Malformed entity reference at line {}:{}",

1035

                pos.row, pos.col

1036

),

1037

            EntityReferenceLoop(pos) => write!(

1038

f,

1039

                "Entity reference loop (recursive entity reference) at line {}:{}",

1040

                pos.row, pos.col

1041

),

1042

            InvalidAttributeValue(pos) => {

1043

                write!(f, "Invalid attribute value at line {}:{}", pos.row, pos.col)

1044

1045

            DuplicatedAttribute(ae) => write!(

1046

f,

1047

                "Duplicated attribute \"{}\" at line {}:{}",

1048

                ae.attribute.as_str(),

1049

                ae.pos.row,

1050

                ae.pos.col

1051

),

1052

            NoRootNode => write!(f, "No root node found"),

1053

            SizeLimit => write!(f, "XML file too large (size limit reached)"),

1054

            DtdDetected => write!(f, "Document type descriptor detected"),

1055

            MalformedHierarchy(e) => write!(

1056

f,

1057

                "Malformed hierarchy: expected <{}/> closing tag, got <{}/>",

1058

                e.expected.as_str(),

1059

                e.got.as_str()

1060

),

1061

            ParserError(p) => write!(f, "{}", p),

1062

            UnclosedRootNode => write!(f, "unclosed root node"),

1063

            UnexpectedDeclaration(tp) => write!(f, "unexpected declaration at {tp}"),

1064

            NodesLimitReached => write!(f, "nodes limit reached"),

1065

            AttributesLimitReached => write!(f, "attributes limit reached"),

1066

            NamespacesLimitReached => write!(f, "namespaces limit reached"),

1067

            InvalidName(tp) => write!(f, "invalid name at {tp}"),

1068

            NonXmlChar(tp) => write!(f, "non xml char at {tp}"),

1069

            InvalidChar(tp) => write!(f, "invalid char at {tp}"),

1070

            InvalidChar2(tp) => write!(f, "invalid char2 at {tp}"),

1071

            InvalidString(tp) => write!(f, "invalid string at {tp}"),

1072

            InvalidExternalID(tp) => write!(f, "invalid externalid at {tp}"),

1073

            InvalidComment(tp) => write!(f, "invalid comment at {tp}"),

1074

            InvalidCharacterData(tp) => write!(f, "invalid character data at {tp}"),

1075

            UnknownToken(tp) => write!(f, "unknown token at {tp}"),

1076

            UnexpectedEndOfStream => write!(f, "unexpected end of stream"),

1077

1078

1079

1080

1081

// ============================================================================

1082

// New repr(C) component system

1083

// ============================================================================

1084

1085

/// Identifies a component within a library collection.

1086

/// e.g. collection="builtin", name="div" for the `<div>` element,

1087

/// or collection="shadcn", name="avatar" for a custom component.

1088

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

1089

#[repr(C)]

1090

pub struct ComponentId {

1091

    /// Library / collection name: "builtin", "shadcn", "myproject"

1092

    pub collection: AzString,

1093

    /// Component name within the collection: "div", "avatar", "card"

1094

    pub name: AzString,

1095

1096

1097

impl ComponentId {

1098

362250

    pub fn builtin(name: &str) -> Self {

1099

362250

        Self {

1100

362250

            collection: AzString::from_const_str("builtin"),

1101

362250

            name: AzString::from(name),

1102

362250

1103

362250

1104

1105

    pub fn new(collection: &str, name: &str) -> Self {

1106

        Self {

1107

            collection: AzString::from(collection),

1108

            name: AzString::from(name),

1109

1110

1111

1112

    /// Returns "collection:name" format string

1113

    pub fn qualified_name(&self) -> String {

1114

        format!("{}:{}", self.collection.as_str(), self.name.as_str())

1115

1116

1117

1118

// ============================================================================

1119

// Component type system — rich type descriptors for component fields

1120

// ============================================================================

1121

1122

/// A single argument in a callback signature.

1123

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

1124

#[repr(C)]

1125

pub struct ComponentCallbackArg {

1126

    /// Argument name, e.g. "button_id"

1127

    pub name: AzString,

1128

    /// Argument type

1129

    pub arg_type: ComponentFieldType,

1130

1131

1132

impl_vec!(ComponentCallbackArg, ComponentCallbackArgVec, ComponentCallbackArgVecDestructor, ComponentCallbackArgVecDestructorType, ComponentCallbackArgVecSlice, OptionComponentCallbackArg);

1133

impl_option!(ComponentCallbackArg, OptionComponentCallbackArg, copy = false, [Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]);

1134

impl_vec_debug!(ComponentCallbackArg, ComponentCallbackArgVec);

1135

impl_vec_partialeq!(ComponentCallbackArg, ComponentCallbackArgVec);

1136

impl_vec_eq!(ComponentCallbackArg, ComponentCallbackArgVec);

1137

impl_vec_partialord!(ComponentCallbackArg, ComponentCallbackArgVec);

1138

impl_vec_ord!(ComponentCallbackArg, ComponentCallbackArgVec);

1139

impl_vec_hash!(ComponentCallbackArg, ComponentCallbackArgVec);

1140

impl_vec_clone!(ComponentCallbackArg, ComponentCallbackArgVec, ComponentCallbackArgVecDestructor);

1141

1142

/// Callback signature: return type + argument list.

1143

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

1144

#[repr(C)]

1145

pub struct ComponentCallbackSignature {

1146

    /// Return type name, e.g. "Update"

1147

    pub return_type: AzString,

1148

    /// Callback arguments (excluding the implicit `&mut RefAny` and `&mut CallbackInfo`)

1149

    pub args: ComponentCallbackArgVec,

1150

1151

1152

/// Heap-allocated box for recursive `ComponentFieldType` (e.g. `Option<String>`).

1153

/// Uses raw pointer indirection to break the infinite size.

1154

#[repr(C)]

1155

pub struct ComponentFieldTypeBox {

1156

    pub ptr: *mut ComponentFieldType,

1157

1158

1159

impl ComponentFieldTypeBox {

1160

    pub fn new(t: ComponentFieldType) -> Self {

1161

        Self { ptr: Box::into_raw(Box::new(t)) }

1162

1163

1164

    pub fn as_ref(&self) -> &ComponentFieldType {

1165

        unsafe { &*self.ptr }

1166

1167

1168

1169

impl Clone for ComponentFieldTypeBox {

1170

    fn clone(&self) -> Self {

1171

        Self::new(unsafe { (*self.ptr).clone() })

1172

1173

1174

1175

impl Drop for ComponentFieldTypeBox {

1176

    fn drop(&mut self) {

1177

        if !self.ptr.is_null() {

1178

            unsafe { let _ = Box::from_raw(self.ptr); }

1179

1180

1181

1182

1183

impl fmt::Debug for ComponentFieldTypeBox {

1184

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

1185

        if self.ptr.is_null() {

1186

            write!(f, "ComponentFieldTypeBox(null)")

1187

        } else {

1188

            write!(f, "ComponentFieldTypeBox({:?})", unsafe { &*self.ptr })

1189

1190

1191

1192

1193

impl PartialEq for ComponentFieldTypeBox {

1194

    fn eq(&self, other: &Self) -> bool {

1195

        if self.ptr.is_null() && other.ptr.is_null() { return true; }

1196

        if self.ptr.is_null() || other.ptr.is_null() { return false; }

1197

        unsafe { *self.ptr == *other.ptr }

1198

1199

1200

1201

impl Eq for ComponentFieldTypeBox {}

1202

1203

impl PartialOrd for ComponentFieldTypeBox {

1204

    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {

1205

        Some(self.cmp(other))

1206

1207

1208

1209

impl Ord for ComponentFieldTypeBox {

1210

    fn cmp(&self, other: &Self) -> core::cmp::Ordering {

1211

        match (self.ptr.is_null(), other.ptr.is_null()) {

1212

            (true, true) => core::cmp::Ordering::Equal,

1213

            (true, false) => core::cmp::Ordering::Less,

1214

            (false, true) => core::cmp::Ordering::Greater,

1215

            (false, false) => unsafe { (*self.ptr).cmp(&*other.ptr) },

1216

1217

1218

1219

1220

impl core::hash::Hash for ComponentFieldTypeBox {

1221

    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {

1222

        if !self.ptr.is_null() {

1223

            unsafe { (*self.ptr).hash(state); }

1224

1225

1226

1227

1228

/// Heap-allocated box for recursive `ComponentFieldValue` (e.g. `Some(value)`).

1229

/// Uses raw pointer indirection to break the infinite size.

1230

#[repr(C)]

1231

pub struct ComponentFieldValueBox {

1232

    pub ptr: *mut ComponentFieldValue,

1233

1234

1235

impl ComponentFieldValueBox {

1236

    pub fn new(v: ComponentFieldValue) -> Self {

1237

        Self { ptr: Box::into_raw(Box::new(v)) }

1238

1239

1240

    pub fn as_ref(&self) -> &ComponentFieldValue {

1241

        unsafe { &*self.ptr }

1242

1243

1244

1245

impl Clone for ComponentFieldValueBox {

1246

    fn clone(&self) -> Self {

1247

        Self::new(unsafe { (*self.ptr).clone() })

1248

1249

1250

1251

impl Drop for ComponentFieldValueBox {

1252

    fn drop(&mut self) {

1253

        if !self.ptr.is_null() {

1254

            unsafe { let _ = Box::from_raw(self.ptr); }

1255

1256

1257

1258

1259

impl fmt::Debug for ComponentFieldValueBox {

1260

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

1261

        if self.ptr.is_null() {

1262

            write!(f, "ComponentFieldValueBox(null)")

1263

        } else {

1264

            write!(f, "ComponentFieldValueBox({:?})", unsafe { &*self.ptr })

1265

1266

1267

1268

1269

impl PartialEq for ComponentFieldValueBox {

1270

    fn eq(&self, other: &Self) -> bool {

1271

        if self.ptr.is_null() && other.ptr.is_null() { return true; }

1272

        if self.ptr.is_null() || other.ptr.is_null() { return false; }

1273

        unsafe { *self.ptr == *other.ptr }

1274

1275

1276

1277

/// Rich type descriptor for a component field.

1278

/// Replaces the old `AzString` type names ("String", "bool", etc.) with

1279

/// a structured enum that the debugger can use for type-aware editing.

1280

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

1281

#[repr(C, u8)]

1282

pub enum ComponentFieldType {

1283

    String,

1284

    Bool,

1285

    I32,

1286

    I64,

1287

    U32,

1288

    U64,

1289

    Usize,

1290

    F32,

1291

    F64,

1292

    ColorU,

1293

    CssProperty,

1294

    ImageRef,

1295

    FontRef,

1296

    /// StyledDom slot — field name = slot name

1297

    StyledDom,

1298

    /// Callback with typed signature

1299

    Callback(ComponentCallbackSignature),

1300

    /// RefAny data binding with type hint

1301

    RefAny(AzString),

1302

    /// Optional value (recursive via Box)

1303

    OptionType(ComponentFieldTypeBox),

1304

    /// Vec of values (recursive via Box)

1305

    VecType(ComponentFieldTypeBox),

1306

    /// Reference to a struct defined in the same library

1307

    StructRef(AzString),

1308

    /// Reference to an enum defined in the same library

1309

    EnumRef(AzString),

1310

1311

1312

impl ComponentFieldType {

1313

    /// Parse a field type string like "String", "Option<Bool>", "Vec<I32>",

1314

    /// "Callback(fn(LayoutCallbackInfo) -> Dom)", "StructRef(MyStruct)" etc.

1315

    /// Returns `None` if the string cannot be parsed.

1316

    pub fn parse(s: &str) -> Option<Self> {

1317

        let s = s.trim();

1318

        match s {

1319

            "String" | "string" => return Some(ComponentFieldType::String),

1320

            "Bool" | "bool" => return Some(ComponentFieldType::Bool),

1321

            "I32" | "i32" => return Some(ComponentFieldType::I32),

1322

            "I64" | "i64" => return Some(ComponentFieldType::I64),

1323

            "U32" | "u32" => return Some(ComponentFieldType::U32),

1324

            "U64" | "u64" => return Some(ComponentFieldType::U64),

1325

            "Usize" | "usize" => return Some(ComponentFieldType::Usize),

1326

            "F32" | "f32" => return Some(ComponentFieldType::F32),

1327

            "F64" | "f64" => return Some(ComponentFieldType::F64),

1328

            "ColorU" => return Some(ComponentFieldType::ColorU),

1329

            "CssProperty" => return Some(ComponentFieldType::CssProperty),

1330

            "ImageRef" => return Some(ComponentFieldType::ImageRef),

1331

            "FontRef" => return Some(ComponentFieldType::FontRef),

1332

            "StyledDom" => return Some(ComponentFieldType::StyledDom),

1333

            "RefAny" => return Some(ComponentFieldType::RefAny(AzString::from(""))),

1334

            _ => {}

1335

1336

1337

        // Option<T>

1338

        if let Some(inner) = s.strip_prefix("Option<").and_then(|r| r.strip_suffix('>')) {

1339

            let inner_type = ComponentFieldType::parse(inner)?;

1340

            return Some(ComponentFieldType::OptionType(ComponentFieldTypeBox::new(inner_type)));

1341

1342

1343

        // Vec<T>

1344

        if let Some(inner) = s.strip_prefix("Vec<").and_then(|r| r.strip_suffix('>')) {

1345

            let inner_type = ComponentFieldType::parse(inner)?;

1346

            return Some(ComponentFieldType::VecType(ComponentFieldTypeBox::new(inner_type)));

1347

1348

1349

        // Callback(signature)

1350

        if let Some(sig) = s.strip_prefix("Callback(").and_then(|r| r.strip_suffix(')')) {

1351

            return Some(ComponentFieldType::Callback(ComponentCallbackSignature {

1352

                return_type: AzString::from(sig),

1353

                args: Vec::new().into(),

1354

            }));

1355

1356

1357

        // RefAny(TypeHint)

1358

        if let Some(hint) = s.strip_prefix("RefAny(").and_then(|r| r.strip_suffix(')')) {

1359

            return Some(ComponentFieldType::RefAny(AzString::from(hint)));

1360

1361

1362

        // EnumRef(Name) — explicit

1363

        if let Some(name) = s.strip_prefix("EnumRef(").and_then(|r| r.strip_suffix(')')) {

1364

            return Some(ComponentFieldType::EnumRef(AzString::from(name)));

1365

1366

1367

        // StructRef(Name) — explicit

1368

        if let Some(name) = s.strip_prefix("StructRef(").and_then(|r| r.strip_suffix(')')) {

1369

            return Some(ComponentFieldType::StructRef(AzString::from(name)));

1370

1371

1372

        // If starts with uppercase, treat as StructRef

1373

        if s.chars().next().map(|c| c.is_uppercase()).unwrap_or(false) {

1374

            return Some(ComponentFieldType::StructRef(AzString::from(s)));

1375

1376

1377

        None

1378

1379

1380

    /// Format this field type to its canonical string representation.

1381

    /// This is the inverse of `parse`.

1382

    pub fn format(&self) -> String {

1383

        match self {

1384

            ComponentFieldType::String => "String".to_string(),

1385

            ComponentFieldType::Bool => "Bool".to_string(),

1386

            ComponentFieldType::I32 => "I32".to_string(),

1387

            ComponentFieldType::I64 => "I64".to_string(),

1388

            ComponentFieldType::U32 => "U32".to_string(),

1389

            ComponentFieldType::U64 => "U64".to_string(),

1390

            ComponentFieldType::Usize => "Usize".to_string(),

1391

            ComponentFieldType::F32 => "F32".to_string(),

1392

            ComponentFieldType::F64 => "F64".to_string(),

1393

            ComponentFieldType::ColorU => "ColorU".to_string(),

1394

            ComponentFieldType::CssProperty => "CssProperty".to_string(),

1395

            ComponentFieldType::ImageRef => "ImageRef".to_string(),

1396

            ComponentFieldType::FontRef => "FontRef".to_string(),

1397

            ComponentFieldType::StyledDom => "StyledDom".to_string(),

1398

            ComponentFieldType::Callback(sig) => format!("Callback({})", sig.return_type.as_str()),

1399

            ComponentFieldType::RefAny(hint) => {

1400

                if hint.as_str().is_empty() {

1401

                    "RefAny".to_string()

1402

                } else {

1403

                    format!("RefAny({})", hint.as_str())

1404

1405

1406

            ComponentFieldType::OptionType(inner) => format!("Option<{}>", inner.as_ref().format()),

1407

            ComponentFieldType::VecType(inner) => format!("Vec<{}>", inner.as_ref().format()),

1408

            ComponentFieldType::StructRef(name) => name.as_str().to_string(),

1409

            ComponentFieldType::EnumRef(name) => name.as_str().to_string(),

1410

1411

1412

1413

1414

impl core::fmt::Display for ComponentFieldType {

1415

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

1416

        f.write_str(&self.format())

1417

1418

1419

1420

/// A single variant in a component enum model.

1421

#[derive(Debug, Clone, PartialEq)]

1422

#[repr(C)]

1423

pub struct ComponentEnumVariant {

1424

    /// Variant name, e.g. "Admin", "Editor", "Viewer"

1425

    pub name: AzString,

1426

    /// Human-readable description for this variant

1427

    pub description: AzString,

1428

    /// Optional associated fields for this variant

1429

    pub fields: ComponentDataFieldVec,

1430

1431

1432

impl_vec!(ComponentEnumVariant, ComponentEnumVariantVec, ComponentEnumVariantVecDestructor, ComponentEnumVariantVecDestructorType, ComponentEnumVariantVecSlice, OptionComponentEnumVariant);

1433

impl_option!(ComponentEnumVariant, OptionComponentEnumVariant, copy = false, [Debug, Clone, PartialEq]);

1434

impl_vec_debug!(ComponentEnumVariant, ComponentEnumVariantVec);

1435

impl_vec_partialeq!(ComponentEnumVariant, ComponentEnumVariantVec);

1436

impl_vec_clone!(ComponentEnumVariant, ComponentEnumVariantVec, ComponentEnumVariantVecDestructor);

1437

1438

/// A named enum model for code generation.

1439

/// Stored in `ComponentLibrary::enum_models`.

1440

#[derive(Debug, Clone, PartialEq)]

1441

#[repr(C)]

1442

pub struct ComponentEnumModel {

1443

    /// Enum name, e.g. "UserRole"

1444

    pub name: AzString,

1445

    /// Human-readable description

1446

    pub description: AzString,

1447

    /// Variants

1448

    pub variants: ComponentEnumVariantVec,

1449

1450

1451

impl_vec!(ComponentEnumModel, ComponentEnumModelVec, ComponentEnumModelVecDestructor, ComponentEnumModelVecDestructorType, ComponentEnumModelVecSlice, OptionComponentEnumModel);

1452

impl_option!(ComponentEnumModel, OptionComponentEnumModel, copy = false, [Debug, Clone, PartialEq]);

1453

impl_vec_debug!(ComponentEnumModel, ComponentEnumModelVec);

1454

impl_vec_partialeq!(ComponentEnumModel, ComponentEnumModelVec);

1455

impl_vec_clone!(ComponentEnumModel, ComponentEnumModelVec, ComponentEnumModelVecDestructor);

1456

1457

/// Default value for a component field.

1458

#[derive(Debug, Clone, PartialEq)]

1459

#[repr(C, u8)]

1460

pub enum ComponentDefaultValue {

1461

    /// No default value (field is required)

1462

    None,

1463

    /// String literal default

1464

    String(AzString),

1465

    /// Boolean default

1466

    Bool(bool),

1467

    /// i32 default

1468

    I32(i32),

1469

    /// i64 default

1470

    I64(i64),

1471

    /// u32 default

1472

    U32(u32),

1473

    /// u64 default

1474

    U64(u64),

1475

    /// usize default

1476

    Usize(usize),

1477

    /// f32 default

1478

    F32(f32),

1479

    /// f64 default

1480

    F64(f64),

1481

    /// ColorU default

1482

    ColorU(ColorU),

1483

    /// Default is an instance of another component

1484

    ComponentInstance(ComponentInstanceDefault),

1485

    /// Default callback function pointer name

1486

    CallbackFnPointer(AzString),

1487

    /// JSON string representing a complex default value

1488

    Json(AzString),

1489

1490

1491

impl_option!(ComponentDefaultValue, OptionComponentDefaultValue, copy = false, [Debug, Clone, PartialEq]);

1492

1493

/// Default component instance for a StyledDom slot.

1494

#[derive(Debug, Clone, PartialEq)]

1495

#[repr(C)]

1496

pub struct ComponentInstanceDefault {

1497

    /// Library name, e.g. "builtin"

1498

    pub library: AzString,

1499

    /// Component tag, e.g. "a"

1500

    pub component: AzString,

1501

    /// Field overrides for this instance

1502

    pub field_overrides: ComponentFieldOverrideVec,

1503

1504

1505

/// An override for a single field in a component instance.

1506

#[derive(Debug, Clone, PartialEq)]

1507

#[repr(C)]

1508

pub struct ComponentFieldOverride {

1509

    /// Field name to override

1510

    pub field_name: AzString,

1511

    /// Value source for this override

1512

    pub source: ComponentFieldValueSource,

1513

1514

1515

impl_vec!(ComponentFieldOverride, ComponentFieldOverrideVec, ComponentFieldOverrideVecDestructor, ComponentFieldOverrideVecDestructorType, ComponentFieldOverrideVecSlice, OptionComponentFieldOverride);

1516

impl_option!(ComponentFieldOverride, OptionComponentFieldOverride, copy = false, [Debug, Clone, PartialEq]);

1517

impl_vec_debug!(ComponentFieldOverride, ComponentFieldOverrideVec);

1518

impl_vec_partialeq!(ComponentFieldOverride, ComponentFieldOverrideVec);

1519

impl_vec_clone!(ComponentFieldOverride, ComponentFieldOverrideVec, ComponentFieldOverrideVecDestructor);

1520

1521

/// How a field value is sourced at the instance level.

1522

#[derive(Debug, Clone, PartialEq)]

1523

#[repr(C, u8)]

1524

pub enum ComponentFieldValueSource {

1525

    /// Use the component's default value

1526

    Default,

1527

    /// Hardcoded literal value (as string, parsed at runtime)

1528

    Literal(AzString),

1529

    /// Bound to an app state path (e.g. "app_state.user.name")

1530

    Binding(AzString),

1531

1532

1533

/// Runtime value for a component field — the "instance" counterpart

1534

/// to `ComponentFieldType` (which is the "class" / type descriptor).

1535

#[derive(Debug, Clone, PartialEq)]

1536

#[repr(C, u8)]

1537

pub enum ComponentFieldValue {

1538

    String(AzString),

1539

    Bool(bool),

1540

    I32(i32),

1541

    I64(i64),

1542

    U32(u32),

1543

    U64(u64),

1544

    Usize(usize),

1545

    F32(f32),

1546

    F64(f64),

1547

    ColorU(ColorU),

1548

    /// Option<T> with no value

1549

    None,

1550

    /// Option<T> with a value

1551

    Some(ComponentFieldValueBox),

1552

    /// Vec of values

1553

    Vec(ComponentFieldValueVec),

1554

    /// StyledDom slot content

1555

    StyledDom(StyledDom),

1556

    /// Struct fields, in order

1557

    Struct(ComponentFieldNamedValueVec),

1558

    /// Enum variant

1559

    Enum { variant: AzString, fields: ComponentFieldNamedValueVec },

1560

    /// Callback function reference (function name as string)

1561

    Callback(AzString),

1562

    /// Opaque reference-counted data

1563

    RefAny(crate::refany::RefAny),

1564

1565

1566

/// Named field value: (field_name, value) pair.

1567

#[derive(Debug, Clone, PartialEq)]

1568

#[repr(C)]

1569

pub struct ComponentFieldNamedValue {

1570

    pub name: AzString,

1571

    pub value: ComponentFieldValue,

1572

1573

1574

impl_vec!(ComponentFieldNamedValue, ComponentFieldNamedValueVec, ComponentFieldNamedValueVecDestructor, ComponentFieldNamedValueVecDestructorType, ComponentFieldNamedValueVecSlice, OptionComponentFieldNamedValue);

1575

impl_option!(ComponentFieldNamedValue, OptionComponentFieldNamedValue, copy = false, [Debug, Clone, PartialEq]);

1576

impl_vec_debug!(ComponentFieldNamedValue, ComponentFieldNamedValueVec);

1577

impl_vec_partialeq!(ComponentFieldNamedValue, ComponentFieldNamedValueVec);

1578

impl_vec_clone!(ComponentFieldNamedValue, ComponentFieldNamedValueVec, ComponentFieldNamedValueVecDestructor);

1579

1580

impl ComponentFieldNamedValueVec {

1581

    /// Look up a field by name, return a reference to its value.

1582

    pub fn get_field(&self, name: &str) -> Option<&ComponentFieldValue> {

1583

        self.as_ref().iter().find_map(|v| {

1584

            if v.name.as_str() == name { Some(&v.value) } else { None }

1585

})

1586

1587

1588

    /// Convenience: get a field as `&str` if it is `ComponentFieldValue::String`.

1589

    pub fn get_string(&self, name: &str) -> Option<&AzString> {

1590

        match self.get_field(name) {

1591

            Some(ComponentFieldValue::String(s)) => Some(s),

1592

            _ => None,

1593

1594

1595

1596

1597

impl_vec!(ComponentFieldValue, ComponentFieldValueVec, ComponentFieldValueVecDestructor, ComponentFieldValueVecDestructorType, ComponentFieldValueVecSlice, OptionComponentFieldValue);

1598

impl_option!(ComponentFieldValue, OptionComponentFieldValue, copy = false, [Debug, Clone, PartialEq]);

1599

impl_vec_debug!(ComponentFieldValue, ComponentFieldValueVec);

1600

impl_vec_partialeq!(ComponentFieldValue, ComponentFieldValueVec);

1601

impl_vec_clone!(ComponentFieldValue, ComponentFieldValueVec, ComponentFieldValueVecDestructor);

1602

1603

/// A field in the component's internal data model.

1604

#[derive(Debug, Clone, PartialEq)]

1605

#[repr(C)]

1606

pub struct ComponentDataField {

1607

    /// Field name, e.g. "counter", "text", "number"

1608

    pub name: AzString,

1609

    /// Rich type descriptor for this field

1610

    pub field_type: ComponentFieldType,

1611

    /// Typed default value, or None if the field is required

1612

    pub default_value: OptionComponentDefaultValue,

1613

    /// Whether this field is required (must be provided by the parent)

1614

    pub required: bool,

1615

    /// Human-readable description

1616

    pub description: AzString,

1617

1618

1619

impl_vec!(ComponentDataField, ComponentDataFieldVec, ComponentDataFieldVecDestructor, ComponentDataFieldVecDestructorType, ComponentDataFieldVecSlice, OptionComponentDataField);

1620

impl_option!(ComponentDataField, OptionComponentDataField, copy = false, [Debug, Clone, PartialEq]);

1621

impl_vec_debug!(ComponentDataField, ComponentDataFieldVec);

1622

impl_vec_partialeq!(ComponentDataField, ComponentDataFieldVec);

1623

impl_vec_clone!(ComponentDataField, ComponentDataFieldVec, ComponentDataFieldVecDestructor);

1624

1625

/// A named data model (struct definition) for code generation.

1626

///

1627

/// Stored in `ComponentLibrary::data_models`. Components reference these

1628

/// by name in `ComponentDataField::field_type`, enabling nested/structured

1629

/// data models. For example, a `UserCard` component might have a field

1630

/// `user: UserProfile` where `UserProfile` is a `ComponentDataModel`.

1631

#[derive(Debug, Clone)]

1632

#[repr(C)]

1633

pub struct ComponentDataModel {

1634

    /// Type name, e.g. "UserProfile", "TodoItem"

1635

    pub name: AzString,

1636

    /// Human-readable description

1637

    pub description: AzString,

1638

    /// Fields in this struct

1639

    pub fields: ComponentDataFieldVec,

1640

1641

1642

impl ComponentDataModel {

1643

    /// Look up a field by name.

1644

    pub fn get_field(&self, name: &str) -> Option<&ComponentDataField> {

1645

        self.fields.as_ref().iter().find(|f| f.name.as_str() == name)

1646

1647

1648

    /// Look up a field's default value as a string, if it exists and is a String variant.

1649

    pub fn get_default_string(&self, name: &str) -> Option<&AzString> {

1650

        self.get_field(name).and_then(|f| {

1651

            match &f.default_value {

1652

                OptionComponentDefaultValue::Some(ComponentDefaultValue::String(s)) => Some(s),

1653

                _ => None,

1654

1655

})

1656

1657

1658

    /// Clone this data model, overriding the default value for a field by name.

1659

    /// If the field is not found, the data model is returned unchanged.

1660

    pub fn with_default(mut self, name: &str, value: ComponentDefaultValue) -> Self {

1661

        let mut fields_vec = core::mem::replace(

1662

            &mut self.fields,

1663

            ComponentDataFieldVec::from_const_slice(&[]),

1664

        ).into_library_owned_vec();

1665

        for f in fields_vec.iter_mut() {

1666

            if f.name.as_str() == name {

1667

                f.default_value = OptionComponentDefaultValue::Some(value);

1668

                break;

1669

1670

1671

        self.fields = ComponentDataFieldVec::from_vec(fields_vec);

1672

        self

1673

1674

1675

1676

impl_vec!(ComponentDataModel, ComponentDataModelVec, ComponentDataModelVecDestructor, ComponentDataModelVecDestructorType, ComponentDataModelVecSlice, OptionComponentDataModel);

1677

impl_option!(ComponentDataModel, OptionComponentDataModel, copy = false, [Debug, Clone]);

1678

impl_vec_debug!(ComponentDataModel, ComponentDataModelVec);

1679

impl_vec_clone!(ComponentDataModel, ComponentDataModelVec, ComponentDataModelVecDestructor);

1680

impl_vec_mut!(ComponentDataModel, ComponentDataModelVec);

1681

1682

// ============================================================================

1683

// Serde support for ComponentDataModel (feature-gated)

1684

// ============================================================================

1685

1686

#[cfg(feature = "serde-json")]

1687

mod serde_impl {

1688

    use super::*;

1689

    use serde::{Serialize, Serializer, Deserialize, Deserializer};

1690

    use serde::ser::SerializeStruct;

1691

1692

    // --- AzString helpers ---

1693

1694

    fn ser_azstring<S: Serializer>(s: &AzString, serializer: S) -> Result<S::Ok, S::Error> {

1695

        serializer.serialize_str(s.as_str())

1696

1697

1698

    fn de_azstring<'de, D: Deserializer<'de>>(deserializer: D) -> Result<AzString, D::Error> {

1699

        let s = alloc::string::String::deserialize(deserializer)?;

1700

        Ok(AzString::from(s.as_str()))

1701

1702

1703

    // --- ComponentFieldType ---

1704

1705

    impl Serialize for ComponentFieldType {

1706

        fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {

1707

            serializer.serialize_str(&field_type_to_string(self))

1708

1709

1710

1711

    impl<'de> Deserialize<'de> for ComponentFieldType {

1712

        fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {

1713

            let s = alloc::string::String::deserialize(deserializer)?;

1714

            Ok(string_to_field_type(&s))

1715

1716

1717

1718

    fn field_type_to_string(ft: &ComponentFieldType) -> alloc::string::String {

1719

        match ft {

1720

            ComponentFieldType::String => "String".into(),

1721

            ComponentFieldType::Bool => "bool".into(),

1722

            ComponentFieldType::I32 => "i32".into(),

1723

            ComponentFieldType::I64 => "i64".into(),

1724

            ComponentFieldType::U32 => "u32".into(),

1725

            ComponentFieldType::U64 => "u64".into(),

1726

            ComponentFieldType::Usize => "usize".into(),

1727

            ComponentFieldType::F32 => "f32".into(),

1728

            ComponentFieldType::F64 => "f64".into(),

1729

            ComponentFieldType::ColorU => "ColorU".into(),

1730

            ComponentFieldType::CssProperty => "CssProperty".into(),

1731

            ComponentFieldType::ImageRef => "ImageRef".into(),

1732

            ComponentFieldType::FontRef => "FontRef".into(),

1733

            ComponentFieldType::StyledDom => "Dom".into(),

1734

            ComponentFieldType::Callback(sig) => alloc::format!(

1735

                "Callback({})",

1736

                sig.return_type.as_str()

1737

),

1738

            ComponentFieldType::RefAny(hint) => alloc::format!("RefAny({})", hint.as_str()),

1739

            ComponentFieldType::OptionType(inner) => alloc::format!(

1740

                "Option<{}>",

1741

                field_type_to_string(inner.as_ref())

1742

),

1743

            ComponentFieldType::VecType(inner) => alloc::format!(

1744

                "Vec<{}>",

1745

                field_type_to_string(inner.as_ref())

1746

),

1747

            ComponentFieldType::StructRef(name) => alloc::format!("struct:{}", name.as_str()),

1748

            ComponentFieldType::EnumRef(name) => alloc::format!("enum:{}", name.as_str()),

1749

1750

1751

1752

    fn string_to_field_type(s: &str) -> ComponentFieldType {

1753

        match s {

1754

            "String" | "string" => ComponentFieldType::String,

1755

            "bool" | "Bool" => ComponentFieldType::Bool,

1756

            "i32" | "I32" => ComponentFieldType::I32,

1757

            "i64" | "I64" => ComponentFieldType::I64,

1758

            "u32" | "U32" => ComponentFieldType::U32,

1759

            "u64" | "U64" => ComponentFieldType::U64,

1760

            "usize" | "Usize" => ComponentFieldType::Usize,

1761

            "f32" | "F32" => ComponentFieldType::F32,

1762

            "f64" | "F64" => ComponentFieldType::F64,

1763

            "ColorU" | "Color" | "color" => ComponentFieldType::ColorU,

1764

            "CssProperty" => ComponentFieldType::CssProperty,

1765

            "ImageRef" | "Image" => ComponentFieldType::ImageRef,

1766

            "FontRef" | "Font" => ComponentFieldType::FontRef,

1767

            "Dom" | "StyledDom" | "Children" => ComponentFieldType::StyledDom,

1768

            other => {

1769

                if let Some(inner) = other.strip_prefix("Option<").and_then(|s| s.strip_suffix('>')) {

1770

                    ComponentFieldType::OptionType(ComponentFieldTypeBox::new(string_to_field_type(inner)))

1771

                } else if let Some(inner) = other.strip_prefix("Vec<").and_then(|s| s.strip_suffix('>')) {

1772

                    ComponentFieldType::VecType(ComponentFieldTypeBox::new(string_to_field_type(inner)))

1773

                } else if let Some(name) = other.strip_prefix("struct:") {

1774

                    ComponentFieldType::StructRef(AzString::from(name))

1775

                } else if let Some(name) = other.strip_prefix("enum:") {

1776

                    ComponentFieldType::EnumRef(AzString::from(name))

1777

                } else if other.starts_with("Callback") {

1778

                    let ret = other.strip_prefix("Callback(")

1779

                        .and_then(|s| s.strip_suffix(')'))

1780

                        .unwrap_or("()");

1781

                    ComponentFieldType::Callback(ComponentCallbackSignature {

1782

                        return_type: AzString::from(ret),

1783

                        args: ComponentCallbackArgVec::from_const_slice(&[]),

1784

})

1785

                } else if other.starts_with("RefAny") {

1786

                    let hint = other.strip_prefix("RefAny(")

1787

                        .and_then(|s| s.strip_suffix(')'))

1788

                        .unwrap_or("");

1789

                    ComponentFieldType::RefAny(AzString::from(hint))

1790

                } else {

1791

                    ComponentFieldType::String // fallback

1792

1793

1794

1795

1796

1797

    // --- ComponentDefaultValue ---

1798

1799

    impl Serialize for ComponentDefaultValue {

1800

        fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {

1801

            use serde::ser::SerializeMap;

1802

            match self {

1803

                ComponentDefaultValue::None => serializer.serialize_none(),

1804

                ComponentDefaultValue::String(s) => serializer.serialize_str(s.as_str()),

1805

                ComponentDefaultValue::Bool(b) => serializer.serialize_bool(*b),

1806

                ComponentDefaultValue::I32(v) => serializer.serialize_i32(*v),

1807

                ComponentDefaultValue::I64(v) => serializer.serialize_i64(*v),

1808

                ComponentDefaultValue::U32(v) => serializer.serialize_u32(*v),

1809

                ComponentDefaultValue::U64(v) => serializer.serialize_u64(*v),

1810

                ComponentDefaultValue::Usize(v) => serializer.serialize_u64(*v as u64),

1811

                ComponentDefaultValue::F32(v) => serializer.serialize_f32(*v),

1812

                ComponentDefaultValue::F64(v) => serializer.serialize_f64(*v),

1813

                ComponentDefaultValue::ColorU(c) => {

1814

                    serializer.serialize_str(&alloc::format!("#{:02x}{:02x}{:02x}{:02x}", c.r, c.g, c.b, c.a))

1815

1816

                ComponentDefaultValue::ComponentInstance(ci) => {

1817

                    let mut map = serializer.serialize_map(Some(2))?;

1818

                    map.serialize_entry("library", ci.library.as_str())?;

1819

                    map.serialize_entry("component", ci.component.as_str())?;

1820

                    map.end()

1821

1822

                ComponentDefaultValue::CallbackFnPointer(name) => {

1823

                    serializer.serialize_str(name.as_str())

1824

1825

                ComponentDefaultValue::Json(json_str) => {

1826

                    // Serialize raw JSON string as-is by parsing and re-emitting

1827

                    match serde_json::from_str::<serde_json::Value>(json_str.as_str()) {

1828

                        Ok(v) => v.serialize(serializer),

1829

                        Err(_) => serializer.serialize_str(json_str.as_str()),

1830

1831

1832

1833

1834

1835

1836

    impl<'de> Deserialize<'de> for ComponentDefaultValue {

1837

        fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {

1838

            let val = serde_json::Value::deserialize(deserializer)?;

1839

            Ok(match val {

1840

                serde_json::Value::Null => ComponentDefaultValue::None,

1841

                serde_json::Value::Bool(b) => ComponentDefaultValue::Bool(b),

1842

                serde_json::Value::Number(n) => {

1843

                    if let Some(i) = n.as_i64() {

1844

                        if let Ok(v) = i32::try_from(i) {

1845

                            ComponentDefaultValue::I32(v)

1846

                        } else {

1847

                            ComponentDefaultValue::I64(i)

1848

1849

                    } else if let Some(f) = n.as_f64() {

1850

                        ComponentDefaultValue::F64(f)

1851

                    } else {

1852

                        ComponentDefaultValue::None

1853

1854

1855

                serde_json::Value::String(s) => {

1856

                    ComponentDefaultValue::String(AzString::from(s.as_str()))

1857

1858

                _ => ComponentDefaultValue::None,

1859

})

1860

1861

1862

1863

    // --- OptionComponentDefaultValue ---

1864

1865

    impl Serialize for OptionComponentDefaultValue {

1866

        fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {

1867

            match self {

1868

                OptionComponentDefaultValue::Some(v) => v.serialize(serializer),

1869

                OptionComponentDefaultValue::None => serializer.serialize_none(),

1870

1871

1872

1873

1874

    impl<'de> Deserialize<'de> for OptionComponentDefaultValue {

1875

        fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {

1876

            let val = Option::<ComponentDefaultValue>::deserialize(deserializer)?;

1877

            Ok(match val {

1878

                Some(v) => OptionComponentDefaultValue::Some(v),

1879

                None => OptionComponentDefaultValue::None,

1880

})

1881

1882

1883

1884

    // --- ComponentDataField ---

1885

1886

    impl Serialize for ComponentDataField {

1887

        fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {

1888

            let mut s = serializer.serialize_struct("ComponentDataField", 5)?;

1889

            s.serialize_field("name", self.name.as_str())?;

1890

            s.serialize_field("type", &self.field_type)?;

1891

            s.serialize_field("default", &self.default_value)?;

1892

            s.serialize_field("required", &self.required)?;

1893

            s.serialize_field("description", self.description.as_str())?;

1894

            s.end()

1895

1896

1897

1898

    impl<'de> Deserialize<'de> for ComponentDataField {

1899

        fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {

1900

            #[derive(Deserialize)]

1901

            struct Helper {

1902

                name: alloc::string::String,

1903

                #[serde(rename = "type", default = "default_type")]

1904

                field_type: ComponentFieldType,

1905

                #[serde(default)]

1906

                default: OptionComponentDefaultValue,

1907

                #[serde(default)]

1908

                required: bool,

1909

                #[serde(default)]

1910

                description: alloc::string::String,

1911

1912

            fn default_type() -> ComponentFieldType { ComponentFieldType::String }

1913

1914

            let h = Helper::deserialize(deserializer)?;

1915

            Ok(ComponentDataField {

1916

                name: AzString::from(h.name.as_str()),

1917

                field_type: h.field_type,

1918

                default_value: h.default,

1919

                required: h.required,

1920

                description: AzString::from(h.description.as_str()),

1921

})

1922

1923

1924

1925

    // --- ComponentDataModel ---

1926

1927

    impl Serialize for ComponentDataModel {

1928

        fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {

1929

            let mut s = serializer.serialize_struct("ComponentDataModel", 3)?;

1930

            s.serialize_field("name", self.name.as_str())?;

1931

            s.serialize_field("description", self.description.as_str())?;

1932

            let fields: alloc::vec::Vec<&ComponentDataField> = self.fields.as_ref().iter().collect();

1933

            s.serialize_field("fields", &fields)?;

1934

            s.end()

1935

1936

1937

1938

    impl<'de> Deserialize<'de> for ComponentDataModel {

1939

        fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {

1940

            #[derive(Deserialize)]

1941

            struct Helper {

1942

                #[serde(default)]

1943

                name: alloc::string::String,

1944

                #[serde(default)]

1945

                description: alloc::string::String,

1946

                #[serde(default)]

1947

                fields: alloc::vec::Vec<ComponentDataField>,

1948

1949

1950

            let h = Helper::deserialize(deserializer)?;

1951

            Ok(ComponentDataModel {

1952

                name: AzString::from(h.name.as_str()),

1953

                description: AzString::from(h.description.as_str()),

1954

                fields: ComponentDataFieldVec::from_vec(h.fields),

1955

})

1956

1957

1958

1959

1960

// Re-export serde impls so they're visible when the feature is enabled

1961

#[cfg(feature = "serde-json")]

1962

pub use serde_impl::*;

1963

1964

#[cfg(feature = "serde-json")]

1965

impl ComponentDataModel {

1966

    /// Serialize this data model to a JSON string.

1967

    pub fn to_json(&self) -> Result<alloc::string::String, alloc::string::String> {

1968

        serde_json::to_string_pretty(self).map_err(|e| alloc::format!("{}", e))

1969

1970

1971

    /// Deserialize a data model from a JSON string.

1972

    pub fn from_json(json: &str) -> Result<Self, alloc::string::String> {

1973

        serde_json::from_str(json).map_err(|e| alloc::format!("{}", e))

1974

1975

1976

1977

/// Source of a component definition — determines whether it can be exported

1978

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]

1979

#[repr(C)]

1980

pub enum ComponentSource {

1981

    /// Built into the DLL (HTML elements). Never exported.

1982

    Builtin,

1983

    /// Compiled Rust widget (Button, TextInput, etc.). Never exported.

1984

    Compiled,

1985

    /// Defined via JSON/XML at runtime. Can be exported.

1986

    UserDefined,

1987

1988

1989

impl Default for ComponentSource {

1990

    fn default() -> Self {

1991

        ComponentSource::UserDefined

1992

1993

1994

1995

impl ComponentSource {

1996

    pub fn create() -> Self {

1997

        Self::default()

1998

1999

2000

2001

/// The target language for code compilation

2002

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

2003

#[repr(C)]

2004

pub enum CompileTarget {

2005

    Rust,

2006

C,

2007

    Cpp,

2008

    Python,

2009

2010

2011

impl_result!(

2012

    StyledDom,

2013

    RenderDomError,

2014

    ResultStyledDomRenderDomError,

2015

    copy = false,

2016

    [Debug, Clone, PartialEq]

2017

);

2018

2019

impl_result!(

2020

    AzString,

2021

    CompileError,

2022

    ResultStringCompileError,

2023

    copy = false,

2024

    [Debug, Clone, PartialEq]

2025

);

2026

2027

/// Render function type: takes component definition + data model (with current values

2028

/// in `default_value` fields) + component map for recursive sub-component instantiation,

2029

/// returns StyledDom.

2030

///

2031

/// The `data` parameter is typically `def.data_model` cloned and with caller-provided

2032

/// values substituted into the `default_value` fields.

2033

pub type ComponentRenderFn = fn(

2034

    &ComponentDef,

2035

    &ComponentDataModel,

2036

    &ComponentMap,

2037

) -> ResultStyledDomRenderDomError;

2038

2039

/// Compile function type: takes component definition + target language + data model, returns source code.

2040

pub type ComponentCompileFn = fn(

2041

    &ComponentDef,

2042

    &CompileTarget,

2043

    &ComponentDataModel,

2044

    indent: usize,

2045

) -> ResultStringCompileError;

2046

2047

/// Raw function pointer type that returns a single ComponentDef when called.

2048

/// Used as the `cb` field in `RegisterComponentFn`.

2049

pub type RegisterComponentFnType = extern "C" fn() -> ComponentDef;

2050

2051

/// Callback struct for registering individual components at startup.

2052

///

2053

/// In C: pass a bare `extern "C" fn() -> ComponentDef` function pointer —

2054

/// it converts automatically via `From<RegisterComponentFnType>`.

2055

///

2056

/// In Python: construct this struct with `cb` set to a trampoline and

2057

/// `ctx` set to `Some(RefAny(...))` wrapping the Python callable.

2058

#[repr(C)]

2059

pub struct RegisterComponentFn {

2060

    pub cb: RegisterComponentFnType,

2061

    /// For FFI: stores the foreign callable (e.g., PyFunction).

2062

    /// Native Rust/C code sets this to None.

2063

    pub ctx: crate::refany::OptionRefAny,

2064

2065

2066

impl_callback!(RegisterComponentFn, RegisterComponentFnType);

2067

2068

/// Raw function pointer type that returns a complete ComponentLibrary when called.

2069

/// Used as the `cb` field in `RegisterComponentLibraryFn`.

2070

pub type RegisterComponentLibraryFnType = extern "C" fn() -> ComponentLibrary;

2071

2072

/// Callback struct for registering entire component libraries at startup.

2073

///

2074

/// In C: pass a bare `extern "C" fn() -> ComponentLibrary` function pointer —

2075

/// it converts automatically via `From<RegisterComponentLibraryFnType>`.

2076

///

2077

/// In Python: construct this struct with `cb` set to a trampoline and

2078

/// `ctx` set to `Some(RefAny(...))` wrapping the Python callable.

2079

#[repr(C)]

2080

pub struct RegisterComponentLibraryFn {

2081

    pub cb: RegisterComponentLibraryFnType,

2082

    /// For FFI: stores the foreign callable (e.g., PyFunction).

2083

    /// Native Rust/C code sets this to None.

2084

    pub ctx: crate::refany::OptionRefAny,

2085

2086

2087

impl_callback!(RegisterComponentLibraryFn, RegisterComponentLibraryFnType);

2088

2089

/// A component definition — the "class" / "template" of a component.

2090

/// Can come from Rust builtins, compiled widgets, JSON, or user creation in debugger.

2091

///

2092

#[derive(Clone)]

2093

#[repr(C)]

2094

pub struct ComponentDef {

2095

    /// Collection + name, e.g. builtin:div, shadcn:avatar

2096

    pub id: ComponentId,

2097

    /// Human-readable display name, e.g. "Link" for builtin:a, "Avatar" for shadcn:avatar

2098

    pub display_name: AzString,

2099

    /// Markdown documentation for the component

2100

    pub description: AzString,

2101

    /// The component's CSS

2102

    pub css: AzString,

2103

    /// Where this component was defined (determines exportability)

2104

    pub source: ComponentSource,

2105

    /// Unified data model: all value fields, callback slots, and child slots

2106

    /// in a single named struct. Code gen uses `data_model.name` as the

2107

    /// input struct type name (e.g. "ButtonData").

2108

    /// The `default_value` on each field doubles as the "current value" for

2109

    /// preview rendering — callers override defaults before calling `render_fn`.

2110

    pub data_model: ComponentDataModel,

2111

    /// Render to live DOM

2112

    pub render_fn: ComponentRenderFn,

2113

    /// Compile to source code in target language

2114

    pub compile_fn: ComponentCompileFn,

2115

    /// Source code for render_fn (user-defined components only)

2116

    pub render_fn_source: OptionString,

2117

    /// Source code for compile_fn (user-defined components only)

2118

    pub compile_fn_source: OptionString,

2119

2120

2121

impl fmt::Debug for ComponentDef {

2122

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

2123

        f.debug_struct("ComponentDef")

2124

            .field("id", &self.id)

2125

            .field("display_name", &self.display_name)

2126

            .field("source", &self.source)

2127

            .field("data_model", &self.data_model.name)

2128

            .finish()

2129

2130

2131

2132

impl_vec!(ComponentDef, ComponentDefVec, ComponentDefVecDestructor, ComponentDefVecDestructorType, ComponentDefVecSlice, OptionComponentDef);

2133

impl_option!(ComponentDef, OptionComponentDef, copy = false, [Clone]);

2134

impl_vec_debug!(ComponentDef, ComponentDefVec);

2135

impl_vec_clone!(ComponentDef, ComponentDefVec, ComponentDefVecDestructor);

2136

impl_vec_mut!(ComponentDef, ComponentDefVec);

2137

2138

/// A named collection of component definitions

2139

#[derive(Debug, Clone)]

2140

#[repr(C)]

2141

pub struct ComponentLibrary {

2142

    /// Library identifier, e.g. "builtin", "shadcn", "myproject"

2143

    pub name: AzString,

2144

    /// Version string

2145

    pub version: AzString,

2146

    /// Human-readable description

2147

    pub description: AzString,

2148

    /// The components in this library

2149

    pub components: ComponentDefVec,

2150

    /// Whether this library can be exported (false for builtin/compiled)

2151

    pub exportable: bool,

2152

    /// Whether this library can be modified by the user (add/remove/edit components).

2153

    /// False for builtin and compiled libraries. True for user-created libraries.

2154

    pub modifiable: bool,

2155

    /// Named data model types defined by this library.

2156

    /// Components reference these by name in their `field_type`.

2157

    pub data_models: ComponentDataModelVec,

2158

    /// Named enum types defined by this library.

2159

    /// Components reference these via `ComponentFieldType::EnumRef(name)`.

2160

    pub enum_models: ComponentEnumModelVec,

2161

2162

2163

impl_vec!(ComponentLibrary, ComponentLibraryVec, ComponentLibraryVecDestructor, ComponentLibraryVecDestructorType, ComponentLibraryVecSlice, OptionComponentLibrary);

2164

impl_option!(ComponentLibrary, OptionComponentLibrary, copy = false, [Debug, Clone]);

2165

impl_vec_debug!(ComponentLibrary, ComponentLibraryVec);

2166

impl_vec_clone!(ComponentLibrary, ComponentLibraryVec, ComponentLibraryVecDestructor);

2167

impl_vec_mut!(ComponentLibrary, ComponentLibraryVec);

2168

2169

/// The component map — holds libraries with namespaced components.

2170

#[derive(Debug, Clone)]

2171

#[repr(C)]

2172

pub struct ComponentMap {

2173

    /// Libraries indexed by name. "builtin" is always present.

2174

    pub libraries: ComponentLibraryVec,

2175

2176

2177

impl ComponentMap {

2178

    /// Qualified lookup: "shadcn:avatar" -> finds library "shadcn", component "avatar"

2179

    pub fn get(&self, collection: &str, name: &str) -> Option<&ComponentDef> {

2180

        self.libraries

2181

            .iter()

2182

            .find(|lib| lib.name.as_str() == collection)

2183

            .and_then(|lib| lib.components.iter().find(|c| c.id.name.as_str() == name))

2184

2185

2186

    /// Unqualified lookup: "div" -> searches ONLY the "builtin" library.

2187

    pub fn get_unqualified(&self, name: &str) -> Option<&ComponentDef> {

2188

        self.get("builtin", name)

2189

2190

2191

    /// Parse a "collection:name" string into a lookup

2192

    pub fn get_by_qualified_name(&self, qualified: &str) -> Option<&ComponentDef> {

2193

        if let Some((collection, name)) = qualified.split_once(':') {

2194

            self.get(collection, name)

2195

        } else {

2196

            self.get_unqualified(qualified)

2197

2198

2199

2200

    /// Get all libraries that can be exported (user-defined only)

2201

    pub fn get_exportable_libraries(&self) -> Vec<&ComponentLibrary> {

2202

        self.libraries.iter().filter(|lib| lib.exportable).collect()

2203

2204

2205

    /// Get all component definitions across all libraries

2206

    pub fn all_components(&self) -> Vec<&ComponentDef> {

2207

        self.libraries.iter().flat_map(|lib| lib.components.iter()).collect()

2208

2209

2210

2211

2212

// ============================================================================

2213

// Builtin component bridge — wraps existing render/compile into ComponentDef

2214

// ============================================================================

2215

2216

/// Map a builtin tag name to its corresponding `NodeType`.

2217

/// Falls back to `NodeType::Div` for unknown tags.

2218

10292

pub fn tag_to_node_type(tag: &str) -> NodeType {

2219

10292

    match tag {

2220

        // Document structure

2221

10292

        "html" => NodeType::Html,

2222

10292

        "head" => NodeType::Head,

2223

10292

        "title" => NodeType::Title,

2224

10292

        "body" => NodeType::Body,

2225

        // Block-level

2226

7142

        "div" => NodeType::Div,

2227

2816

        "header" => NodeType::Header,

2228

2816

        "footer" => NodeType::Footer,

2229

2816

        "section" => NodeType::Section,

2230

2816

        "article" => NodeType::Article,

2231

2816

        "aside" => NodeType::Aside,

2232

2816

        "nav" => NodeType::Nav,

2233

2816

        "main" => NodeType::Main,

2234

2816

        "figure" => NodeType::Figure,

2235

2816

        "figcaption" => NodeType::FigCaption,

2236

2816

        "address" => NodeType::Address,

2237

2816

        "details" => NodeType::Details,

2238

2816

        "summary" => NodeType::Summary,

2239

2816

        "dialog" => NodeType::Dialog,

2240

        // Headings

2241

2816

        "h1" => NodeType::H1,

2242

2816

        "h2" => NodeType::H2,

2243

2816

        "h3" => NodeType::H3,

2244

2816

        "h4" => NodeType::H4,

2245

2816

        "h5" => NodeType::H5,

2246

2816

        "h6" => NodeType::H6,

2247

        // Text content

2248

2816

        "p" => NodeType::P,

2249

2102

        "span" => NodeType::Span,

2250

1976

        "pre" => NodeType::Pre,

2251

1850

        "code" => NodeType::Code,

2252

1850

        "blockquote" => NodeType::BlockQuote,

2253

1850

        "br" => NodeType::Br,

2254

1808

        "hr" => NodeType::Hr,

2255

        // Lists

2256

1808

        "ul" => NodeType::Ul,

2257

1808

        "ol" => NodeType::Ol,

2258

1808

        "li" => NodeType::Li,

2259

1808

        "dl" => NodeType::Dl,

2260

1808

        "dt" => NodeType::Dt,

2261

1808

        "dd" => NodeType::Dd,

2262

1808

        "menu" => NodeType::Menu,

2263

1808

        "menuitem" => NodeType::MenuItem,

2264

1808

        "dir" => NodeType::Dir,

2265

        // Tables

2266

1808

        "table" => NodeType::Table,

2267

1808

        "caption" => NodeType::Caption,

2268

1808

        "thead" => NodeType::THead,

2269

1808

        "tbody" => NodeType::TBody,

2270

1808

        "tfoot" => NodeType::TFoot,

2271

1808

        "tr" => NodeType::Tr,

2272

1808

        "th" => NodeType::Th,

2273

1808

        "td" => NodeType::Td,

2274

1808

        "colgroup" => NodeType::ColGroup,

2275

1808

        "col" => NodeType::Col,

2276

        // Forms

2277

1808

        "form" => NodeType::Form,

2278

1808

        "fieldset" => NodeType::FieldSet,

2279

1808

        "legend" => NodeType::Legend,

2280

1808

        "label" => NodeType::Label,

2281

1808

        "input" => NodeType::Input,

2282

1808

        "button" => NodeType::Button,

2283

1808

        "select" => NodeType::Select,

2284

1808

        "optgroup" => NodeType::OptGroup,

2285

1808

        "option" => NodeType::SelectOption,

2286

1808

        "textarea" => NodeType::TextArea,

2287

1808

        "output" => NodeType::Output,

2288

1808

        "progress" => NodeType::Progress,

2289

1808

        "meter" => NodeType::Meter,

2290

1808

        "datalist" => NodeType::DataList,

2291

        // Inline

2292

1808

        "a" => NodeType::A,

2293

1808

        "strong" => NodeType::Strong,

2294

1808

        "em" => NodeType::Em,

2295

1808

        "b" => NodeType::B,

2296

1808

        "i" => NodeType::I,

2297

1808

        "u" => NodeType::U,

2298

1808

        "s" => NodeType::S,

2299

1808

        "small" => NodeType::Small,

2300

1808

        "mark" => NodeType::Mark,

2301

1808

        "del" => NodeType::Del,

2302

1808

        "ins" => NodeType::Ins,

2303

1808

        "samp" => NodeType::Samp,

2304

1808

        "kbd" => NodeType::Kbd,

2305

1808

        "var" => NodeType::Var,

2306

1808

        "cite" => NodeType::Cite,

2307

1808

        "dfn" => NodeType::Dfn,

2308

1808

        "abbr" => NodeType::Abbr,

2309

1808

        "acronym" => NodeType::Acronym,

2310

1808

        "q" => NodeType::Q,

2311

1808

        "time" => NodeType::Time,

2312

1808

        "sub" => NodeType::Sub,

2313

1808

        "sup" => NodeType::Sup,

2314

1808

        "big" => NodeType::Big,

2315

1808

        "bdo" => NodeType::Bdo,

2316

1808

        "bdi" => NodeType::Bdi,

2317

1808

        "wbr" => NodeType::Wbr,

2318

1808

        "ruby" => NodeType::Ruby,

2319

1808

        "rt" => NodeType::Rt,

2320

1808

        "rtc" => NodeType::Rtc,

2321

1808

        "rp" => NodeType::Rp,

2322

1808

        "data" => NodeType::Data,

2323

        // Embedded content

2324

        // `<img>` becomes a replaced `NodeType::Image`. The `src` attribute is not

2325

        // available here, so a placeholder `NullImage` (0x0, empty tag) is created;

2326

        // `xml_node_to_dom_fast` overrides it with a `NullImage` whose `tag` carries

2327

        // the `src` bytes so a renderer (e.g. printpdf) can resolve the actual image.

2328

1808

        "img" => NodeType::Image(azul_css::css::BoxOrStatic::heap(

2329

2

            crate::resources::ImageRef::null_image(

2330

2

0,

2331

2

0,

2332

2

                crate::resources::RawImageFormat::RGBA8,

2333

2

                alloc::vec::Vec::new(),

2334

2

),

2335

2

)),

2336

1806

        "canvas" => NodeType::Canvas,

2337

1806

        "object" => NodeType::Object,

2338

1806

        "param" => NodeType::Param,

2339

1806

        "embed" => NodeType::Embed,

2340

1806

        "audio" => NodeType::Audio,

2341

1806

        "video" => NodeType::Video,

2342

1806

        "source" => NodeType::Source,

2343

1806

        "track" => NodeType::Track,

2344

1806

        "map" => NodeType::Map,

2345

1806

        "area" => NodeType::Area,

2346

        // SVG elements

2347

1806

        "svg" => NodeType::Svg,

2348

1008

        "g" => NodeType::SvgG,

2349

924

        "defs" => NodeType::SvgDefs,

2350

924

        "symbol" => NodeType::SvgSymbol,

2351

924

        "use" => NodeType::SvgUse,

2352

924

        "switch" => NodeType::SvgSwitch,

2353

924

        "path" => NodeType::SvgPath,

2354

714

        "circle" => NodeType::SvgCircle,

2355

504

        "rect" => NodeType::SvgRect,

2356

252

        "ellipse" => NodeType::SvgEllipse,

2357

168

        "line" => NodeType::SvgLine,

2358

126

        "polygon" => NodeType::SvgPolygon,

2359

42

        "polyline" => NodeType::SvgPolyline,

2360

        "tspan" => NodeType::SvgTspan,

2361

        "textpath" => NodeType::SvgTextPath,

2362

        "lineargradient" => NodeType::SvgLinearGradient,

2363

        "radialgradient" => NodeType::SvgRadialGradient,

2364

        "stop" => NodeType::SvgStop,

2365

        "pattern" => NodeType::SvgPattern,

2366

        "clippath" => NodeType::SvgClipPathElement,

2367

        "mask" => NodeType::SvgMask,

2368

        "filter" => NodeType::SvgFilter,

2369

        "feblend" => NodeType::SvgFeBlend,

2370

        "fecolormatrix" => NodeType::SvgFeColorMatrix,

2371

        "fecomponenttransfer" => NodeType::SvgFeComponentTransfer,

2372

        "fecomposite" => NodeType::SvgFeComposite,

2373

        "feconvolvematrix" => NodeType::SvgFeConvolveMatrix,

2374

        "fediffuselighting" => NodeType::SvgFeDiffuseLighting,

2375

        "fedisplacementmap" => NodeType::SvgFeDisplacementMap,

2376

        "fedistantlight" => NodeType::SvgFeDistantLight,

2377

        "fedropshadow" => NodeType::SvgFeDropShadow,

2378

        "feflood" => NodeType::SvgFeFlood,

2379

        "fefuncr" => NodeType::SvgFeFuncR,

2380

        "fefuncg" => NodeType::SvgFeFuncG,

2381

        "fefuncb" => NodeType::SvgFeFuncB,

2382

        "fefunca" => NodeType::SvgFeFuncA,

2383

        "fegaussianblur" => NodeType::SvgFeGaussianBlur,

2384

        "feimage" => NodeType::SvgFeImage,

2385

        "femerge" => NodeType::SvgFeMerge,

2386

        "femergenode" => NodeType::SvgFeMergeNode,

2387

        "femorphology" => NodeType::SvgFeMorphology,

2388

        "feoffset" => NodeType::SvgFeOffset,

2389

        "fepointlight" => NodeType::SvgFePointLight,

2390

        "fespecularlighting" => NodeType::SvgFeSpecularLighting,

2391

        "fespotlight" => NodeType::SvgFeSpotLight,

2392

        "fetile" => NodeType::SvgFeTile,

2393

        "feturbulence" => NodeType::SvgFeTurbulence,

2394

        "foreignobject" => NodeType::SvgForeignObject,

2395

        "desc" => NodeType::SvgDesc,

2396

        "view" => NodeType::SvgView,

2397

        "animate" => NodeType::SvgAnimate,

2398

        "animatemotion" => NodeType::SvgAnimateMotion,

2399

        "animatetransform" => NodeType::SvgAnimateTransform,

2400

        "set" => NodeType::SvgSet,

2401

        "mpath" => NodeType::SvgMpath,

2402

        // Metadata

2403

        "meta" => NodeType::Meta,

2404

        "link" => NodeType::Link,

2405

        "script" => NodeType::Script,

2406

        "style" => NodeType::Style,

2407

        "base" => NodeType::Base,

2408

        _ => NodeType::Div,

2409

2410

10292

2411

2412

/// Map a tag name to its CSS `NodeTypeTag` for CSS matching in the compile pipeline.

2413

/// Falls back to `NodeTypeTag::Div` for unknown tags.

2414

fn tag_to_node_type_tag(tag: &str) -> NodeTypeTag {

2415

    match tag {

2416

        // Document structure

2417

        "html" => NodeTypeTag::Html,

2418

        "head" => NodeTypeTag::Head,

2419

        "title" => NodeTypeTag::Title,

2420

        "body" => NodeTypeTag::Body,

2421

        // Block-level

2422

        "div" => NodeTypeTag::Div,

2423

        "header" => NodeTypeTag::Header,

2424

        "footer" => NodeTypeTag::Footer,

2425

        "section" => NodeTypeTag::Section,

2426

        "article" => NodeTypeTag::Article,

2427

        "aside" => NodeTypeTag::Aside,

2428

        "nav" => NodeTypeTag::Nav,

2429

        "main" => NodeTypeTag::Main,

2430

        "figure" => NodeTypeTag::Figure,

2431

        "figcaption" => NodeTypeTag::FigCaption,

2432

        "address" => NodeTypeTag::Address,

2433

        "details" => NodeTypeTag::Details,

2434

        "summary" => NodeTypeTag::Summary,

2435

        "dialog" => NodeTypeTag::Dialog,

2436

        // Headings

2437

        "h1" => NodeTypeTag::H1,

2438

        "h2" => NodeTypeTag::H2,

2439

        "h3" => NodeTypeTag::H3,

2440

        "h4" => NodeTypeTag::H4,

2441

        "h5" => NodeTypeTag::H5,

2442

        "h6" => NodeTypeTag::H6,

2443

        // Text content

2444

        "p" => NodeTypeTag::P,

2445

        "span" => NodeTypeTag::Span,

2446

        "pre" => NodeTypeTag::Pre,

2447

        "code" => NodeTypeTag::Code,

2448

        "blockquote" => NodeTypeTag::BlockQuote,

2449

        "br" => NodeTypeTag::Br,

2450

        "hr" => NodeTypeTag::Hr,

2451

        // Lists

2452

        "ul" => NodeTypeTag::Ul,

2453

        "ol" => NodeTypeTag::Ol,

2454

        "li" => NodeTypeTag::Li,

2455

        "dl" => NodeTypeTag::Dl,

2456

        "dt" => NodeTypeTag::Dt,

2457

        "dd" => NodeTypeTag::Dd,

2458

        "menu" => NodeTypeTag::Menu,

2459

        "menuitem" => NodeTypeTag::MenuItem,

2460

        "dir" => NodeTypeTag::Dir,

2461

        // Tables

2462

        "table" => NodeTypeTag::Table,

2463

        "caption" => NodeTypeTag::Caption,

2464

        "thead" => NodeTypeTag::THead,

2465

        "tbody" => NodeTypeTag::TBody,

2466

        "tfoot" => NodeTypeTag::TFoot,

2467

        "tr" => NodeTypeTag::Tr,

2468

        "th" => NodeTypeTag::Th,

2469

        "td" => NodeTypeTag::Td,

2470

        "colgroup" => NodeTypeTag::ColGroup,

2471

        "col" => NodeTypeTag::Col,

2472

        // Forms

2473

        "form" => NodeTypeTag::Form,

2474

        "fieldset" => NodeTypeTag::FieldSet,

2475

        "legend" => NodeTypeTag::Legend,

2476

        "label" => NodeTypeTag::Label,

2477

        "input" => NodeTypeTag::Input,

2478

        "button" => NodeTypeTag::Button,

2479

        "select" => NodeTypeTag::Select,

2480

        "optgroup" => NodeTypeTag::OptGroup,

2481

        "option" => NodeTypeTag::SelectOption,

2482

        "textarea" => NodeTypeTag::TextArea,

2483

        "output" => NodeTypeTag::Output,

2484

        "progress" => NodeTypeTag::Progress,

2485

        "meter" => NodeTypeTag::Meter,

2486

        "datalist" => NodeTypeTag::DataList,

2487

        // Inline

2488

        "a" => NodeTypeTag::A,

2489

        "strong" => NodeTypeTag::Strong,

2490

        "em" => NodeTypeTag::Em,

2491

        "b" => NodeTypeTag::B,

2492

        "i" => NodeTypeTag::I,

2493

        "u" => NodeTypeTag::U,

2494

        "s" => NodeTypeTag::S,

2495

        "small" => NodeTypeTag::Small,

2496

        "mark" => NodeTypeTag::Mark,

2497

        "del" => NodeTypeTag::Del,

2498

        "ins" => NodeTypeTag::Ins,

2499

        "samp" => NodeTypeTag::Samp,

2500

        "kbd" => NodeTypeTag::Kbd,

2501

        "var" => NodeTypeTag::Var,

2502

        "cite" => NodeTypeTag::Cite,

2503

        "dfn" => NodeTypeTag::Dfn,

2504

        "abbr" => NodeTypeTag::Abbr,

2505

        "acronym" => NodeTypeTag::Acronym,

2506

        "q" => NodeTypeTag::Q,

2507

        "time" => NodeTypeTag::Time,

2508

        "sub" => NodeTypeTag::Sub,

2509

        "sup" => NodeTypeTag::Sup,

2510

        "big" => NodeTypeTag::Big,

2511

        "bdo" => NodeTypeTag::Bdo,

2512

        "bdi" => NodeTypeTag::Bdi,

2513

        "wbr" => NodeTypeTag::Wbr,

2514

        "ruby" => NodeTypeTag::Ruby,

2515

        "rt" => NodeTypeTag::Rt,

2516

        "rtc" => NodeTypeTag::Rtc,

2517

        "rp" => NodeTypeTag::Rp,

2518

        "data" => NodeTypeTag::Data,

2519

        // Embedded content

2520

        "canvas" => NodeTypeTag::Canvas,

2521

        "object" => NodeTypeTag::Object,

2522

        "param" => NodeTypeTag::Param,

2523

        "embed" => NodeTypeTag::Embed,

2524

        "audio" => NodeTypeTag::Audio,

2525

        "video" => NodeTypeTag::Video,

2526

        "source" => NodeTypeTag::Source,

2527

        "track" => NodeTypeTag::Track,

2528

        "map" => NodeTypeTag::Map,

2529

        "area" => NodeTypeTag::Area,

2530

        "svg" => NodeTypeTag::Svg,

2531

        "g" => NodeTypeTag::SvgG,

2532

        "defs" => NodeTypeTag::SvgDefs,

2533

        "symbol" => NodeTypeTag::SvgSymbol,

2534

        "use" => NodeTypeTag::SvgUse,

2535

        "switch" => NodeTypeTag::SvgSwitch,

2536

        "path" => NodeTypeTag::SvgPath,

2537

        "circle" => NodeTypeTag::SvgCircle,

2538

        "rect" => NodeTypeTag::SvgRect,

2539

        "ellipse" => NodeTypeTag::SvgEllipse,

2540

        "line" => NodeTypeTag::SvgLine,

2541

        "polygon" => NodeTypeTag::SvgPolygon,

2542

        "polyline" => NodeTypeTag::SvgPolyline,

2543

        "tspan" => NodeTypeTag::SvgTspan,

2544

        "textpath" => NodeTypeTag::SvgTextPath,

2545

        "lineargradient" => NodeTypeTag::SvgLinearGradient,

2546

        "radialgradient" => NodeTypeTag::SvgRadialGradient,

2547

        "stop" => NodeTypeTag::SvgStop,

2548

        "pattern" => NodeTypeTag::SvgPattern,

2549

        "clippath" => NodeTypeTag::SvgClipPathElement,

2550

        "mask" => NodeTypeTag::SvgMask,

2551

        "filter" => NodeTypeTag::SvgFilter,

2552

        "feblend" => NodeTypeTag::SvgFeBlend,

2553

        "fecolormatrix" => NodeTypeTag::SvgFeColorMatrix,

2554

        "fecomponenttransfer" => NodeTypeTag::SvgFeComponentTransfer,

2555

        "fecomposite" => NodeTypeTag::SvgFeComposite,

2556

        "feconvolvematrix" => NodeTypeTag::SvgFeConvolveMatrix,

2557

        "fediffuselighting" => NodeTypeTag::SvgFeDiffuseLighting,

2558

        "fedisplacementmap" => NodeTypeTag::SvgFeDisplacementMap,

2559

        "fedistantlight" => NodeTypeTag::SvgFeDistantLight,

2560

        "fedropshadow" => NodeTypeTag::SvgFeDropShadow,

2561

        "feflood" => NodeTypeTag::SvgFeFlood,

2562

        "fefuncr" => NodeTypeTag::SvgFeFuncR,

2563

        "fefuncg" => NodeTypeTag::SvgFeFuncG,

2564

        "fefuncb" => NodeTypeTag::SvgFeFuncB,

2565

        "fefunca" => NodeTypeTag::SvgFeFuncA,

2566

        "fegaussianblur" => NodeTypeTag::SvgFeGaussianBlur,

2567

        "feimage" => NodeTypeTag::SvgFeImage,

2568

        "femerge" => NodeTypeTag::SvgFeMerge,

2569

        "femergenode" => NodeTypeTag::SvgFeMergeNode,

2570

        "femorphology" => NodeTypeTag::SvgFeMorphology,

2571

        "feoffset" => NodeTypeTag::SvgFeOffset,

2572

        "fepointlight" => NodeTypeTag::SvgFePointLight,

2573

        "fespecularlighting" => NodeTypeTag::SvgFeSpecularLighting,

2574

        "fespotlight" => NodeTypeTag::SvgFeSpotLight,

2575

        "fetile" => NodeTypeTag::SvgFeTile,

2576

        "feturbulence" => NodeTypeTag::SvgFeTurbulence,

2577

        "foreignobject" => NodeTypeTag::SvgForeignObject,

2578

        "desc" => NodeTypeTag::SvgDesc,

2579

        "view" => NodeTypeTag::SvgView,

2580

        "animate" => NodeTypeTag::SvgAnimate,

2581

        "animatemotion" => NodeTypeTag::SvgAnimateMotion,

2582

        "animatetransform" => NodeTypeTag::SvgAnimateTransform,

2583

        "set" => NodeTypeTag::SvgSet,

2584

        "mpath" => NodeTypeTag::SvgMpath,

2585

        // Metadata

2586

        "meta" => NodeTypeTag::Meta,

2587

        "link" => NodeTypeTag::Link,

2588

        "script" => NodeTypeTag::Script,

2589

        "style" => NodeTypeTag::Style,

2590

        "base" => NodeTypeTag::Base,

2591

        // Special

2592

        "img" | "image" => NodeTypeTag::Img,

2593

        "icon" => NodeTypeTag::Icon,

2594

        _ => NodeTypeTag::Div,

2595

2596

2597

2598

/// Default render function for builtin HTML elements.

2599

/// Delegates to creating a DOM node of the appropriate NodeType.

2600

fn builtin_render_fn(

2601

    def: &ComponentDef,

2602

    data: &ComponentDataModel,

2603

    _component_map: &ComponentMap,

2604

) -> ResultStyledDomRenderDomError {

2605

    let node_type = tag_to_node_type(def.id.name.as_str());

2606

    let mut dom = Dom::create_node(node_type);

2607

    if let Some(text_str) = data.get_default_string("text") {

2608

        let prepared = prepare_string(text_str);

2609

        if !prepared.is_empty() {

2610

            dom = dom.with_children(alloc::vec![Dom::create_text(prepared)].into());

2611

2612

2613

    let r: Result<StyledDom, RenderDomError> = Ok(StyledDom::create(&mut dom, Css::empty()));

2614

    r.into()

2615

2616

2617

/// Default compile function for builtin HTML elements.

2618

/// Generates `Dom::create_node(NodeType::Div)` style code for the target language.

2619

fn builtin_compile_fn(

2620

    def: &ComponentDef,

2621

    target: &CompileTarget,

2622

    data: &ComponentDataModel,

2623

    indent: usize,

2624

) -> ResultStringCompileError {

2625

    let node_type = tag_to_node_type(def.id.name.as_str());

2626

    let type_name = format!("{:?}", node_type); // "Div", "Body", "P", etc.

2627

    let text = data.get_default_string("text");

2628

2629

    let r: Result<AzString, CompileError> = match target {

2630

        CompileTarget::Rust => {

2631

            if let Some(text_str) = text {

2632

                Ok(format!(

2633

                    "Dom::create_node(NodeType::{}).with_children(vec![Dom::create_text(AzString::from_const_str(\"{}\"))].into())",

2634

                    type_name,

2635

                    text_str.as_str().replace("\\", "\\\\").replace("\"", "\\\"")

2636

                ).into())

2637

            } else {

2638

                Ok(format!("Dom::create_node(NodeType::{})", type_name).into())

2639

2640

2641

        CompileTarget::C => {

2642

            if let Some(text_str) = text {

2643

                Ok(format!(

2644

                    "AzDom_createText(AzString_fromConstStr(\"{}\"))",

2645

                    text_str.as_str().replace("\\", "\\\\").replace("\"", "\\\"")

2646

                ).into())

2647

            } else {

2648

                Ok(format!("AzDom_create{}()", type_name).into())

2649

2650

2651

        CompileTarget::Cpp => {

2652

            Ok(format!("Dom::create_{}()", type_name.to_lowercase()).into())

2653

2654

        CompileTarget::Python => {

2655

            Ok(format!("Dom.{}()", type_name.to_lowercase()).into())

2656

2657

};

2658

    r.into()

2659

2660

2661

/// Pushes a `<div>` containing `"field_name: value"` text into the children list.

2662

fn push_scalar_field(children: &mut Vec<Dom>, field_name: &str, value: &dyn core::fmt::Display) {

2663

    use crate::dom::{Dom, NodeType};

2664

    let text = alloc::format!("{}: {}", field_name, value);

2665

    children.push(

2666

        Dom::create_node(NodeType::Div)

2667

            .with_children(alloc::vec![Dom::create_text(text)].into()),

2668

);

2669

2670

2671

/// Default render function for user-defined (JSON-imported) components.

2672

///

2673

/// Interprets the `ComponentDef` structure generically:

2674

/// 1. Creates a wrapper `<div>` with the component's CSS class

2675

/// 2. For each data field, renders content based on type:

2676

///    - String fields → text node with current value

2677

///    - Bool fields → conditional display

2678

///    - StyledDom fields → embeds the child DOM subtree

2679

///    - StructRef/EnumRef → recursively renders sub-components if found in ComponentMap

2680

///    - Other scalar fields → text display of the value

2681

/// 3. Applies the component's scoped CSS

2682

pub fn user_defined_render_fn(

2683

    def: &ComponentDef,

2684

    data: &ComponentDataModel,

2685

    component_map: &ComponentMap,

2686

) -> ResultStyledDomRenderDomError {

2687

    use crate::dom::{Dom, NodeType};

2688

    use azul_css::css::Css;

2689

2690

    let mut children: Vec<Dom> = Vec::new();

2691

2692

    for field in data.fields.as_ref().iter() {

2693

        let field_name = field.name.as_str();

2694

2695

        // Get the current value from default_value

2696

        match &field.default_value {

2697

            OptionComponentDefaultValue::None => {

2698

                // Required field with no value — skip in preview

2699

                continue;

2700

2701

            OptionComponentDefaultValue::Some(default_val) => {

2702

                match default_val {

2703

                    ComponentDefaultValue::String(s) => {

2704

                        let text = s.as_str().trim();

2705

                        if !text.is_empty() {

2706

                            let label_dom = Dom::create_node(NodeType::Div)

2707

                                .with_children(alloc::vec![Dom::create_text(text.to_string())].into());

2708

                            children.push(label_dom);

2709

2710

2711

                    ComponentDefaultValue::Bool(v) => {

2712

                        push_scalar_field(&mut children, field_name, v);

2713

2714

                    ComponentDefaultValue::I32(v) => {

2715

                        push_scalar_field(&mut children, field_name, v);

2716

2717

                    ComponentDefaultValue::I64(v) => {

2718

                        push_scalar_field(&mut children, field_name, v);

2719

2720

                    ComponentDefaultValue::U32(v) => {

2721

                        push_scalar_field(&mut children, field_name, v);

2722

2723

                    ComponentDefaultValue::U64(v) => {

2724

                        push_scalar_field(&mut children, field_name, v);

2725

2726

                    ComponentDefaultValue::Usize(v) => {

2727

                        push_scalar_field(&mut children, field_name, v);

2728

2729

                    ComponentDefaultValue::F32(v) => {

2730

                        push_scalar_field(&mut children, field_name, v);

2731

2732

                    ComponentDefaultValue::F64(v) => {

2733

                        push_scalar_field(&mut children, field_name, v);

2734

2735

                    ComponentDefaultValue::ColorU(c) => {

2736

                        let text = alloc::format!("{}: #{:02x}{:02x}{:02x}{:02x}", field_name, c.r, c.g, c.b, c.a);

2737

                        children.push(Dom::create_node(NodeType::Div)

2738

                            .with_children(alloc::vec![Dom::create_text(text)].into()));

2739

2740

                    ComponentDefaultValue::ComponentInstance(ci) => {

2741

                        // Recursively instantiate sub-component from ComponentMap

2742

                        if let Some(sub_comp) = component_map.get(ci.library.as_str(), ci.component.as_str()) {

2743

                            let sub_data = sub_comp.data_model.clone();

2744

                            match (sub_comp.render_fn)(sub_comp, &sub_data, component_map) {

2745

                                ResultStyledDomRenderDomError::Ok(_styled_dom) => {

2746

                                    // Sub-component rendered successfully — add a placeholder

2747

                                    // (StyledDom cannot be directly converted back to Dom)

2748

                                    let text = alloc::format!("[{}:{}]", ci.library.as_str(), ci.component.as_str());

2749

                                    children.push(Dom::create_node(NodeType::Div)

2750

                                        .with_children(alloc::vec![Dom::create_text(text)].into()));

2751

2752

                                ResultStyledDomRenderDomError::Err(_) => {

2753

                                    // On error, show a placeholder

2754

                                    let text = alloc::format!("[Error rendering {}:{}]", ci.library.as_str(), ci.component.as_str());

2755

                                    children.push(Dom::create_node(NodeType::Div)

2756

                                        .with_children(alloc::vec![Dom::create_text(text)].into()));

2757

2758

2759

                        } else {

2760

                            let text = alloc::format!("[Unknown component {}:{}]", ci.library.as_str(), ci.component.as_str());

2761

                            children.push(Dom::create_node(NodeType::Div)

2762

                                .with_children(alloc::vec![Dom::create_text(text)].into()));

2763

2764

2765

                    ComponentDefaultValue::CallbackFnPointer(name) => {

2766

                        // Callbacks are not rendered, just acknowledged

2767

                        let text = alloc::format!("{}: fn({})", field_name, name.as_str());

2768

                        children.push(Dom::create_node(NodeType::Div)

2769

                            .with_children(alloc::vec![Dom::create_text(text)].into()));

2770

2771

                    ComponentDefaultValue::Json(json_str) => {

2772

                        let text = alloc::format!("{}: {}", field_name, json_str.as_str());

2773

                        children.push(Dom::create_node(NodeType::Div)

2774

                            .with_children(alloc::vec![Dom::create_text(text)].into()));

2775

2776

                    ComponentDefaultValue::None => {

2777

                        // No default, skip

2778

                        continue;

2779

2780

2781

2782

2783

2784

2785

    let mut wrapper = Dom::create_node(NodeType::Div);

2786

    if !children.is_empty() {

2787

        wrapper = wrapper.with_children(children.into());

2788

2789

2790

    // Apply component CSS

2791

    let css = if !def.css.as_str().is_empty() {

2792

        Css::from_string(def.css.clone())

2793

    } else {

2794

        Css::empty()

2795

};

2796

2797

    let r: Result<StyledDom, RenderDomError> = Ok(StyledDom::create(&mut wrapper, css));

2798

    r.into()

2799

2800

2801

/// Default compile function for user-defined (JSON-imported) components.

2802

///

2803

/// Generates source code that creates the component's DOM structure for the

2804

/// target language. For each data field, emits the appropriate code:

2805

/// - String fields → text node creation

2806

/// - Scalar fields → formatted display

2807

/// - ComponentInstance → function call to sub-component's render function

2808

/// - StyledDom slots → child parameter pass-through

2809

pub fn user_defined_compile_fn(

2810

    def: &ComponentDef,

2811

    target: &CompileTarget,

2812

    data: &ComponentDataModel,

2813

    indent: usize,

2814

) -> ResultStringCompileError {

2815

    let tag = def.id.name.as_str();

2816

    let indent_str = " ".repeat(indent * 4);

2817

    let inner_indent = " ".repeat((indent + 1) * 4);

2818

2819

    let r: Result<AzString, CompileError> = match target {

2820

        CompileTarget::Rust => {

2821

            let mut lines = Vec::new();

2822

            lines.push(alloc::format!("{}// Component: {}", indent_str, tag));

2823

            lines.push(alloc::format!("{}let mut children: Vec<Dom> = Vec::new();", indent_str));

2824

2825

            for field in data.fields.as_ref().iter() {

2826

                let fname = field.name.as_str();

2827

                match &field.default_value {

2828

                    OptionComponentDefaultValue::Some(ComponentDefaultValue::String(s)) => {

2829

                        let escaped = s.as_str().replace("\\", "\\\\").replace("\"", "\\\"");

2830

                        lines.push(alloc::format!(

2831

                            "{}children.push(Dom::create_text(AzString::from_const_str(\"{}\")));",

2832

                            inner_indent, escaped

2833

));

2834

2835

                    OptionComponentDefaultValue::Some(ComponentDefaultValue::Bool(b)) => {

2836

                        lines.push(alloc::format!(

2837

                            "{}children.push(Dom::create_text(AzString::from(format!(\"{{}}: {{}}\", \"{}\", {}).as_str())));",

2838

                            inner_indent, fname, b

2839

));

2840

2841

                    OptionComponentDefaultValue::Some(ComponentDefaultValue::ComponentInstance(ci)) => {

2842

                        let fn_name = alloc::format!("render_{}", ci.component.as_str().replace("-", "_"));

2843

                        lines.push(alloc::format!(

2844

                            "{}children.push({}()); // sub-component {}:{}",

2845

                            inner_indent, fn_name, ci.library.as_str(), ci.component.as_str()

2846

));

2847

2848

                    _ => {

2849

                        // For other types, generate a placeholder comment

2850

                        lines.push(alloc::format!(

2851

                            "{}// field '{}': {:?}",

2852

                            inner_indent, fname, field.field_type

2853

));

2854

2855

2856

2857

2858

            lines.push(alloc::format!(

2859

                "{}Dom::create_node(NodeType::Div).with_children(children.into())",

2860

                indent_str

2861

));

2862

            Ok(lines.join("\n").into())

2863

2864

        CompileTarget::C => {

2865

            let mut lines = Vec::new();

2866

            lines.push(alloc::format!("{}/* Component: {} */", indent_str, tag));

2867

            lines.push(alloc::format!("{}AzDom root = AzDom_createDiv();", indent_str));

2868

2869

            for field in data.fields.as_ref().iter() {

2870

                let fname = field.name.as_str();

2871

                match &field.default_value {

2872

                    OptionComponentDefaultValue::Some(ComponentDefaultValue::String(s)) => {

2873

                        let escaped = s.as_str().replace("\\", "\\\\").replace("\"", "\\\"");

2874

                        lines.push(alloc::format!(

2875

                            "{}AzDom_addChild(&root, AzDom_createText(AzString_fromConstStr(\"{}\")));",

2876

                            inner_indent, escaped

2877

));

2878

2879

                    OptionComponentDefaultValue::Some(ComponentDefaultValue::ComponentInstance(ci)) => {

2880

                        let fn_name = alloc::format!("render_{}", ci.component.as_str().replace("-", "_"));

2881

                        lines.push(alloc::format!(

2882

                            "{}AzDom_addChild(&root, {}());",

2883

                            inner_indent, fn_name

2884

));

2885

2886

                    _ => {

2887

                        lines.push(alloc::format!(

2888

                            "{}/* field '{}' */",

2889

                            inner_indent, fname

2890

));

2891

2892

2893

2894

2895

            lines.push(alloc::format!("{}return root;", indent_str));

2896

            Ok(lines.join("\n").into())

2897

2898

        CompileTarget::Cpp => {

2899

            let mut lines = Vec::new();

2900

            lines.push(alloc::format!("{}// Component: {}", indent_str, tag));

2901

            lines.push(alloc::format!("{}auto root = Dom::create_div();", indent_str));

2902

2903

            for field in data.fields.as_ref().iter() {

2904

                let fname = field.name.as_str();

2905

                match &field.default_value {

2906

                    OptionComponentDefaultValue::Some(ComponentDefaultValue::String(s)) => {

2907

                        let escaped = s.as_str().replace("\\", "\\\\").replace("\"", "\\\"");

2908

                        lines.push(alloc::format!(

2909

                            "{}root.add_child(Dom::create_text(\"{}\"));",

2910

                            inner_indent, escaped

2911

));

2912

2913

                    OptionComponentDefaultValue::Some(ComponentDefaultValue::ComponentInstance(ci)) => {

2914

                        let fn_name = alloc::format!("render_{}", ci.component.as_str().replace("-", "_"));

2915

                        lines.push(alloc::format!(

2916

                            "{}root.add_child({}());",

2917

                            inner_indent, fn_name

2918

));

2919

2920

                    _ => {

2921

                        lines.push(alloc::format!(

2922

                            "{}// field '{}'",

2923

                            inner_indent, fname

2924

));

2925

2926

2927

2928

2929

            lines.push(alloc::format!("{}return root;", indent_str));

2930

            Ok(lines.join("\n").into())

2931

2932

        CompileTarget::Python => {

2933

            let mut lines = Vec::new();

2934

            lines.push(alloc::format!("{}# Component: {}", indent_str, tag));

2935

            lines.push(alloc::format!("{}root = Dom.div()", indent_str));

2936

2937

            for field in data.fields.as_ref().iter() {

2938

                let fname = field.name.as_str();

2939

                match &field.default_value {

2940

                    OptionComponentDefaultValue::Some(ComponentDefaultValue::String(s)) => {

2941

                        let escaped = s.as_str().replace("\\", "\\\\").replace("\"", "\\\"").replace("'", "\\'");

2942

                        lines.push(alloc::format!(

2943

                            "{}root.add_child(Dom.text('{}'))",

2944

                            inner_indent, escaped

2945

));

2946

2947

                    OptionComponentDefaultValue::Some(ComponentDefaultValue::ComponentInstance(ci)) => {

2948

                        let fn_name = alloc::format!("render_{}", ci.component.as_str().replace("-", "_"));

2949

                        lines.push(alloc::format!(

2950

                            "{}root.add_child({}())",

2951

                            inner_indent, fn_name

2952

));

2953

2954

                    _ => {

2955

                        lines.push(alloc::format!(

2956

                            "{}# field '{}'",

2957

                            inner_indent, fname

2958

));

2959

2960

2961

2962

2963

            lines.push(alloc::format!("{}return root", indent_str));

2964

            Ok(lines.join("\n").into())

2965

2966

};

2967

    r.into()

2968

2969

2970

/// Create a ComponentDef for a builtin HTML element.

2971

///

2972

/// # Arguments

2973

/// * `tag` - HTML tag name (e.g. "button", "div")

2974

/// * `display_name` - Human-readable name (e.g. "Button", "Div")

2975

/// * `default_text` - Default text content for the preview, or `None` if the element has no text.

2976

///   Pass `Some("Button text")` for `<button>`, `Some("")` for text elements like `<span>` that

2977

///   accept text but have no meaningful default.

2978

/// * `css` - Component-level CSS string. For most builtin elements this is `""` because

2979

///   styling comes from `ua_css.rs` and the `SystemStyle`. Components that need extra

2980

///   styling (e.g. a future high-level button widget) can pass CSS here.

2981

352800

fn builtin_component_def(tag: &str, display_name: &str, default_text: Option<&str>, css: &str) -> ComponentDef {

2982

352800

    let mut fields = builtin_data_model(tag);

2983

    // If a default_text is provided, this element accepts text content

2984

352800

    if let Some(text) = default_text {

2985

185850

        fields.push(data_field("text", ComponentFieldType::String,

2986

185850

            Some(ComponentDefaultValue::String(AzString::from(text))),

2987

185850

            "Text content of the element"));

2988

185850

2989

352800

    let model_name = format!("{}Data", display_name);

2990

352800

    ComponentDef {

2991

352800

        id: ComponentId::builtin(tag),

2992

352800

        display_name: AzString::from(display_name),

2993

352800

        description: AzString::from(format!("HTML <{}> element", tag).as_str()),

2994

352800

        css: AzString::from(css),

2995

352800

        source: ComponentSource::Builtin,

2996

352800

        data_model: ComponentDataModel {

2997

352800

            name: AzString::from(model_name.as_str()),

2998

352800

            description: AzString::from(format!("Data model for <{}>", tag).as_str()),

2999

352800

            fields: fields.into(),

3000

352800

},

3001

352800

        render_fn: builtin_render_fn,

3002

352800

        compile_fn: builtin_compile_fn,

3003

352800

        render_fn_source: None.into(),

3004

352800

        compile_fn_source: None.into(),

3005

352800

3006

352800

3007

3008

/// Helper to create a ComponentDataField with a rich type

3009

585900

fn data_field(name: &str, ft: ComponentFieldType, default: Option<ComponentDefaultValue>, description: &str) -> ComponentDataField {

3010

585900

    let required = default.is_none();

3011

    ComponentDataField {

3012

585900

        name: AzString::from(name),

3013

585900

        field_type: ft,

3014

585900

        default_value: match default {

3015

567000

            Some(d) => OptionComponentDefaultValue::Some(d),

3016

18900

            None => OptionComponentDefaultValue::None,

3017

},

3018

585900

        required,

3019

585900

        description: AzString::from(description),

3020

3021

585900

3022

3023

/// Returns the tag-specific data model fields for builtin HTML elements.

3024

/// These are the component's "main data model" — the attributes that define

3025

/// what the component needs as configuration (e.g., `href` for `<a>`,

3026

/// `src` for `<img>`). Universal HTML attributes (id, class, style, etc.)

3027

/// are NOT included here — they are added separately by the debug server.

3028

352800

fn builtin_data_model(tag: &str) -> Vec<ComponentDataField> {

3029

    use ComponentFieldType::*;

3030

    use ComponentDefaultValue as D;

3031

352800

    match tag {

3032

352800

        "a" => alloc::vec![

3033

3150

            data_field("href", String, Some(D::String(AzString::from_const_str(""))), "URL the link points to"),

3034

3150

            data_field("target", String, Some(D::String(AzString::from_const_str(""))), "Where to open the linked document (_blank, _self, _parent, _top)"),

3035

3150

            data_field("rel", String, Some(D::String(AzString::from_const_str(""))), "Relationship between current and linked document"),

3036

],

3037

349650

        "img" | "image" => alloc::vec![

3038

            data_field("src", String, None, "URL of the image"),

3039

            data_field("alt", String, Some(D::String(AzString::from_const_str(""))), "Alternative text for the image"),

3040

            data_field("width", String, Some(D::String(AzString::from_const_str(""))), "Width of the image"),

3041

            data_field("height", String, Some(D::String(AzString::from_const_str(""))), "Height of the image"),

3042

],

3043

349650

        "form" => alloc::vec![

3044

3150

            data_field("action", String, Some(D::String(AzString::from_const_str(""))), "URL where form data is submitted"),

3045

3150

            data_field("method", String, Some(D::String(AzString::from_const_str("GET"))), "HTTP method for form submission (GET or POST)"),

3046

],

3047

346500

        "label" => alloc::vec![

3048

3150

            data_field("for", String, Some(D::String(AzString::from_const_str(""))), "ID of the form element this label is for"),

3049

],

3050

343350

        "button" => alloc::vec![

3051

3150

            data_field("type", String, Some(D::String(AzString::from_const_str("button"))), "Button type (button, submit, reset)"),

3052

3150

            data_field("disabled", Bool, Some(D::Bool(false)), "Whether the button is disabled"),

3053

],

3054

340200

        "td" | "th" => alloc::vec![

3055

6300

            data_field("colspan", I32, Some(D::I32(1)), "Number of columns the cell spans"),

3056

6300

            data_field("rowspan", I32, Some(D::I32(1)), "Number of rows the cell spans"),

3057

],

3058

333900

        "icon" => alloc::vec![

3059

3150

            data_field("name", String, Some(D::String(AzString::from_const_str(""))), "Icon name"),

3060

],

3061

330750

        "ol" => alloc::vec![

3062

3150

            data_field("start", I32, Some(D::I32(1)), "Start value for the ordered list"),

3063

3150

            data_field("type", String, Some(D::String(AzString::from_const_str("1"))), "Numbering type (1, A, a, I, i)"),

3064

],

3065

        // Form controls

3066

327600

        "input" => alloc::vec![

3067

3150

            data_field("type", String, Some(D::String(AzString::from_const_str("text"))), "Input type (text, password, email, number, checkbox, radio, etc.)"),

3068

3150

            data_field("name", String, Some(D::String(AzString::from_const_str(""))), "Name of the input for form submission"),

3069

3150

            data_field("value", String, Some(D::String(AzString::from_const_str(""))), "Current value of the input"),

3070

3150

            data_field("placeholder", String, Some(D::String(AzString::from_const_str(""))), "Placeholder text"),

3071

3150

            data_field("disabled", Bool, Some(D::Bool(false)), "Whether the input is disabled"),

3072

3150

            data_field("required", Bool, Some(D::Bool(false)), "Whether the input is required"),

3073

3150

            data_field("readonly", Bool, Some(D::Bool(false)), "Whether the input is read-only"),

3074

3150

            data_field("checked", Bool, Some(D::Bool(false)), "Whether the checkbox/radio is checked"),

3075

3150

            data_field("min", String, Some(D::String(AzString::from_const_str(""))), "Minimum value (for number, range, date)"),

3076

3150

            data_field("max", String, Some(D::String(AzString::from_const_str(""))), "Maximum value (for number, range, date)"),

3077

3150

            data_field("step", String, Some(D::String(AzString::from_const_str(""))), "Step increment (for number, range)"),

3078

3150

            data_field("pattern", String, Some(D::String(AzString::from_const_str(""))), "Regex pattern for validation"),

3079

3150

            data_field("maxlength", String, Some(D::String(AzString::from_const_str(""))), "Maximum number of characters"),

3080

],

3081

324450

        "select" => alloc::vec![

3082

3150

            data_field("name", String, Some(D::String(AzString::from_const_str(""))), "Name for form submission"),

3083

3150

            data_field("multiple", Bool, Some(D::Bool(false)), "Whether multiple options can be selected"),

3084

3150

            data_field("disabled", Bool, Some(D::Bool(false)), "Whether the select is disabled"),

3085

3150

            data_field("required", Bool, Some(D::Bool(false)), "Whether selection is required"),

3086

3150

            data_field("size", String, Some(D::String(AzString::from_const_str(""))), "Number of visible options"),

3087

],

3088

321300

        "option" => alloc::vec![

3089

3150

            data_field("value", String, Some(D::String(AzString::from_const_str(""))), "Value submitted with the form"),

3090

3150

            data_field("selected", Bool, Some(D::Bool(false)), "Whether this option is selected"),

3091

3150

            data_field("disabled", Bool, Some(D::Bool(false)), "Whether this option is disabled"),

3092

],

3093

318150

        "optgroup" => alloc::vec![

3094

3150

            data_field("label", String, Some(D::String(AzString::from_const_str(""))), "Label for the option group"),

3095

3150

            data_field("disabled", Bool, Some(D::Bool(false)), "Whether the group is disabled"),

3096

],

3097

315000

        "textarea" => alloc::vec![

3098

3150

            data_field("name", String, Some(D::String(AzString::from_const_str(""))), "Name for form submission"),

3099

3150

            data_field("placeholder", String, Some(D::String(AzString::from_const_str(""))), "Placeholder text"),

3100

3150

            data_field("rows", I32, Some(D::I32(2)), "Number of visible text lines"),

3101

3150

            data_field("cols", I32, Some(D::I32(20)), "Visible width in average character widths"),

3102

3150

            data_field("disabled", Bool, Some(D::Bool(false)), "Whether the textarea is disabled"),

3103

3150

            data_field("required", Bool, Some(D::Bool(false)), "Whether content is required"),

3104

3150

            data_field("readonly", Bool, Some(D::Bool(false)), "Whether the textarea is read-only"),

3105

3150

            data_field("maxlength", String, Some(D::String(AzString::from_const_str(""))), "Maximum number of characters"),

3106

],

3107

311850

        "fieldset" => alloc::vec![

3108

3150

            data_field("disabled", Bool, Some(D::Bool(false)), "Whether all controls in the fieldset are disabled"),

3109

],

3110

308700

        "output" => alloc::vec![

3111

3150

            data_field("for", String, Some(D::String(AzString::from_const_str(""))), "IDs of elements that contributed to the output"),

3112

3150

            data_field("name", String, Some(D::String(AzString::from_const_str(""))), "Name for form submission"),

3113

],

3114

305550

        "progress" => alloc::vec![

3115

3150

            data_field("value", String, Some(D::String(AzString::from_const_str(""))), "Current progress value"),

3116

3150

            data_field("max", String, Some(D::String(AzString::from_const_str("1"))), "Maximum value"),

3117

],

3118

302400

        "meter" => alloc::vec![

3119

3150

            data_field("value", String, Some(D::String(AzString::from_const_str(""))), "Current value"),

3120

3150

            data_field("min", String, Some(D::String(AzString::from_const_str("0"))), "Minimum value"),

3121

3150

            data_field("max", String, Some(D::String(AzString::from_const_str("1"))), "Maximum value"),

3122

3150

            data_field("low", String, Some(D::String(AzString::from_const_str(""))), "Low threshold"),

3123

3150

            data_field("high", String, Some(D::String(AzString::from_const_str(""))), "High threshold"),

3124

3150

            data_field("optimum", String, Some(D::String(AzString::from_const_str(""))), "Optimum value"),

3125

],

3126

        // Interactive

3127

299250

        "details" => alloc::vec![

3128

3150

            data_field("open", Bool, Some(D::Bool(false)), "Whether the details are visible"),

3129

],

3130

296100

        "dialog" => alloc::vec![

3131

3150

            data_field("open", Bool, Some(D::Bool(false)), "Whether the dialog is active and can be interacted with"),

3132

],

3133

        // Embedded content

3134

292950

        "audio" | "video" => alloc::vec![

3135

6300

            data_field("src", String, Some(D::String(AzString::from_const_str(""))), "URL of the media resource"),

3136

6300

            data_field("controls", Bool, Some(D::Bool(false)), "Whether to show playback controls"),

3137

6300

            data_field("autoplay", Bool, Some(D::Bool(false)), "Whether to start playing automatically"),

3138

6300

            data_field("loop", Bool, Some(D::Bool(false)), "Whether to loop playback"),

3139

6300

            data_field("muted", Bool, Some(D::Bool(false)), "Whether audio is muted"),

3140

6300

            data_field("preload", String, Some(D::String(AzString::from_const_str("auto"))), "Preload hint (none, metadata, auto)"),

3141

],

3142

286650

        "source" => alloc::vec![

3143

3150

            data_field("src", String, None, "URL of the media resource"),

3144

3150

            data_field("type", String, Some(D::String(AzString::from_const_str(""))), "MIME type of the resource"),

3145

],

3146

283500

        "track" => alloc::vec![

3147

3150

            data_field("src", String, None, "URL of the track file"),

3148

3150

            data_field("kind", String, Some(D::String(AzString::from_const_str("subtitles"))), "Kind of text track (subtitles, captions, descriptions, chapters, metadata)"),

3149

3150

            data_field("srclang", String, Some(D::String(AzString::from_const_str(""))), "Language of the track text"),

3150

            data_field("label", String, Some(D::String(AzString::from_const_str(""))), "User-readable title for the track"),

3151

3150

            data_field("default", Bool, Some(D::Bool(false)), "Whether this is the default track"),

3152

],

3153

280350

        "canvas" => alloc::vec![

3154

3150

            data_field("width", String, Some(D::String(AzString::from_const_str("300"))), "Width of the canvas in pixels"),

3155

3150

            data_field("height", String, Some(D::String(AzString::from_const_str("150"))), "Height of the canvas in pixels"),

3156

],

3157

277200

        "embed" => alloc::vec![

3158

3150

            data_field("src", String, None, "URL of the resource to embed"),

3159

3150

            data_field("type", String, Some(D::String(AzString::from_const_str(""))), "MIME type of the embedded content"),

3160

3150

            data_field("width", String, Some(D::String(AzString::from_const_str(""))), "Width"),

3161

3150

            data_field("height", String, Some(D::String(AzString::from_const_str(""))), "Height"),

3162

],

3163

274050

        "object" => alloc::vec![

3164

3150

            data_field("data", String, Some(D::String(AzString::from_const_str(""))), "URL of the resource"),

3165

3150

            data_field("type", String, Some(D::String(AzString::from_const_str(""))), "MIME type of the resource"),

3166

3150

            data_field("width", String, Some(D::String(AzString::from_const_str(""))), "Width"),

3167

3150

            data_field("height", String, Some(D::String(AzString::from_const_str(""))), "Height"),

3168

],

3169

270900

        "param" => alloc::vec![

3170

3150

            data_field("name", String, None, "Name of the parameter"),

3171

3150

            data_field("value", String, Some(D::String(AzString::from_const_str(""))), "Value of the parameter"),

3172

],

3173

267750

        "area" => alloc::vec![

3174

3150

            data_field("shape", String, Some(D::String(AzString::from_const_str("default"))), "Shape of the area (default, rect, circle, poly)"),

3175

3150

            data_field("coords", String, Some(D::String(AzString::from_const_str(""))), "Coordinates of the area"),

3176

3150

            data_field("href", String, Some(D::String(AzString::from_const_str(""))), "URL for the area link"),

3177

3150

            data_field("alt", String, Some(D::String(AzString::from_const_str(""))), "Alternative text"),

3178

3150

            data_field("target", String, Some(D::String(AzString::from_const_str(""))), "Where to open the linked document"),

3179

],

3180

264600

        "map" => alloc::vec![

3181

3150

            data_field("name", String, None, "Name of the image map (referenced by usemap)"),

3182

],

3183

        // Inline semantics with special attributes

3184

261450

        "time" => alloc::vec![

3185

3150

            data_field("datetime", String, Some(D::String(AzString::from_const_str(""))), "Machine-readable date/time value"),

3186

],

3187

258300

        "data" => alloc::vec![

3188

3150

            data_field("value", String, Some(D::String(AzString::from_const_str(""))), "Machine-readable value"),

3189

],

3190

255150

        "abbr" | "acronym" | "dfn" => alloc::vec![

3191

9450

            data_field("title", String, Some(D::String(AzString::from_const_str(""))), "Full expansion or definition"),

3192

],

3193

245700

        "q" | "blockquote" => alloc::vec![

3194

6300

            data_field("cite", String, Some(D::String(AzString::from_const_str(""))), "URL of the source of the quotation"),

3195

],

3196

239400

        "del" | "ins" => alloc::vec![

3197

6300

            data_field("cite", String, Some(D::String(AzString::from_const_str(""))), "URL explaining the change"),

3198

6300

            data_field("datetime", String, Some(D::String(AzString::from_const_str(""))), "Date/time of the change"),

3199

],

3200

233100

        "bdo" => alloc::vec![

3201

3150

            data_field("dir", String, Some(D::String(AzString::from_const_str("ltr"))), "Text direction (ltr, rtl)"),

3202

],

3203

229950

        "col" | "colgroup" => alloc::vec![

3204

6300

            data_field("span", I32, Some(D::I32(1)), "Number of columns the element spans"),

3205

],

3206

        // Metadata

3207

223650

        "meta" => alloc::vec![

3208

3150

            data_field("name", String, Some(D::String(AzString::from_const_str(""))), "Metadata name"),

3209

3150

            data_field("content", String, Some(D::String(AzString::from_const_str(""))), "Metadata value"),

3210

3150

            data_field("charset", String, Some(D::String(AzString::from_const_str(""))), "Character encoding"),

3211

3150

            data_field("http-equiv", String, Some(D::String(AzString::from_const_str(""))), "HTTP header equivalent"),

3212

],

3213

220500

        "link" => alloc::vec![

3214

3150

            data_field("rel", String, None, "Relationship type"),

3215

3150

            data_field("href", String, Some(D::String(AzString::from_const_str(""))), "URL of the linked resource"),

3216

3150

            data_field("type", String, Some(D::String(AzString::from_const_str(""))), "MIME type of the linked resource"),

3217

],

3218

217350

        "script" => alloc::vec![

3219

3150

            data_field("src", String, Some(D::String(AzString::from_const_str(""))), "URL of external script"),

3220

3150

            data_field("type", String, Some(D::String(AzString::from_const_str(""))), "MIME type or module"),

3221

3150

            data_field("async", Bool, Some(D::Bool(false)), "Execute asynchronously"),

3222

3150

            data_field("defer", Bool, Some(D::Bool(false)), "Defer execution until page load"),

3223

],

3224

214200

        "style" => alloc::vec![

3225

3150

            data_field("type", String, Some(D::String(AzString::from_const_str("text/css"))), "MIME type of the style sheet"),

3226

],

3227

211050

        "base" => alloc::vec![

3228

3150

            data_field("href", String, Some(D::String(AzString::from_const_str(""))), "Base URL for relative URLs"),

3229

3150

            data_field("target", String, Some(D::String(AzString::from_const_str(""))), "Default target for hyperlinks"),

3230

],

3231

207900

        _ => alloc::vec![],

3232

3233

352800

3234

3235

impl Default for ComponentMap {

3236

    /// Returns an empty `ComponentMap` with no libraries.

3237

///

3238

    /// Use `AppConfig::create()` (which registers the 52 builtins via

3239

    /// `register_builtin_components`) followed by `ComponentMap::from_libraries()`

3240

    /// to get a fully-populated map.

3241

1

    fn default() -> Self {

3242

1

        ComponentMap {

3243

1

            libraries: ComponentLibraryVec::from_const_slice(&[]),

3244

1

3245

1

3246

3247

3248

impl ComponentMap {

3249

    pub fn create() -> Self {

3250

        Self::default()

3251

3252

3253

    /// Create a `ComponentMap` with the 52 built-in HTML element components pre-registered.

3254

3150

    pub fn with_builtin() -> Self {

3255

3150

        ComponentMap {

3256

3150

            libraries: alloc::vec![register_builtin_components()].into(),

3257

3150

3258

3150

3259

3260

    /// Build a `ComponentMap` from the libraries stored in an `AppConfig`.

3261

///

3262

    /// The `component_libraries` field already contains builtins (registered in

3263

    /// `AppConfig::create()`) plus any user-added libraries.  No merging needed —

3264

    /// `add_component_library` / `add_component` handle insertion at registration time.

3265

    pub fn from_libraries(libs: &ComponentLibraryVec) -> Self {

3266

        ComponentMap {

3267

            libraries: libs.clone(),

3268

3269

3270

3271

3272

/// Convert XML attributes to a `ComponentDataModel` by cloning the component's

3273

/// base data model and overriding field defaults with values from the XML attributes.

3274

///

3275

/// This is the bridge between the XML parsing layer (key-value string pairs)

3276

/// and the typed component data model. For each field in the base model,

3277

/// if a matching XML attribute exists, its string value is set as the new default.

3278

///

3279

/// # Arguments

3280

/// * `base_model` - The component's data model template (from `ComponentDef::data_model`)

3281

/// * `xml_attributes` - The XML node's attribute map

3282

/// * `text_content` - Optional text content from child text nodes

3283

///

3284

/// # Returns

3285

/// A cloned `ComponentDataModel` with overridden defaults

3286

fn xml_attrs_to_data_model(

3287

    base_model: &ComponentDataModel,

3288

    xml_attributes: &XmlAttributeMap,

3289

    text_content: Option<&str>,

3290

) -> ComponentDataModel {

3291

    let mut model = base_model.clone();

3292

3293

    // Override defaults from XML attributes

3294

    let mut fields_vec = core::mem::replace(

3295

        &mut model.fields,

3296

        ComponentDataFieldVec::from_const_slice(&[]),

3297

    ).into_library_owned_vec();

3298

3299

    for field in fields_vec.iter_mut() {

3300

        if let Some(attr_value) = xml_attributes.get_key(field.name.as_str()) {

3301

            // Override the default_value with the XML attribute's string value

3302

            field.default_value = OptionComponentDefaultValue::Some(

3303

                ComponentDefaultValue::String(attr_value.clone()),

3304

);

3305

3306

3307

3308

    model.fields = ComponentDataFieldVec::from_vec(fields_vec);

3309

3310

    // Handle text content — set the "text" field if present

3311

    if let Some(text) = text_content {

3312

        let prepared = prepare_string(text);

3313

        if !prepared.is_empty() {

3314

            model = model.with_default("text", ComponentDefaultValue::String(AzString::from(prepared.as_str())));

3315

3316

3317

3318

    model

3319

3320

3321

// ============================================================================

3322

// Structural builtin components: if, for, map

3323

// ============================================================================

3324

3325

/// `builtin:if` — conditional rendering.

3326

/// Takes `condition: Bool`, `then: StyledDom`, and optionally `else: StyledDom`.

3327

3150

fn builtin_if_component() -> ComponentDef {

3328

3150

    ComponentDef {

3329

3150

        id: ComponentId::builtin("if"),

3330

3150

        display_name: AzString::from_const_str("If"),

3331

3150

        description: AzString::from_const_str("Conditional rendering: shows 'then' if condition is true, else shows 'else' (if provided)."),

3332

3150

        css: AzString::from_const_str(""),

3333

3150

        source: ComponentSource::Builtin,

3334

3150

        data_model: ComponentDataModel {

3335

3150

            name: AzString::from_const_str("IfData"),

3336

3150

            description: AzString::from_const_str("Data for conditional rendering"),

3337

3150

            fields: alloc::vec![

3338

3150

                data_field("condition", ComponentFieldType::Bool, Some(ComponentDefaultValue::Bool(false)), "The boolean condition to evaluate"),

3339

3150

            ].into(),

3340

3150

},

3341

3150

        render_fn: builtin_if_render_fn,

3342

3150

        compile_fn: builtin_if_compile_fn,

3343

3150

        render_fn_source: None.into(),

3344

3150

        compile_fn_source: None.into(),

3345

3150

3346

3150

3347

3348

fn builtin_if_render_fn(

3349

    _comp: &ComponentDef,

3350

    data_model: &ComponentDataModel,

3351

    _component_map: &ComponentMap,

3352

) -> ResultStyledDomRenderDomError {

3353

    // Evaluate the condition field

3354

    let condition = data_model.fields.iter().find(|f| f.name.as_str() == "condition")

3355

        .and_then(|f| match &f.default_value { OptionComponentDefaultValue::Some(ComponentDefaultValue::Bool(b)) => Some(*b), _ => None })

3356

        .unwrap_or(false);

3357

3358

    let label = if condition { "if: true (then branch)" } else { "if: false (else branch)" };

3359

    let mut dom = Dom::create_node(NodeType::Div)

3360

        .with_children(alloc::vec![Dom::create_text(label)].into());

3361

    let css = Css::empty();

3362

    ResultStyledDomRenderDomError::Ok(StyledDom::create(&mut dom, css))

3363

3364

3365

fn builtin_if_compile_fn(

3366

    _comp: &ComponentDef,

3367

    target: &CompileTarget,

3368

    _data: &ComponentDataModel,

3369

    _indent: usize,

3370

) -> ResultStringCompileError {

3371

    match target {

3372

        CompileTarget::Rust => ResultStringCompileError::Ok(AzString::from(

3373

            "if data.condition {\n    // then branch\n    Dom::div()\n} else {\n    // else branch\n    Dom::div()\n}"

3374

)),

3375

        CompileTarget::C => ResultStringCompileError::Ok(AzString::from(

3376

            "if (data.condition) {\n    // then branch\n    AzDom_createDiv();\n} else {\n    // else branch\n    AzDom_createDiv();\n}"

3377

)),

3378

        CompileTarget::Cpp => ResultStringCompileError::Ok(AzString::from(

3379

            "if (data.condition) {\n    // then branch\n    Dom::div();\n} else {\n    // else branch\n    Dom::div();\n}"

3380

)),

3381

        CompileTarget::Python => ResultStringCompileError::Ok(AzString::from(

3382

            "if data.condition:\n    # then branch\n    Dom.div()\nelse:\n    # else branch\n    Dom.div()"

3383

)),

3384

3385

3386

3387

/// `builtin:for` — iterative rendering.

3388

/// Takes `count: U32` (number of iterations), renders children N times.

3389

3150

fn builtin_for_component() -> ComponentDef {

3390

3150

    ComponentDef {

3391

3150

        id: ComponentId::builtin("for"),

3392

3150

        display_name: AzString::from_const_str("For Loop"),

3393

3150

        description: AzString::from_const_str("Iterative rendering: repeats children 'count' times."),

3394

3150

        css: AzString::from_const_str(""),

3395

3150

        source: ComponentSource::Builtin,

3396

3150

        data_model: ComponentDataModel {

3397

3150

            name: AzString::from_const_str("ForData"),

3398

3150

            description: AzString::from_const_str("Data for iterative rendering"),

3399

3150

            fields: alloc::vec![

3400

3150

                data_field("count", ComponentFieldType::U32, Some(ComponentDefaultValue::U32(3)), "Number of iterations"),

3401

3150

            ].into(),

3402

3150

},

3403

3150

        render_fn: builtin_for_render_fn,

3404

3150

        compile_fn: builtin_for_compile_fn,

3405

3150

        render_fn_source: None.into(),

3406

3150

        compile_fn_source: None.into(),

3407

3150

3408

3150

3409

3410

fn builtin_for_render_fn(

3411

    _comp: &ComponentDef,

3412

    data_model: &ComponentDataModel,

3413

    _component_map: &ComponentMap,

3414

) -> ResultStyledDomRenderDomError {

3415

    let count = data_model.fields.iter().find(|f| f.name.as_str() == "count")

3416

        .and_then(|f| match &f.default_value { OptionComponentDefaultValue::Some(ComponentDefaultValue::U32(n)) => Some(*n), _ => None })

3417

        .unwrap_or(3);

3418

3419

    let mut items: alloc::vec::Vec<Dom> = alloc::vec::Vec::new();

3420

    for i in 0..count {

3421

        items.push(Dom::create_node(NodeType::Div)

3422

            .with_children(alloc::vec![Dom::create_text(alloc::format!("Item {}", i))].into()));

3423

3424

    let mut dom = Dom::create_node(NodeType::Div)

3425

        .with_children(items.into());

3426

    let css = Css::empty();

3427

    ResultStyledDomRenderDomError::Ok(StyledDom::create(&mut dom, css))

3428

3429

3430

fn builtin_for_compile_fn(

3431

    _comp: &ComponentDef,

3432

    target: &CompileTarget,

3433

    _data: &ComponentDataModel,

3434

    _indent: usize,

3435

) -> ResultStringCompileError {

3436

    match target {

3437

        CompileTarget::Rust => ResultStringCompileError::Ok(AzString::from(

3438

            "let mut children = Vec::new();\nfor i in 0..data.count {\n    children.push(Dom::div());\n}\nDom::div().with_children(children)"

3439

)),

3440

        CompileTarget::C => ResultStringCompileError::Ok(AzString::from(

3441

            "AzDom container = AzDom_createDiv();\nfor (uint32_t i = 0; i < data.count; i++) {\n    AzDom_addChild(&container, AzDom_createDiv());\n}"

3442

)),

3443

        CompileTarget::Cpp => ResultStringCompileError::Ok(AzString::from(

3444

            "auto container = Dom::div();\nfor (uint32_t i = 0; i < data.count; i++) {\n    container.add_child(Dom::div());\n}"

3445

)),

3446

        CompileTarget::Python => ResultStringCompileError::Ok(AzString::from(

3447

            "container = Dom.div()\nfor i in range(data.count):\n    container.add_child(Dom.div())"

3448

)),

3449

3450

3451

3452

/// `builtin:map` — map data to DOM.

3453

/// Takes `data_json: String` (JSON array) + maps each element.

3454

3150

fn builtin_map_component() -> ComponentDef {

3455

3150

    ComponentDef {

3456

3150

        id: ComponentId::builtin("map"),

3457

3150

        display_name: AzString::from_const_str("Map"),

3458

3150

        description: AzString::from_const_str("Map data to DOM: applies a template to each item in a collection."),

3459

3150

        css: AzString::from_const_str(""),

3460

3150

        source: ComponentSource::Builtin,

3461

3150

        data_model: ComponentDataModel {

3462

3150

            name: AzString::from_const_str("MapData"),

3463

3150

            description: AzString::from_const_str("Data for map rendering"),

3464

3150

            fields: alloc::vec![

3465

3150

                data_field("data_json", ComponentFieldType::String, Some(ComponentDefaultValue::String(AzString::from_const_str("[]"))), "JSON array of items to map over"),

3466

3150

            ].into(),

3467

3150

},

3468

3150

        render_fn: builtin_map_render_fn,

3469

3150

        compile_fn: builtin_map_compile_fn,

3470

3150

        render_fn_source: None.into(),

3471

3150

        compile_fn_source: None.into(),

3472

3150

3473

3150

3474

3475

fn builtin_map_render_fn(

3476

    _comp: &ComponentDef,

3477

    data_model: &ComponentDataModel,

3478

    _component_map: &ComponentMap,

3479

) -> ResultStyledDomRenderDomError {

3480

    // For now, render a placeholder — actual mapping requires callback support

3481

    let data_str = data_model.fields.iter().find(|f| f.name.as_str() == "data_json")

3482

        .and_then(|f| match &f.default_value { OptionComponentDefaultValue::Some(ComponentDefaultValue::String(s)) => Some(s.as_str().to_string()), _ => None })

3483

        .unwrap_or_else(|| "[]".to_string());

3484

3485

    let label = alloc::format!("map: data_json={}", data_str);

3486

    let mut dom = Dom::create_node(NodeType::Div)

3487

        .with_children(alloc::vec![Dom::create_text(label)].into());

3488

    let css = Css::empty();

3489

    ResultStyledDomRenderDomError::Ok(StyledDom::create(&mut dom, css))

3490

3491

3492

fn builtin_map_compile_fn(

3493

    _comp: &ComponentDef,

3494

    target: &CompileTarget,

3495

    _data: &ComponentDataModel,

3496

    _indent: usize,

3497

) -> ResultStringCompileError {

3498

    match target {

3499

        CompileTarget::Rust => ResultStringCompileError::Ok(AzString::from(

3500

            "let items: Vec<serde_json::Value> = serde_json::from_str(&data.data_json).unwrap_or_default();\nlet children: Vec<Dom> = items.iter().map(|item| {\n    Dom::div() // map template\n}).collect();\nDom::div().with_children(children)"

3501

)),

3502

        CompileTarget::C => ResultStringCompileError::Ok(AzString::from(

3503

            "// Parse data.data_json and map each item\nAzDom container = AzDom_createDiv();\n// TODO: iterate parsed JSON array"

3504

)),

3505

        CompileTarget::Cpp => ResultStringCompileError::Ok(AzString::from(

3506

            "// Parse data.data_json and map each item\nauto container = Dom::div();\n// TODO: iterate parsed JSON array"

3507

)),

3508

        CompileTarget::Python => ResultStringCompileError::Ok(AzString::from(

3509

            "import json\nitems = json.loads(data.data_json)\ncontainer = Dom.div()\nfor item in items:\n    container.add_child(Dom.div())"

3510

)),

3511

3512

3513

3514

/// Register the 52 built-in HTML element components.

3515

///

3516

/// This is an `extern "C"` function pointer compatible with

3517

/// `RegisterComponentLibraryFnType`, so it can be passed directly to

3518

/// `AppConfig::add_component_library()`.

3519

///

3520

/// Called once during `AppConfig::create()` — the framework dogfoods

3521

/// its own component registration system for builtins.

3522

3150

pub extern "C" fn register_builtin_components() -> ComponentLibrary {

3523

3150

    ComponentLibrary {

3524

3150

        name: AzString::from_const_str("builtin"),

3525

3150

        version: AzString::from_const_str("1.0.0"),

3526

3150

        description: AzString::from_const_str("Built-in HTML elements"),

3527

3150

        exportable: false,

3528

3150

        modifiable: false,

3529

3150

        data_models: Vec::new().into(),

3530

3150

        enum_models: Vec::new().into(),

3531

3150

        components: alloc::vec![

3532

3150

            // Structural

3533

3150

            builtin_component_def("html", "HTML", None, ""),

3534

3150

            builtin_component_def("head", "Head", None, ""),

3535

3150

            builtin_component_def("title", "Title", Some(""), ""),

3536

3150

            builtin_component_def("body", "Body", None, ""),

3537

3150

            // Block-level

3538

3150

            builtin_component_def("div", "Div", None, ""),

3539

3150

            builtin_component_def("header", "Header", None, ""),

3540

3150

            builtin_component_def("footer", "Footer", None, ""),

3541

3150

            builtin_component_def("section", "Section", None, ""),

3542

3150

            builtin_component_def("article", "Article", None, ""),

3543

3150

            builtin_component_def("aside", "Aside", None, ""),

3544

3150

            builtin_component_def("nav", "Nav", None, ""),

3545

3150

            builtin_component_def("main", "Main", None, ""),

3546

3150

            builtin_component_def("figure", "Figure", None, ""),

3547

3150

            builtin_component_def("figcaption", "Figure Caption", Some(""), ""),

3548

3150

            builtin_component_def("address", "Address", Some(""), ""),

3549

3150

            builtin_component_def("details", "Details", None, ""),

3550

3150

            builtin_component_def("summary", "Summary", Some("Details"), ""),

3551

3150

            builtin_component_def("dialog", "Dialog", None, ""),

3552

3150

            // Headings — default text is the heading level name so preview is visible

3553

3150

            builtin_component_def("h1", "Heading 1", Some("Heading 1"), ""),

3554

3150

            builtin_component_def("h2", "Heading 2", Some("Heading 2"), ""),

3555

3150

            builtin_component_def("h3", "Heading 3", Some("Heading 3"), ""),

3556

3150

            builtin_component_def("h4", "Heading 4", Some("Heading 4"), ""),

3557

3150

            builtin_component_def("h5", "Heading 5", Some("Heading 5"), ""),

3558

3150

            builtin_component_def("h6", "Heading 6", Some("Heading 6"), ""),

3559

3150

            // Text content

3560

3150

            builtin_component_def("p", "Paragraph", Some("Paragraph text"), ""),

3561

3150

            builtin_component_def("span", "Span", Some(""), ""),

3562

3150

            builtin_component_def("pre", "Preformatted", Some(""), ""),

3563

3150

            builtin_component_def("code", "Code", Some(""), ""),

3564

3150

            builtin_component_def("blockquote", "Blockquote", Some(""), ""),

3565

3150

            builtin_component_def("br", "Line Break", None, ""),

3566

3150

            builtin_component_def("hr", "Horizontal Rule", None, ""),

3567

3150

            builtin_component_def("icon", "Icon", Some(""), ""),

3568

3150

            // Lists

3569

3150

            builtin_component_def("ul", "Unordered List", None, ""),

3570

3150

            builtin_component_def("ol", "Ordered List", None, ""),

3571

3150

            builtin_component_def("li", "List Item", Some("List item"), ""),

3572

3150

            builtin_component_def("dl", "Description List", None, ""),

3573

3150

            builtin_component_def("dt", "Description Term", Some(""), ""),

3574

3150

            builtin_component_def("dd", "Description Details", Some(""), ""),

3575

3150

            builtin_component_def("menu", "Menu", None, ""),

3576

3150

            builtin_component_def("menuitem", "Menu Item", Some(""), ""),

3577

3150

            builtin_component_def("dir", "Directory List", None, ""),

3578

3150

            // Tables

3579

3150

            builtin_component_def("table", "Table", None, ""),

3580

3150

            builtin_component_def("caption", "Table Caption", Some(""), ""),

3581

3150

            builtin_component_def("thead", "Table Head", None, ""),

3582

3150

            builtin_component_def("tbody", "Table Body", None, ""),

3583

3150

            builtin_component_def("tfoot", "Table Foot", None, ""),

3584

3150

            builtin_component_def("tr", "Table Row", None, ""),

3585

3150

            builtin_component_def("th", "Table Header Cell", Some("Header"), ""),

3586

3150

            builtin_component_def("td", "Table Data Cell", Some(""), ""),

3587

3150

            builtin_component_def("colgroup", "Column Group", None, ""),

3588

3150

            builtin_component_def("col", "Column", None, ""),

3589

3150

            // Inline

3590

3150

            builtin_component_def("a", "Link", Some("Link text"), ""),

3591

3150

            builtin_component_def("strong", "Strong", Some(""), ""),

3592

3150

            builtin_component_def("em", "Emphasis", Some(""), ""),

3593

3150

            builtin_component_def("b", "Bold", Some(""), ""),

3594

3150

            builtin_component_def("i", "Italic", Some(""), ""),

3595

3150

            builtin_component_def("u", "Underline", Some(""), ""),

3596

3150

            builtin_component_def("s", "Strikethrough", Some(""), ""),

3597

3150

            builtin_component_def("small", "Small", Some(""), ""),

3598

3150

            builtin_component_def("mark", "Mark", Some(""), ""),

3599

3150

            builtin_component_def("del", "Deleted Text", Some(""), ""),

3600

3150

            builtin_component_def("ins", "Inserted Text", Some(""), ""),

3601

3150

            builtin_component_def("sub", "Subscript", Some(""), ""),

3602

3150

            builtin_component_def("sup", "Superscript", Some(""), ""),

3603

3150

            builtin_component_def("samp", "Sample Output", Some(""), ""),

3604

3150

            builtin_component_def("kbd", "Keyboard Input", Some(""), ""),

3605

3150

            builtin_component_def("var", "Variable", Some(""), ""),

3606

3150

            builtin_component_def("cite", "Citation", Some(""), ""),

3607

3150

            builtin_component_def("dfn", "Definition", Some(""), ""),

3608

3150

            builtin_component_def("abbr", "Abbreviation", Some(""), ""),

3609

3150

            builtin_component_def("acronym", "Acronym", Some(""), ""),

3610

3150

            builtin_component_def("q", "Inline Quote", Some(""), ""),

3611

3150

            builtin_component_def("time", "Time", Some(""), ""),

3612

3150

            builtin_component_def("big", "Big", Some(""), ""),

3613

3150

            builtin_component_def("bdo", "BiDi Override", Some(""), ""),

3614

3150

            builtin_component_def("bdi", "BiDi Isolate", Some(""), ""),

3615

3150

            builtin_component_def("wbr", "Word Break Opportunity", None, ""),

3616

3150

            builtin_component_def("ruby", "Ruby Annotation", None, ""),

3617

3150

            builtin_component_def("rt", "Ruby Text", Some(""), ""),

3618

3150

            builtin_component_def("rtc", "Ruby Text Container", None, ""),

3619

3150

            builtin_component_def("rp", "Ruby Parenthesis", Some(""), ""),

3620

3150

            builtin_component_def("data", "Data", Some(""), ""),

3621

3150

            // Forms

3622

3150

            builtin_component_def("form", "Form", None, ""),

3623

3150

            builtin_component_def("fieldset", "Field Set", None, ""),

3624

3150

            builtin_component_def("legend", "Legend", Some("Legend"), ""),

3625

3150

            builtin_component_def("label", "Label", Some("Label"), ""),

3626

3150

            builtin_component_def("input", "Input", None, ""),

3627

3150

            builtin_component_def("button", "Button", Some("Button text"), ""),

3628

3150

            builtin_component_def("select", "Select", None, ""),

3629

3150

            builtin_component_def("optgroup", "Option Group", None, ""),

3630

3150

            builtin_component_def("option", "Option", Some(""), ""),

3631

3150

            builtin_component_def("textarea", "Text Area", Some(""), ""),

3632

3150

            builtin_component_def("output", "Output", Some(""), ""),

3633

3150

            builtin_component_def("progress", "Progress", None, ""),

3634

3150

            builtin_component_def("meter", "Meter", None, ""),

3635

3150

            builtin_component_def("datalist", "Data List", None, ""),

3636

3150

            // Embedded content

3637

3150

            builtin_component_def("canvas", "Canvas", None, ""),

3638

3150

            builtin_component_def("object", "Object", None, ""),

3639

3150

            builtin_component_def("param", "Parameter", None, ""),

3640

3150

            builtin_component_def("embed", "Embed", None, ""),

3641

3150

            builtin_component_def("audio", "Audio", None, ""),

3642

3150

            builtin_component_def("video", "Video", None, ""),

3643

3150

            builtin_component_def("source", "Source", None, ""),

3644

3150

            builtin_component_def("track", "Track", None, ""),

3645

3150

            builtin_component_def("map", "Image Map", None, ""),

3646

3150

            builtin_component_def("area", "Map Area", None, ""),

3647

3150

            builtin_component_def("svg", "SVG", None, ""),

3648

3150

            // Metadata

3649

3150

            builtin_component_def("meta", "Meta", None, ""),

3650

3150

            builtin_component_def("link", "Link (Resource)", None, ""),

3651

3150

            builtin_component_def("script", "Script", Some(""), ""),

3652

3150

            builtin_component_def("style", "Style", Some(""), ""),

3653

3150

            builtin_component_def("base", "Base URL", None, ""),

3654

3150

            // Structural control-flow builtins (F1-F3)

3655

3150

            builtin_if_component(),

3656

3150

            builtin_for_component(),

3657

3150

            builtin_map_component(),

3658

3150

        ].into(),

3659

3150

3660

3150

3661

3662

// ============================================================================

3663

// End new component system types

3664

// ============================================================================

3665

3666

3667

/// Wrapper for the XML parser - necessary to easily create a Dom from

3668

/// XML without putting an XML solver into `azul-core`.

3669

#[derive(Default)]

3670

pub struct DomXml {

3671

    pub parsed_dom: StyledDom,

3672

3673

3674

impl DomXml {

3675

    /// Convenience function, only available in tests, useful for quickly writing UI tests.

3676

    /// Wraps the XML string in the required `<app></app>` braces, panics if the XML couldn't be

3677

    /// parsed.

3678

///

3679

    /// ## Example

3680

///

3681

    /// ```rust,ignore

3682

    /// # use azul::dom::Dom;

3683

    /// # use azul::xml::DomXml;

3684

    /// let dom = DomXml::mock("<div id='test' />");

3685

    /// dom.assert_eq(Dom::create_div().with_id("test"));

3686

    /// ```

3687

    #[cfg(test)]

3688

    pub fn assert_eq(self, other: StyledDom) {

3689

        let mut body = Dom::create_body();

3690

        let mut fixed = StyledDom::create(&mut body, Css::empty());

3691

        fixed.append_child(other);

3692

        if self.parsed_dom != fixed {

3693

            panic!(

3694

                "\r\nExpected DOM did not match:\r\n\r\nexpected: ----------\r\n{}\r\ngot: \

3695

                 ----------\r\n{}\r\n",

3696

                self.parsed_dom.get_html_string("", "", true),

3697

                fixed.get_html_string("", "", true)

3698

);

3699

3700

3701

3702

    pub fn into_styled_dom(self) -> StyledDom {

3703

        self.into()

3704

3705

3706

3707

impl From<DomXml> for StyledDom {

3708

    fn from(val: DomXml) -> Self {

3709

        val.parsed_dom

3710

3711

3712

3713

/// Represents a child of an XML node - either an element or text

3714

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

3715

#[repr(C, u8)]

3716

pub enum XmlNodeChild {

3717

    /// A text node

3718

    Text(AzString),

3719

    /// An element node

3720

    Element(XmlNode),

3721

3722

3723

impl_option!(

3724

    XmlNodeChild,

3725

    OptionXmlNodeChild,

3726

    copy = false,

3727

    [Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]

3728

);

3729

3730

impl XmlNodeChild {

3731

    /// Get the text content if this is a text node

3732

2313

    pub fn as_text(&self) -> Option<&str> {

3733

2313

        match self {

3734

2313

            XmlNodeChild::Text(s) => Some(s.as_str()),

3735

            XmlNodeChild::Element(_) => None,

3736

3737

2313

3738

3739

    /// Get the element if this is an element node

3740

2

    pub fn as_element(&self) -> Option<&XmlNode> {

3741

2

        match self {

3742

            XmlNodeChild::Text(_) => None,

3743

2

            XmlNodeChild::Element(node) => Some(node),

3744

3745

2

3746

3747

    /// Get the element mutably if this is an element node

3748

    pub fn as_element_mut(&mut self) -> Option<&mut XmlNode> {

3749

        match self {

3750

            XmlNodeChild::Text(_) => None,

3751

            XmlNodeChild::Element(node) => Some(node),

3752

3753

3754

3755

3756

impl_vec!(XmlNodeChild, XmlNodeChildVec, XmlNodeChildVecDestructor, XmlNodeChildVecDestructorType, XmlNodeChildVecSlice, OptionXmlNodeChild);

3757

impl_vec_mut!(XmlNodeChild, XmlNodeChildVec);

3758

impl_vec_debug!(XmlNodeChild, XmlNodeChildVec);

3759

impl_vec_partialeq!(XmlNodeChild, XmlNodeChildVec);

3760

impl_vec_eq!(XmlNodeChild, XmlNodeChildVec);

3761

impl_vec_partialord!(XmlNodeChild, XmlNodeChildVec);

3762

impl_vec_ord!(XmlNodeChild, XmlNodeChildVec);

3763

impl_vec_hash!(XmlNodeChild, XmlNodeChildVec);

3764

impl_vec_clone!(XmlNodeChild, XmlNodeChildVec, XmlNodeChildVecDestructor);

3765

3766

/// Represents one XML node tag

3767

#[derive(Default, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

3768

#[repr(C)]

3769

pub struct XmlNode {

3770

    /// Type of the node

3771

    pub node_type: XmlTagName,

3772

    /// Attributes of an XML node (note: not yet filtered and / or broken into function arguments!)

3773

    pub attributes: XmlAttributeMap,

3774

    /// Direct children of this node (can be text or element nodes)

3775

    pub children: XmlNodeChildVec,

3776

3777

3778

impl_option!(

3779

    XmlNode,

3780

    OptionXmlNode,

3781

    copy = false,

3782

    [Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]

3783

);

3784

3785

impl XmlNode {

3786

    pub fn create<I: Into<XmlTagName>>(node_type: I) -> Self {

3787

        XmlNode {

3788

            node_type: node_type.into(),

3789

            ..Default::default()

3790

3791

3792

    pub fn with_children(mut self, v: Vec<XmlNodeChild>) -> Self {

3793

        Self {

3794

            children: v.into(),

3795

            ..self

3796

3797

3798

3799

    /// Get all text content concatenated from direct children

3800

2310

    pub fn get_text_content(&self) -> String {

3801

2310

        self.children

3802

2310

            .as_ref()

3803

2310

            .iter()

3804

2310

            .filter_map(|child| child.as_text())

3805

2310

            .collect::<Vec<_>>()

3806

2310

            .join("")

3807

2310

3808

3809

    /// Check if this node has only text children (no element children)

3810

    pub fn has_only_text_children(&self) -> bool {

3811

        self.children

3812

            .as_ref()

3813

            .iter()

3814

            .all(|child| matches!(child, XmlNodeChild::Text(_)))

3815

3816

3817

3818

impl_vec!(XmlNode, XmlNodeVec, XmlNodeVecDestructor, XmlNodeVecDestructorType, XmlNodeVecSlice, OptionXmlNode);

3819

impl_vec_mut!(XmlNode, XmlNodeVec);

3820

impl_vec_debug!(XmlNode, XmlNodeVec);

3821

impl_vec_partialeq!(XmlNode, XmlNodeVec);

3822

impl_vec_eq!(XmlNode, XmlNodeVec);

3823

impl_vec_partialord!(XmlNode, XmlNodeVec);

3824

impl_vec_ord!(XmlNode, XmlNodeVec);

3825

impl_vec_hash!(XmlNode, XmlNodeVec);

3826

impl_vec_clone!(XmlNode, XmlNodeVec, XmlNodeVecDestructor);

3827

3828

#[derive(Debug, Clone, PartialEq)]

3829

#[repr(C, u8)]

3830

pub enum DomXmlParseError {

3831

    /// No `<html></html>` node component present

3832

    NoHtmlNode,

3833

    /// Multiple `<html>` nodes

3834

    MultipleHtmlRootNodes,

3835

    /// No ´<body></body>´ node in the root HTML

3836

    NoBodyInHtml,

3837

    /// The DOM can only have one <body> node, not multiple.

3838

    MultipleBodyNodes,

3839

    /// Note: Sadly, the error type can only be a string because xmlparser

3840

    /// returns all errors as strings. There is an open PR to fix

3841

    /// this deficiency, but since the XML parsing is only needed for

3842

    /// hot-reloading and compiling, it doesn't matter that much.

3843

    Xml(XmlError),

3844

    /// Invalid hierarchy close tags, i.e `<app></p></app>`

3845

    MalformedHierarchy(MalformedHierarchyError),

3846

    /// A component raised an error while rendering the DOM - holds the component name + error

3847

    /// string

3848

    RenderDom(RenderDomError),

3849

    /// Something went wrong while parsing an XML component

3850

    Component(ComponentParseError),

3851

    /// Error parsing global CSS in head node

3852

    Css(CssParseErrorOwned),

3853

3854

3855

impl From<XmlError> for DomXmlParseError {

3856

    fn from(e: XmlError) -> Self {

3857

        Self::Xml(e)

3858

3859

3860

3861

impl From<ComponentParseError> for DomXmlParseError {

3862

    fn from(e: ComponentParseError) -> Self {

3863

        Self::Component(e)

3864

3865

3866

3867

impl From<RenderDomError> for DomXmlParseError {

3868

    fn from(e: RenderDomError) -> Self {

3869

        Self::RenderDom(e)

3870

3871

3872

3873

impl From<CssParseErrorOwned> for DomXmlParseError {

3874

    fn from(e: CssParseErrorOwned) -> Self {

3875

        Self::Css(e)

3876

3877

3878

3879

/// Error that can happen from the translation from XML code to Rust code -

3880

/// stringified, since it is only used for printing and is not exposed in the public API

3881

#[derive(Debug, Clone, PartialEq)]

3882

#[repr(C, u8)]

3883

pub enum CompileError {

3884

    Dom(RenderDomError),

3885

    Xml(DomXmlParseError),

3886

    Css(CssParseErrorOwned),

3887

3888

3889

impl From<ComponentError> for CompileError {

3890

    fn from(e: ComponentError) -> Self {

3891

        CompileError::Dom(RenderDomError::Component(e))

3892

3893

3894

3895

impl From<CssParseErrorOwned> for CompileError {

3896

    fn from(e: CssParseErrorOwned) -> Self {

3897

        CompileError::Css(e)

3898

3899

3900

3901

impl<'a> fmt::Display for CompileError {

3902

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

3903

        use self::CompileError::*;

3904

        match self {

3905

            Dom(d) => write!(f, "{}", d),

3906

            Xml(s) => write!(f, "{}", s),

3907

            Css(s) => write!(f, "{}", s.to_shared()),

3908

3909

3910

3911

3912

impl From<RenderDomError> for CompileError {

3913

    fn from(e: RenderDomError) -> Self {

3914

        CompileError::Dom(e)

3915

3916

3917

3918

impl From<DomXmlParseError> for CompileError {

3919

    fn from(e: DomXmlParseError) -> Self {

3920

        CompileError::Xml(e)

3921

3922

3923

3924

/// Wrapper for UselessFunctionArgument error data.

3925

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

3926

#[repr(C)]

3927

pub struct UselessFunctionArgumentError {

3928

    pub component_name: AzString,

3929

    pub argument_name: AzString,

3930

    pub valid_args: StringVec,

3931

3932

3933

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

3934

#[repr(C, u8)]

3935

pub enum ComponentError {

3936

    /// While instantiating a component, a function argument

3937

    /// was encountered that the component won't use or react to.

3938

    UselessFunctionArgument(UselessFunctionArgumentError),

3939

    /// A certain node type can't be rendered, because the

3940

    /// renderer for this node is not available isn't available

3941

///

3942

    /// UnknownComponent(component_name)

3943

    UnknownComponent(AzString),

3944

3945

3946

#[derive(Debug, Clone, PartialEq)]

3947

#[repr(C, u8)]

3948

pub enum RenderDomError {

3949

    Component(ComponentError),

3950

    /// Error parsing the CSS on the component style

3951

    CssError(CssParseErrorOwned),

3952

3953

3954

impl From<ComponentError> for RenderDomError {

3955

    fn from(e: ComponentError) -> Self {

3956

        Self::Component(e)

3957

3958

3959

3960

impl From<CssParseErrorOwned> for RenderDomError {

3961

    fn from(e: CssParseErrorOwned) -> Self {

3962

        Self::CssError(e)

3963

3964

3965

3966

/// Wrapper for MissingType error data.

3967

#[derive(Debug, Clone, PartialEq)]

3968

#[repr(C)]

3969

pub struct MissingTypeError {

3970

    pub arg_pos: usize,

3971

    pub arg_name: AzString,

3972

3973

3974

/// Wrapper for WhiteSpaceInComponentName error data.

3975

#[derive(Debug, Clone, PartialEq)]

3976

#[repr(C)]

3977

pub struct WhiteSpaceInComponentNameError {

3978

    pub arg_pos: usize,

3979

    pub arg_name: AzString,

3980

3981

3982

/// Wrapper for WhiteSpaceInComponentType error data.

3983

#[derive(Debug, Clone, PartialEq)]

3984

#[repr(C)]

3985

pub struct WhiteSpaceInComponentTypeError {

3986

    pub arg_pos: usize,

3987

    pub arg_name: AzString,

3988

    pub arg_type: AzString,

3989

3990

3991

#[derive(Debug, Clone, PartialEq)]

3992

#[repr(C, u8)]

3993

pub enum ComponentParseError {

3994

    /// Given XmlNode is not a `<component />` node.

3995

    NotAComponent,

3996

    /// A `<component>` node does not have a `name` attribute.

3997

    UnnamedComponent,

3998

    /// Argument at position `usize` is either empty or has no name

3999

    MissingName(usize),

4000

    /// Argument at position `usize` with the name

4001

    /// `String` doesn't have a `: type`

4002

    MissingType(MissingTypeError),

4003

    /// Component name may not contain a whitespace

4004

    /// (probably missing a `:` between the name and the type)

4005

    WhiteSpaceInComponentName(WhiteSpaceInComponentNameError),

4006

    /// Component type may not contain a whitespace

4007

    /// (probably missing a `,` between the type and the next name)

4008

    WhiteSpaceInComponentType(WhiteSpaceInComponentTypeError),

4009

    /// Error parsing the <style> tag / CSS

4010

    CssError(CssParseErrorOwned),

4011

4012

4013

impl<'a> fmt::Display for DomXmlParseError {

4014

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

4015

        use self::DomXmlParseError::*;

4016

        match self {

4017

            NoHtmlNode => write!(

4018

f,

4019

                "No <html> node found as the root of the file - empty file?"

4020

),

4021

            MultipleHtmlRootNodes => write!(

4022

f,

4023

                "Multiple <html> nodes found as the root of the file - only one root node allowed"

4024

),

4025

            NoBodyInHtml => write!(

4026

f,

4027

                "No <body> node found as a direct child of an <html> node - malformed DOM \

4028

                 hierarchy?"

4029

),

4030

            MultipleBodyNodes => write!(

4031

f,

4032

                "Multiple <body> nodes present, only one <body> node is allowed"

4033

),

4034

            Xml(e) => write!(f, "Error parsing XML: {}", e),

4035

            MalformedHierarchy(e) => write!(

4036

f,

4037

                "Invalid </{}> tag: expected </{}>",

4038

                e.got.as_str(),

4039

                e.expected.as_str()

4040

),

4041

            RenderDom(e) => write!(f, "Error rendering DOM: {}", e),

4042

            Component(c) => write!(f, "Error parsing component in <head> node:\r\n{}", c),

4043

            Css(c) => write!(f, "Error parsing CSS in <head> node:\r\n{}", c.to_shared()),

4044

4045

4046

4047

4048

impl<'a> fmt::Display for ComponentParseError {

4049

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

4050

        use self::ComponentParseError::*;

4051

        match self {

4052

            NotAComponent => write!(f, "Expected <component/> node, found no such node"),

4053

            UnnamedComponent => write!(

4054

f,

4055

                "Found <component/> tag with out a \"name\" attribute, component must have a name"

4056

),

4057

            MissingName(arg_pos) => write!(

4058

f,

4059

                "Argument at position {} is either empty or has no name",

4060

                arg_pos

4061

),

4062

            MissingType(e) => write!(

4063

f,

4064

                "Argument \"{}\" at position {} doesn't have a `: type`",

4065

                e.arg_name, e.arg_pos

4066

),

4067

            WhiteSpaceInComponentName(e) => {

4068

                write!(

4069

f,

4070

                    "Missing `:` between the name and the type in argument {} (around \"{}\")",

4071

                    e.arg_pos, e.arg_name

4072

4073

4074

            WhiteSpaceInComponentType(e) => {

4075

                write!(

4076

f,

4077

                    "Missing `,` between two arguments (in argument {}, position {}, around \

4078

                     \"{}\")",

4079

                    e.arg_name, e.arg_pos, e.arg_type

4080

4081

4082

            CssError(lsf) => write!(f, "Error parsing <style> tag: {}", lsf.to_shared()),

4083

4084

4085

4086

4087

impl fmt::Display for ComponentError {

4088

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

4089

        use self::ComponentError::*;

4090

        match self {

4091

            UselessFunctionArgument(e) => {

4092

                write!(

4093

f,

4094

                    "Useless component argument \"{}\": \"{}\" - available args are: {:#?}",

4095

                    e.component_name, e.argument_name, e.valid_args

4096

4097

4098

            UnknownComponent(name) => write!(f, "Unknown component: \"{}\"", name),

4099

4100

4101

4102

4103

impl<'a> fmt::Display for RenderDomError {

4104

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

4105

        use self::RenderDomError::*;

4106

        match self {

4107

            Component(c) => write!(f, "{}", c),

4108

            CssError(e) => write!(f, "Error parsing CSS in component: {}", e.to_shared()),

4109

4110

4111

4112

4113

4114

/// Find the one and only `<body>` node, return error if

4115

/// there is no app node or there are multiple app nodes

4116

3150

pub fn get_html_node<'a>(root_nodes: &'a [XmlNodeChild]) -> Result<&'a XmlNode, DomXmlParseError> {

4117

3150

    let mut html_node_iterator = root_nodes.iter().filter_map(|child| {

4118

3150

        if let XmlNodeChild::Element(node) = child {

4119

3150

            let node_type_normalized = normalize_casing(&node.node_type);

4120

3150

            if &node_type_normalized == "html" {

4121

3150

                Some(node)

4122

            } else {

4123

                None

4124

4125

        } else {

4126

            None

4127

4128

3150

});

4129

4130

3150

    let html_node = html_node_iterator

4131

3150

        .next()

4132

3150

        .ok_or(DomXmlParseError::NoHtmlNode)?;

4133

3150

    if html_node_iterator.next().is_some() {

4134

        Err(DomXmlParseError::MultipleHtmlRootNodes)

4135

    } else {

4136

3150

        Ok(html_node)

4137

4138

3150

4139

4140

/// Find the one and only `<body>` node, return error if

4141

/// there is no app node or there are multiple app nodes

4142

3150

pub fn get_body_node<'a>(root_nodes: &'a [XmlNodeChild]) -> Result<&'a XmlNode, DomXmlParseError> {

4143

    // First try to find body as a direct child (proper HTML structure)

4144

7602

    let direct_body = root_nodes.iter().filter_map(|child| {

4145

7602

        if let XmlNodeChild::Element(node) = child {

4146

5460

            let node_type_normalized = normalize_casing(&node.node_type);

4147

5460

            if &node_type_normalized == "body" {

4148

3150

                Some(node)

4149

            } else {

4150

2310

                None

4151

4152

        } else {

4153

2142

            None

4154

4155

7602

    }).next();

4156

4157

3150

    if let Some(body) = direct_body {

4158

3150

        return Ok(body);

4159

4160

4161

    // If not found as direct child, search recursively (for malformed HTML like example.com)

4162

    // where <body> might be nested inside <head> due to missing </head> tag

4163

    fn find_body_recursive<'a>(nodes: &'a [XmlNodeChild]) -> Option<&'a XmlNode> {

4164

        for child in nodes {

4165

            if let XmlNodeChild::Element(node) = child {

4166

                let node_type_normalized = normalize_casing(&node.node_type);

4167

                if &node_type_normalized == "body" {

4168

                    return Some(node);

4169

4170

                // Recurse into children

4171

                if let Some(found) = find_body_recursive(node.children.as_ref()) {

4172

                    return Some(found);

4173

4174

4175

4176

        None

4177

4178

4179

    find_body_recursive(root_nodes).ok_or(DomXmlParseError::NoBodyInHtml)

4180

3150

4181

4182

/// Searches in the the `root_nodes` for a `node_type`, convenience function in order to

4183

/// for example find the first <blah /> node in all these nodes.

4184

/// This function searches recursively through the entire tree.

4185

8148

fn find_node_by_type<'a>(

4186

8148

    root_nodes: &'a [XmlNodeChild],

4187

8148

    node_type: &str,

4188

8148

) -> Option<&'a XmlNode> {

4189

    // First check direct children

4190

11382

    for child in root_nodes {

4191

7854

        if let XmlNodeChild::Element(node) = child {

4192

7308

            if normalize_casing(&node.node_type).as_str() == node_type {

4193

4620

                return Some(node);

4194

2688

4195

546

4196

4197

4198

    // If not found, search recursively (for malformed HTML)

4199

6510

    for child in root_nodes {

4200

2982

        if let XmlNodeChild::Element(node) = child {

4201

2688

            if let Some(found) = find_node_by_type(node.children.as_ref(), node_type) {

4202

                return Some(found);

4203

2688

4204

294

4205

4206

4207

3528

    None

4208

8148

4209

4210

pub fn find_attribute<'a>(node: &'a XmlNode, attribute: &str) -> Option<&'a AzString> {

4211

    node.attributes

4212

        .iter()

4213

        .find(|n| normalize_casing(&n.key.as_str()).as_str() == attribute)

4214

        .map(|s| &s.value)

4215

4216

4217

/// Normalizes input such as `abcDef`, `AbcDef`, `abc-def` to the normalized form of `abc_def`

4218

26209

pub fn normalize_casing(input: &str) -> String {

4219

26209

    let mut words: Vec<String> = Vec::new();

4220

26209

    let mut cur_str = Vec::new();

4221

4222

100509

    for ch in input.chars() {

4223

100509

        if ch.is_uppercase() || ch == '_' || ch == '-' {

4224

            if !cur_str.is_empty() {

4225

                words.push(cur_str.iter().collect());

4226

                cur_str.clear();

4227

4228

            if ch.is_uppercase() {

4229

                cur_str.extend(ch.to_lowercase());

4230

4231

100509

        } else {

4232

100509

            cur_str.extend(ch.to_lowercase());

4233

100509

4234

4235

4236

26209

    if !cur_str.is_empty() {

4237

26209

        words.push(cur_str.iter().collect());

4238

26209

        cur_str.clear();

4239

26209

4240

4241

26209

    words.join("_")

4242

26209

4243

4244

/// Given a root node, traverses along the hierarchy, and returns a

4245

/// mutable reference to the last child node of the root node

4246

#[allow(trivial_casts)]

4247

pub fn get_item<'a>(hierarchy: &[usize], root_node: &'a mut XmlNode) -> Option<&'a mut XmlNode> {

4248

    let mut hierarchy = hierarchy.to_vec();

4249

    hierarchy.reverse();

4250

    let item = match hierarchy.pop() {

4251

        Some(s) => s,

4252

        None => return Some(root_node),

4253

};

4254

    let child = root_node.children.as_mut().get_mut(item)?;

4255

    match child {

4256

        XmlNodeChild::Element(node) => get_item_internal(&mut hierarchy, node),

4257

        XmlNodeChild::Text(_) => None, // Can't traverse into text nodes

4258

4259

4260

4261

fn get_item_internal<'a>(

4262

    hierarchy: &mut Vec<usize>,

4263

    root_node: &'a mut XmlNode,

4264

) -> Option<&'a mut XmlNode> {

4265

    if hierarchy.is_empty() {

4266

        return Some(root_node);

4267

4268

    let cur_item = match hierarchy.pop() {

4269

        Some(s) => s,

4270

        None => return Some(root_node),

4271

};

4272

    let child = root_node.children.as_mut().get_mut(cur_item)?;

4273

    match child {

4274

        XmlNodeChild::Element(node) => get_item_internal(hierarchy, node),

4275

        XmlNodeChild::Text(_) => None, // Can't traverse into text nodes

4276

4277

4278

4279

/// Parses an XML string and returns a `StyledDom` with the components instantiated in the

4280

/// `<app></app>`

4281

3150

pub fn str_to_dom<'a>(

4282

3150

    root_nodes: &'a [XmlNodeChild],

4283

3150

    component_map: &'a ComponentMap,

4284

3150

    max_width: Option<f32>,

4285

3150

) -> Result<StyledDom, DomXmlParseError> {

4286

    // Delegate to the fast path (Dom::Fast / CompactDom arena).

4287

3150

    str_to_dom_fast(root_nodes, component_map, max_width)

4288

3150

4289

4290

/// Parse XML to StyledDom via arena-based FastDom (no tree intermediary).

4291

///

4292

/// **Note**: `str_to_dom()` now delegates to this function, so you can use

4293

/// either one. This function is kept for backward compatibility.

4294

3150

fn str_to_dom_fast<'a>(

4295

3150

    root_nodes: &'a [XmlNodeChild],

4296

3150

    component_map: &'a ComponentMap,

4297

3150

    max_width: Option<f32>,

4298

3150

) -> Result<StyledDom, DomXmlParseError> {

4299

3150

    let html_node = get_html_node(root_nodes)?;

4300

3150

    let body_node = get_body_node(html_node.children.as_ref())?;

4301

4302

3150

    let mut global_style = None;

4303

4304

3150

    if let Some(head_node) = find_node_by_type(html_node.children.as_ref(), "head") {

4305

2310

        if let Some(style_node) = find_node_by_type(head_node.children.as_ref(), "style") {

4306

2310

            let text = style_node.get_text_content();

4307

2310

            if !text.is_empty() {

4308

2310

                let parsed_css = Css::from_string(text.into());

4309

2310

                global_style = Some(parsed_css);

4310

2310

4311

4312

840

4313

4314

3150

    render_dom_from_body_node_fast(&body_node, global_style, component_map, max_width)

4315

3150

        .map_err(|e| e.into())

4316

3150

4317

4318

/// Parses XML nodes and returns a `Dom` with CSS stylesheets attached (but not applied).

4319

///

4320

/// Unlike `str_to_dom` which returns a fully styled `StyledDom`, this function

4321

/// returns an unstyled `Dom` whose `css` field carries the parsed `<style>` rules.

4322

/// The layout framework will apply the CSS during the cascade pass.

4323

///

4324

/// This is the correct function for building a `Dom` from XML in layout callbacks

4325

/// (which must return `Dom`, not `StyledDom`).

4326

pub fn str_to_dom_unstyled<'a>(

4327

    root_nodes: &'a [XmlNodeChild],

4328

    component_map: &'a ComponentMap,

4329

) -> Result<Dom, DomXmlParseError> {

4330

    let html_node = get_html_node(root_nodes)?;

4331

    let body_node = get_body_node(html_node.children.as_ref())?;

4332

4333

    let mut global_style = None;

4334

4335

    if let Some(head_node) = find_node_by_type(html_node.children.as_ref(), "head") {

4336

        if let Some(style_node) = find_node_by_type(head_node.children.as_ref(), "style") {

4337

            let text = style_node.get_text_content();

4338

            if !text.is_empty() {

4339

                let parsed_css = Css::from_string(text.into());

4340

                global_style = Some(parsed_css);

4341

4342

4343

4344

4345

    // Build the DOM tree from the body node

4346

    let body_dom = xml_node_to_dom_fast(&body_node, component_map, false)

4347

        .map_err(|e| DomXmlParseError::from(e))?;

4348

4349

    // Wrap in proper HTML structure

4350

    use crate::dom::NodeType;

4351

    let root_node_type = body_dom.root.node_type.clone();

4352

4353

    let mut full_dom = match root_node_type {

4354

        NodeType::Html => body_dom,

4355

        NodeType::Body => Dom::create_html().with_child(body_dom),

4356

        _ => {

4357

            let body_wrapper = Dom::create_body().with_child(body_dom);

4358

            Dom::create_html().with_child(body_wrapper)

4359

4360

};

4361

4362

    // Attach CSS to the Dom's css field instead of applying it immediately

4363

    if let Some(css) = global_style {

4364

        let mut css_vec: Vec<Css> = Vec::new();

4365

        css_vec.push(css);

4366

        full_dom.css = css_vec.into();

4367

4368

4369

    Ok(full_dom)

4370

4371

4372

/// Parses an XML string and returns a `String`, which contains the Rust source code

4373

/// (i.e. it compiles the XML to valid Rust)

4374

pub fn str_to_rust_code<'a>(

4375

    root_nodes: &'a [XmlNodeChild],

4376

    imports: &str,

4377

    component_map: &'a ComponentMap,

4378

) -> Result<String, CompileError> {

4379

    let html_node = get_html_node(&root_nodes)?;

4380

    let body_node = get_body_node(html_node.children.as_ref())?;

4381

    let mut global_style = Css::empty();

4382

4383

    if let Some(head_node) = find_node_by_type(html_node.children.as_ref(), "head") {

4384

        if let Some(style_node) = find_node_by_type(head_node.children.as_ref(), "style") {

4385

            let text = style_node.get_text_content();

4386

            if !text.is_empty() {

4387

                let parsed_css = azul_css::parser2::new_from_str(&text).0;

4388

                global_style = parsed_css;

4389

4390

4391

4392

4393

    global_style.sort_by_specificity();

4394

4395

    let mut css_blocks = BTreeMap::new();

4396

    let mut extra_blocks = VecContents::default();

4397

    let app_source = compile_body_node_to_rust_code(

4398

        &body_node,

4399

        component_map,

4400

        &mut extra_blocks,

4401

        &mut css_blocks,

4402

        &global_style,

4403

        CssMatcher {

4404

            path: Vec::new(),

4405

            indices_in_parent: vec![0],

4406

            children_length: vec![body_node.children.as_ref().len()],

4407

},

4408

)?;

4409

4410

    let app_source = app_source

4411

        .lines()

4412

        .map(|l| format!("        {}", l))

4413

        .collect::<Vec<String>>()

4414

        .join("\r\n");

4415

4416

    let t = "    ";

4417

    let css_blocks = css_blocks

4418

        .iter()

4419

        .map(|(k, v)| {

4420

            let v = v

4421

                .lines()

4422

                .map(|l| format!("{}{}{}", t, t, l))

4423

                .collect::<Vec<String>>()

4424

                .join("\r\n");

4425

4426

            format!(

4427

                "    const {}_PROPERTIES: &[NodeDataInlineCssProperty] = \

4428

                 &[\r\n{}\r\n{}];\r\n{}const {}: NodeDataInlineCssPropertyVec = \

4429

                 NodeDataInlineCssPropertyVec::from_const_slice({}_PROPERTIES);",

4430

                k, v, t, t, k, k

4431

4432

})

4433

        .collect::<Vec<_>>()

4434

        .join(&format!("{}\r\n\r\n", t));

4435

4436

    let mut extra_block_string = extra_blocks.format(1);

4437

4438

    let main_func = "

4439

4440

use azul::{

4441

    app::{App, AppConfig, LayoutSolver},

4442

    css::Css,

4443

    dom::Dom,

4444

    callbacks::{RefAny, LayoutCallbackInfo},

4445

    window::{WindowCreateOptions, WindowFrame},

4446

};

4447

4448

struct Data { }

4449

4450

extern \"C\" fn render(_: RefAny, _: LayoutCallbackInfo) -> Dom {

4451

    let dom = crate::ui::render();

4452

    dom.with_component_css(Css::empty()) // styles are applied inline

4453

4454

4455

fn main() {

4456

    let app = App::new(RefAny::new(Data { }), AppConfig::new(LayoutSolver::Default));

4457

    let mut window = WindowCreateOptions::new(render);

4458

    window.state.flags.frame = WindowFrame::Maximized;

4459

    app.run(window);

4460

}";

4461

4462

    let source_code = format!(

4463

        "#![windows_subsystem = \"windows\"]\r\n//! Auto-generated UI source \

4464

         code\r\n{}\r\n{}\r\n\r\n{}{}",

4465

        imports,

4466

        compile_components(Vec::new()), // no user-defined components to compile

4467

        format!(

4468

            "#[allow(unused_imports)]\r\npub mod ui {{

4469

4470

    pub use crate::components::*;

4471

4472

    use azul::css::*;

4473

    use azul::str::String as AzString;

4474

    use azul::vec::{{

4475

        DomVec, IdOrClassVec, NodeDataInlineCssPropertyVec,

4476

        StyleBackgroundSizeVec, StyleBackgroundRepeatVec,

4477

        StyleBackgroundContentVec, StyleTransformVec,

4478

        StyleFontFamilyVec, StyleBackgroundPositionVec,

4479

        NormalizedLinearColorStopVec, NormalizedRadialColorStopVec,

4480

}};

4481

    use azul::dom::{{

4482

        Dom, IdOrClass, TabIndex,

4483

        IdOrClass::{{Id, Class}},

4484

        NodeDataInlineCssProperty,

4485

    }};\r\n\r\n{}\r\n\r\n{}

4486

4487

    pub fn render() -> Dom {{\r\n{}\r\n    }}\r\n}}",

4488

            extra_block_string, css_blocks, app_source

4489

),

4490

        main_func,

4491

);

4492

4493

    Ok(source_code)

4494

4495

4496

// Compile all components to source code

4497

fn compile_components(

4498

    components: Vec<(

4499

        ComponentName,

4500

        CompiledComponent,

4501

        ComponentArguments,

4502

        BTreeMap<String, String>,

4503

)>,

4504

) -> String {

4505

    let cs = components

4506

        .iter()

4507

        .map(|(name, function_body, function_args, css_blocks)| {

4508

            let name = &normalize_casing(&name);

4509

            let f = compile_component(name, function_args, function_body)

4510

                .lines()

4511

                .map(|l| format!("    {}", l))

4512

                .collect::<Vec<String>>()

4513

                .join("\r\n");

4514

4515

            // let css_blocks = ...

4516

4517

            format!(

4518

                "#[allow(unused_imports)]\r\npub mod {} {{\r\n    use azul::dom::Dom;\r\n    use \

4519

                 azul::str::String as AzString;\r\n{}\r\n}}",

4520

                name, f

4521

4522

})

4523

        .collect::<Vec<String>>()

4524

        .join("\r\n\r\n");

4525

4526

    let cs = cs

4527

        .lines()

4528

        .map(|l| format!("    {}", l))

4529

        .collect::<Vec<String>>()

4530

        .join("\r\n");

4531

4532

    if cs.is_empty() {

4533

cs

4534

    } else {

4535

        format!("pub mod components {{\r\n{}\r\n}}", cs)

4536

4537

4538

4539

fn format_component_args(component_args: &ComponentArgumentVec) -> String {

4540

    let mut args = component_args

4541

        .iter()

4542

        .map(|a| format!("{}: {}", a.name, a.arg_type))

4543

        .collect::<Vec<String>>();

4544

4545

    args.sort_by(|a, b| b.cmp(&a));

4546

4547

    args.join(", ")

4548

4549

4550

pub fn compile_component(

4551

    component_name: &str,

4552

    component_args: &ComponentArguments,

4553

    component_function_body: &str,

4554

) -> String {

4555

    let component_name = &normalize_casing(&component_name);

4556

    let function_args = format_component_args(&component_args.args);

4557

    let component_function_body = component_function_body

4558

        .lines()

4559

        .map(|l| format!("    {}", l))

4560

        .collect::<Vec<String>>()

4561

        .join("\r\n");

4562

    let should_inline = component_function_body.lines().count() == 1;

4563

    format!(

4564

        "{}pub fn render({}{}{}) -> Dom {{\r\n{}\r\n}}",

4565

        if should_inline { "#[inline]\r\n" } else { "" },

4566

        // pass the text content as the first

4567

        if component_args.accepts_text {

4568

            "text: AzString"

4569

        } else {

4570

""

4571

},

4572

        if function_args.is_empty() || !component_args.accepts_text {

4573

""

4574

        } else {

4575

            ", "

4576

},

4577

        function_args,

4578

        component_function_body,

4579

4580

4581

4582

/// Parse an SVG numeric attribute value to f32.

4583

2646

fn parse_svg_float(attr: Option<&AzString>) -> Option<f32> {

4584

2646

    attr?.as_str().trim().parse::<f32>().ok()

4585

2646

4586

4587

/// Parse an SVG `points` attribute (used by `<polygon>` and `<polyline>`).

4588

126

fn parse_svg_points(pts: &str, close: bool) -> Option<crate::svg::SvgMultiPolygon> {

4589

126

    let nums: Vec<f32> = pts

4590

2268

        .split(|c: char| c == ',' || c.is_ascii_whitespace())

4591

840

        .filter(|s| !s.is_empty())

4592

840

        .filter_map(|s| s.parse::<f32>().ok())

4593

126

        .collect();

4594

126

    if nums.len() < 4 || nums.len() % 2 != 0 {

4595

        return None;

4596

126

4597

126

    let mut elements = Vec::new();

4598

126

    let points: Vec<azul_css::props::basic::SvgPoint> = nums

4599

126

        .chunks_exact(2)

4600

420

        .map(|c| azul_css::props::basic::SvgPoint { x: c[0], y: c[1] })

4601

126

        .collect();

4602

294

    for w in points.windows(2) {

4603

294

        elements.push(crate::svg::SvgPathElement::Line(crate::svg::SvgLine::new(w[0], w[1])));

4604

294

4605

126

    if close && points.len() >= 2 {

4606

84

        let first = points[0];

4607

84

        let last = *points.last().unwrap();

4608

84

        if (first.x - last.x).abs() > 0.001 || (first.y - last.y).abs() > 0.001 {

4609

84

            elements.push(crate::svg::SvgPathElement::Line(crate::svg::SvgLine::new(last, first)));

4610

84

4611

42

4612

126

    Some(crate::svg::SvgMultiPolygon {

4613

126

        rings: crate::svg::SvgPathVec::from_vec(vec![

4614

126

            crate::svg::SvgPath {

4615

126

                items: crate::svg::SvgPathElementVec::from_vec(elements),

4616

126

4617

126

]),

4618

126

})

4619

126

4620

4621

/// Fast XML to Dom conversion that builds Dom tree directly without intermediate StyledDom

4622

/// This is O(n) instead of O(n²) for large documents

4623

1

fn xml_node_to_dom_fast<'a>(

4624

1

    xml_node: &'a XmlNode,

4625

1

    component_map: &'a ComponentMap,

4626

1

    inside_svg: bool,

4627

1

) -> Result<Dom, RenderDomError> {

4628

    use crate::dom::{Dom, NodeType, IdOrClass, TabIndex};

4629

4630

1

    let component_name = normalize_casing(&xml_node.node_type);

4631

4632

    // Look up the component definition

4633

1

    let node_type = tag_to_node_type(&component_name);

4634

1

    let mut dom = Dom::create_node(node_type);

4635

4636

    // `<img src="...">`: rebuild the placeholder Image node so its `NullImage`

4637

    // carries the `src` string (as UTF-8 bytes in `tag`). The bytes are NOT

4638

    // resolved here — a downstream renderer (printpdf, the compositor, ...) uses

4639

    // the tag to look up and embed the actual image. Optional `width`/`height`

4640

    // attributes set the intrinsic size used for layout (CSS still overrides).

4641

1

    if component_name == "img" {

4642

1

        if let Some(src) = xml_node.attributes.get_key("src") {

4643

1

            let width = xml_node

4644

1

                .attributes

4645

1

                .get_key("width")

4646

1

                .and_then(|w| w.as_str().trim().trim_end_matches("px").trim().parse::<usize>().ok())

4647

1

                .unwrap_or(0);

4648

1

            let height = xml_node

4649

1

                .attributes

4650

1

                .get_key("height")

4651

1

                .and_then(|h| h.as_str().trim().trim_end_matches("px").trim().parse::<usize>().ok())

4652

1

                .unwrap_or(0);

4653

1

            let image_ref = crate::resources::ImageRef::null_image(

4654

1

                width,

4655

1

                height,

4656

1

                crate::resources::RawImageFormat::RGBA8,

4657

1

                src.as_str().as_bytes().to_vec(),

4658

);

4659

1

            dom.root.set_node_type(NodeType::Image(azul_css::css::BoxOrStatic::heap(image_ref)));

4660

4661

4662

4663

    // Set id and class attributes

4664

1

    let mut ids_and_classes = Vec::new();

4665

1

    if let Some(id_str) = xml_node.attributes.get_key("id") {

4666

        for id in id_str.split_whitespace() {

4667

            ids_and_classes.push(IdOrClass::Id(id.into()));

4668

4669

1

4670

1

    if let Some(class_str) = xml_node.attributes.get_key("class") {

4671

        for class in class_str.split_whitespace() {

4672

            ids_and_classes.push(IdOrClass::Class(class.into()));

4673

4674

1

4675

1

    if !ids_and_classes.is_empty() {

4676

        dom.root.set_ids_and_classes(ids_and_classes.into());

4677

1

4678

4679

    // Handle focusable attribute

4680

1

    if let Some(focusable) = xml_node.attributes.get_key("focusable").and_then(|f| parse_bool(f.as_str())) {

4681

        match focusable {

4682

            true => dom.root.set_tab_index(TabIndex::Auto),

4683

            false => dom.root.set_tab_index(TabIndex::NoKeyboardFocus),

4684

4685

1

4686

4687

    // Handle tabindex attribute

4688

1

    if let Some(tab_index) = xml_node.attributes.get_key("tabindex").and_then(|val| val.parse::<isize>().ok()) {

4689

        match tab_index {

4690

            0 => dom.root.set_tab_index(TabIndex::Auto),

4691

            i if i > 0 => dom.root.set_tab_index(TabIndex::OverrideInParent(i as u32)),

4692

            _ => dom.root.set_tab_index(TabIndex::NoKeyboardFocus),

4693

4694

1

4695

4696

    // Handle inline style attribute

4697

1

    if let Some(style) = xml_node.attributes.get_key("style") {

4698

        let css_key_map = azul_css::props::property::get_css_key_map();

4699

        let mut attributes = Vec::new();

4700

        for s in style.as_str().split(";") {

4701

            let mut s = s.split(":");

4702

            let key = match s.next() { Some(s) => s, None => continue };

4703

            let value = match s.next() { Some(s) => s, None => continue };

4704

            let _ = azul_css::parser2::parse_css_declaration(

4705

                key.trim(), value.trim(),

4706

                azul_css::parser2::ErrorLocationRange::default(),

4707

                &css_key_map, &mut Vec::new(), &mut attributes,

4708

);

4709

4710

        let props = attributes.into_iter().filter_map(|s| {

4711

            use azul_css::dynamic_selector::CssPropertyWithConditions;

4712

            match s {

4713

                CssDeclaration::Static(s) => Some(CssPropertyWithConditions::simple(s)),

4714

                _ => None,

4715

4716

        }).collect::<Vec<_>>();

4717

        if !props.is_empty() {

4718

            dom.root.set_css_props(props.into());

4719

4720

1

4721

4722

    // Handle SVG shape elements when inside an <svg> context

4723

1

    let tag = component_name.as_str();

4724

1

    let child_inside_svg = inside_svg || tag == "svg";

4725

1

    let is_svg_shape = inside_svg && matches!(tag, "path" | "circle" | "rect" | "ellipse" | "line" | "polygon" | "polyline");

4726

4727

1

    if is_svg_shape {

4728

        let clip = match tag {

4729

            "path" => {

4730

                xml_node.attributes.get_key("d").and_then(|d| {

4731

                    crate::svg_path_parser::parse_svg_path_d(d.as_str()).ok()

4732

})

4733

4734

            "circle" => {

4735

                let cx = parse_svg_float(xml_node.attributes.get_key("cx")).unwrap_or(0.0);

4736

                let cy = parse_svg_float(xml_node.attributes.get_key("cy")).unwrap_or(0.0);

4737

                let r = parse_svg_float(xml_node.attributes.get_key("r")).unwrap_or(0.0);

4738

                if r > 0.0 {

4739

                    Some(crate::svg::SvgMultiPolygon {

4740

                        rings: crate::svg::SvgPathVec::from_vec(vec![

4741

                            crate::svg_path_parser::svg_circle_to_paths(cx, cy, r)

4742

]),

4743

})

4744

                } else {

4745

                    None

4746

4747

4748

            "rect" => {

4749

                let x = parse_svg_float(xml_node.attributes.get_key("x")).unwrap_or(0.0);

4750

                let y = parse_svg_float(xml_node.attributes.get_key("y")).unwrap_or(0.0);

4751

                let w = parse_svg_float(xml_node.attributes.get_key("width")).unwrap_or(0.0);

4752

                let h = parse_svg_float(xml_node.attributes.get_key("height")).unwrap_or(0.0);

4753

                let rx = parse_svg_float(xml_node.attributes.get_key("rx")).unwrap_or(0.0);

4754

                let ry = parse_svg_float(xml_node.attributes.get_key("ry")).unwrap_or(rx);

4755

                if w > 0.0 && h > 0.0 {

4756

                    Some(crate::svg::SvgMultiPolygon {

4757

                        rings: crate::svg::SvgPathVec::from_vec(vec![

4758

                            crate::svg_path_parser::svg_rect_to_path(x, y, w, h, rx, ry)

4759

]),

4760

})

4761

                } else {

4762

                    None

4763

4764

4765

            "ellipse" => {

4766

                let cx = parse_svg_float(xml_node.attributes.get_key("cx")).unwrap_or(0.0);

4767

                let cy = parse_svg_float(xml_node.attributes.get_key("cy")).unwrap_or(0.0);

4768

                let rx = parse_svg_float(xml_node.attributes.get_key("rx")).unwrap_or(0.0);

4769

                let ry = parse_svg_float(xml_node.attributes.get_key("ry")).unwrap_or(0.0);

4770

                if rx > 0.0 && ry > 0.0 {

4771

                    // Approximate ellipse with 4 cubic beziers (using rx for x-kappa, ry for y-kappa)

4772

                    use azul_css::props::basic::{SvgPoint, SvgCubicCurve};

4773

                    const KAPPA: f32 = 0.5522847498;

4774

                    let kx = rx * KAPPA;

4775

                    let ky = ry * KAPPA;

4776

                    let elements = vec![

4777

                        crate::svg::SvgPathElement::CubicCurve(SvgCubicCurve {

4778

                            start: SvgPoint { x: cx, y: cy - ry },

4779

                            ctrl_1: SvgPoint { x: cx + kx, y: cy - ry },

4780

                            ctrl_2: SvgPoint { x: cx + rx, y: cy - ky },

4781

                            end: SvgPoint { x: cx + rx, y: cy },

4782

}),

4783

                        crate::svg::SvgPathElement::CubicCurve(SvgCubicCurve {

4784

                            start: SvgPoint { x: cx + rx, y: cy },

4785

                            ctrl_1: SvgPoint { x: cx + rx, y: cy + ky },

4786

                            ctrl_2: SvgPoint { x: cx + kx, y: cy + ry },

4787

                            end: SvgPoint { x: cx, y: cy + ry },

4788

}),

4789

                        crate::svg::SvgPathElement::CubicCurve(SvgCubicCurve {

4790

                            start: SvgPoint { x: cx, y: cy + ry },

4791

                            ctrl_1: SvgPoint { x: cx - kx, y: cy + ry },

4792

                            ctrl_2: SvgPoint { x: cx - rx, y: cy + ky },

4793

                            end: SvgPoint { x: cx - rx, y: cy },

4794

}),

4795

                        crate::svg::SvgPathElement::CubicCurve(SvgCubicCurve {

4796

                            start: SvgPoint { x: cx - rx, y: cy },

4797

                            ctrl_1: SvgPoint { x: cx - rx, y: cy - ky },

4798

                            ctrl_2: SvgPoint { x: cx - kx, y: cy - ry },

4799

                            end: SvgPoint { x: cx, y: cy - ry },

4800

}),

4801

];

4802

                    Some(crate::svg::SvgMultiPolygon {

4803

                        rings: crate::svg::SvgPathVec::from_vec(vec![

4804

                            crate::svg::SvgPath { items: crate::svg::SvgPathElementVec::from_vec(elements) }

4805

]),

4806

})

4807

                } else {

4808

                    None

4809

4810

4811

            "line" => {

4812

                let x1 = parse_svg_float(xml_node.attributes.get_key("x1")).unwrap_or(0.0);

4813

                let y1 = parse_svg_float(xml_node.attributes.get_key("y1")).unwrap_or(0.0);

4814

                let x2 = parse_svg_float(xml_node.attributes.get_key("x2")).unwrap_or(0.0);

4815

                let y2 = parse_svg_float(xml_node.attributes.get_key("y2")).unwrap_or(0.0);

4816

                Some(crate::svg::SvgMultiPolygon {

4817

                    rings: crate::svg::SvgPathVec::from_vec(vec![

4818

                        crate::svg::SvgPath {

4819

                            items: crate::svg::SvgPathElementVec::from_vec(vec![

4820

                                crate::svg::SvgPathElement::Line(crate::svg::SvgLine::new(

4821

                                    azul_css::props::basic::SvgPoint { x: x1, y: y1 },

4822

                                    azul_css::props::basic::SvgPoint { x: x2, y: y2 },

4823

))

4824

]),

4825

4826

]),

4827

})

4828

4829

            "polygon" | "polyline" => {

4830

                xml_node.attributes.get_key("points").and_then(|pts| {

4831

                    parse_svg_points(pts.as_str(), tag == "polygon")

4832

})

4833

4834

            _ => None,

4835

};

4836

4837

        if let Some(mp) = clip {

4838

            dom.root.set_svg_data(crate::dom::SvgNodeData::Path(mp));

4839

4840

4841

1

4842

4843

    // Recursively convert children

4844

1

    let mut children = Vec::new();

4845

1

    for child in xml_node.children.as_ref().iter() {

4846

        match child {

4847

            XmlNodeChild::Element(child_node) => {

4848

                let child_dom = xml_node_to_dom_fast(child_node, component_map, child_inside_svg)?;

4849

                children.push(child_dom);

4850

4851

            XmlNodeChild::Text(text) => {

4852

                let text_dom = Dom::create_text(AzString::from(text.as_str()));

4853

                children.push(text_dom);

4854

4855

4856

4857

4858

1

    if !children.is_empty() {

4859

        dom = dom.with_children(children.into());

4860

1

4861

4862

1

    Ok(dom)

4863

1

4864

4865

/// Builder for arena-based DOM construction (FastDom).

4866

/// Builds two parallel Vecs (hierarchy + node_data) in a single DFS pass.

4867

pub struct CompactDomBuilder {

4868

    hierarchy: Vec<crate::styled_dom::NodeHierarchyItem>,

4869

    node_data: Vec<crate::dom::NodeData>,

4870

    css: Vec<crate::dom::CssWithNodeId>,

4871

    /// Stack of (node_index, previous_child_index) for open elements

4872

    stack: Vec<(usize, Option<usize>)>,

4873

4874

4875

impl CompactDomBuilder {

4876

3150

    pub fn new() -> Self {

4877

3150

        Self {

4878

3150

            hierarchy: Vec::new(),

4879

3150

            node_data: Vec::new(),

4880

3150

            css: Vec::new(),

4881

3150

            stack: Vec::new(),

4882

3150

4883

3150

4884

4885

    pub fn with_capacity(cap: usize) -> Self {

4886

        Self {

4887

            hierarchy: Vec::with_capacity(cap),

4888

            node_data: Vec::with_capacity(cap),

4889

            css: Vec::new(),

4890

            stack: Vec::new(),

4891

4892

4893

4894

    /// Open a new element node. Must be paired with `close_node()`.

4895

20454

    pub fn open_node(&mut self, node_data: crate::dom::NodeData) {

4896

        use crate::id::NodeId;

4897

        use crate::styled_dom::NodeHierarchyItem;

4898

4899

20454

        let idx = self.hierarchy.len();

4900

4901

        // Determine parent from stack

4902

20454

        let parent_raw = if let Some(&(parent_idx, _)) = self.stack.last() {

4903

17304

            NodeId::into_raw(&Some(NodeId::new(parent_idx)))

4904

        } else {

4905

3150

            0 // No parent (root)

4906

};

4907

4908

        // Determine previous sibling from parent's last child tracking

4909

20454

        let prev_sibling_raw = if let Some(&(_, prev_child)) = self.stack.last() {

4910

17304

            prev_child.map(|pi| NodeId::into_raw(&Some(NodeId::new(pi)))).unwrap_or(0)

4911

        } else {

4912

3150

4913

};

4914

4915

        // If there's a previous sibling, set its next_sibling to us

4916

20454

        if let Some(&(_, Some(prev_idx))) = self.stack.last() {

4917

7560

            self.hierarchy[prev_idx].next_sibling = NodeId::into_raw(&Some(NodeId::new(idx)));

4918

12894

4919

4920

        // Update parent's "last seen child" to us

4921

20454

        if let Some(parent) = self.stack.last_mut() {

4922

17304

            parent.1 = Some(idx);

4923

17304

4924

4925

        // Push the hierarchy item (last_child will be set in close_node)

4926

20454

        self.hierarchy.push(NodeHierarchyItem {

4927

20454

            parent: parent_raw,

4928

20454

            previous_sibling: prev_sibling_raw,

4929

20454

            next_sibling: 0, // Will be set by next sibling's open_node

4930

20454

            last_child: 0,   // Will be set in close_node

4931

20454

});

4932

20454

        self.node_data.push(node_data);

4933

4934

        // Push onto stack: this node is now the "open" element, no children yet

4935

20454

        self.stack.push((idx, None));

4936

20454

4937

4938

    /// Close the current element. Sets the `last_child` pointer.

4939

20454

    pub fn close_node(&mut self) {

4940

        use crate::id::NodeId;

4941

4942

20454

        if let Some((idx, last_child_idx)) = self.stack.pop() {

4943

            // Set last_child on this node's hierarchy item

4944

20454

            self.hierarchy[idx].last_child = last_child_idx

4945

20454

                .map(|lc| NodeId::into_raw(&Some(NodeId::new(lc))))

4946

20454

                .unwrap_or(0);

4947

4948

20454

4949

4950

    /// Add a leaf node (text, br, hr, etc.) that has no children.

4951

7014

    pub fn add_leaf(&mut self, node_data: crate::dom::NodeData) {

4952

7014

        self.open_node(node_data);

4953

7014

        self.close_node();

4954

7014

4955

4956

    /// Add a CSS stylesheet scoped to a node ID.

4957

    pub fn add_css(&mut self, node_id: usize, css: azul_css::css::Css) {

4958

        self.css.push(crate::dom::CssWithNodeId { node_id, css });

4959

4960

4961

    /// Finish building and produce a FastDom.

4962

3150

    pub fn finish(self) -> crate::dom::FastDom {

4963

3150

        crate::dom::FastDom {

4964

3150

            node_hierarchy: self.hierarchy.into(),

4965

3150

            node_data: self.node_data.into(),

4966

3150

            css: self.css.into(),

4967

3150

4968

3150

4969

4970

4971

/// Convert an XML node tree into a FastDom (arena-based) in a single DFS pass.

4972

/// This is the fast path equivalent of `xml_node_to_dom_fast`.

4973

10290

fn xml_node_to_fast_dom<'a>(

4974

10290

    xml_node: &'a XmlNode,

4975

10290

    component_map: &'a ComponentMap,

4976

10290

    inside_svg: bool,

4977

10290

    builder: &mut CompactDomBuilder,

4978

10290

) -> Result<(), RenderDomError> {

4979

    use crate::dom::{Dom, NodeType, NodeData, IdOrClass, TabIndex};

4980

4981

10290

    let component_name = normalize_casing(&xml_node.node_type);

4982

10290

    let node_type = tag_to_node_type(&component_name);

4983

10290

    let mut node_data = NodeData::create_node(node_type);

4984

4985

    // `<img src="...">`: rebuild the placeholder Image node so its `NullImage`

4986

    // carries the `src` string (UTF-8 bytes in `tag`). The bytes are resolved

4987

    // downstream (e.g. printpdf) via the tag. Mirrors `xml_node_to_dom_fast`.

4988

10290

    if component_name == "img" {

4989

        if let Some(src) = xml_node.attributes.get_key("src") {

4990

            let width = xml_node

4991

                .attributes

4992

                .get_key("width")

4993

                .and_then(|w| w.as_str().trim().trim_end_matches("px").trim().parse::<usize>().ok())

4994

                .unwrap_or(0);

4995

            let height = xml_node

4996

                .attributes

4997

                .get_key("height")

4998

                .and_then(|h| h.as_str().trim().trim_end_matches("px").trim().parse::<usize>().ok())

4999

                .unwrap_or(0);

5000

            let image_ref = crate::resources::ImageRef::null_image(

5001

                width,

5002

                height,

5003

                crate::resources::RawImageFormat::RGBA8,

5004

                src.as_str().as_bytes().to_vec(),

5005

);

5006

            node_data.set_node_type(NodeType::Image(azul_css::css::BoxOrStatic::heap(image_ref)));

5007

5008

10290

5009

5010

    // Set id and class attributes

5011

10290

    let mut ids_and_classes = Vec::new();

5012

10290

    if let Some(id_str) = xml_node.attributes.get_key("id") {

5013

        for id in id_str.split_whitespace() {

5014

            ids_and_classes.push(IdOrClass::Id(id.into()));

5015

5016

10290

5017

10290

    if let Some(class_str) = xml_node.attributes.get_key("class") {

5018

4116

        for class in class_str.split_whitespace() {

5019

4116

            ids_and_classes.push(IdOrClass::Class(class.into()));

5020

4116

5021

6174

5022

10290

    if !ids_and_classes.is_empty() {

5023

4116

        node_data.set_ids_and_classes(ids_and_classes.into());

5024

6174

5025

5026

    // Handle focusable attribute

5027

10290

    if let Some(focusable) = xml_node.attributes.get_key("focusable").and_then(|f| parse_bool(f.as_str())) {

5028

        match focusable {

5029

            true => node_data.set_tab_index(TabIndex::Auto),

5030

            false => node_data.set_tab_index(TabIndex::NoKeyboardFocus),

5031

5032

10290

5033

5034

    // Handle tabindex attribute

5035

10290

    if let Some(tab_index) = xml_node.attributes.get_key("tabindex").and_then(|val| val.parse::<isize>().ok()) {

5036

        match tab_index {

5037

            0 => node_data.set_tab_index(TabIndex::Auto),

5038

            i if i > 0 => node_data.set_tab_index(TabIndex::OverrideInParent(i as u32)),

5039

            _ => node_data.set_tab_index(TabIndex::NoKeyboardFocus),

5040

5041

10290

5042

5043

    // Handle inline style attribute

5044

10290

    if let Some(style) = xml_node.attributes.get_key("style") {

5045

        let css_key_map = azul_css::props::property::get_css_key_map();

5046

        let mut attributes = Vec::new();

5047

        for s in style.as_str().split(";") {

5048

            let mut s = s.split(":");

5049

            let key = match s.next() { Some(s) => s, None => continue };

5050

            let value = match s.next() { Some(s) => s, None => continue };

5051

            let _ = azul_css::parser2::parse_css_declaration(

5052

                key.trim(), value.trim(),

5053

                azul_css::parser2::ErrorLocationRange::default(),

5054

                &css_key_map, &mut Vec::new(), &mut attributes,

5055

);

5056

5057

        let props = attributes.into_iter().filter_map(|s| {

5058

            use azul_css::dynamic_selector::CssPropertyWithConditions;

5059

            match s {

5060

                CssDeclaration::Static(s) => Some(CssPropertyWithConditions::simple(s)),

5061

                _ => None,

5062

5063

        }).collect::<Vec<_>>();

5064

        if !props.is_empty() {

5065

            node_data.set_css_props(props.into());

5066

5067

10290

5068

5069

    // Handle SVG shape elements

5070

10290

    let tag = component_name.as_str();

5071

10290

    let child_inside_svg = inside_svg || tag == "svg";

5072

10290

    let is_svg_shape = inside_svg && matches!(tag, "path" | "circle" | "rect" | "ellipse" | "line" | "polygon" | "polyline");

5073

5074

10290

    if is_svg_shape {

5075

882

        let clip = match tag {

5076

882

            "path" => {

5077

168

                xml_node.attributes.get_key("d").and_then(|d| {

5078

168

                    crate::svg_path_parser::parse_svg_path_d(d.as_str()).ok()

5079

168

})

5080

5081

714

            "circle" => {

5082

210

                let cx = parse_svg_float(xml_node.attributes.get_key("cx")).unwrap_or(0.0);

5083

210

                let cy = parse_svg_float(xml_node.attributes.get_key("cy")).unwrap_or(0.0);

5084

210

                let r = parse_svg_float(xml_node.attributes.get_key("r")).unwrap_or(0.0);

5085

210

                if r > 0.0 {

5086

168

                    Some(crate::svg::SvgMultiPolygon {

5087

168

                        rings: crate::svg::SvgPathVec::from_vec(vec![

5088

168

                            crate::svg_path_parser::svg_circle_to_paths(cx, cy, r)

5089

168

]),

5090

168

})

5091

                } else {

5092

42

                    None

5093

5094

5095

504

            "rect" => {

5096

252

                let x = parse_svg_float(xml_node.attributes.get_key("x")).unwrap_or(0.0);

5097

252

                let y = parse_svg_float(xml_node.attributes.get_key("y")).unwrap_or(0.0);

5098

252

                let w = parse_svg_float(xml_node.attributes.get_key("width")).unwrap_or(0.0);

5099

252

                let h = parse_svg_float(xml_node.attributes.get_key("height")).unwrap_or(0.0);

5100

252

                let rx = parse_svg_float(xml_node.attributes.get_key("rx")).unwrap_or(0.0);

5101

252

                let ry = parse_svg_float(xml_node.attributes.get_key("ry")).unwrap_or(rx);

5102

252

                if w > 0.0 && h > 0.0 {

5103

210

                    Some(crate::svg::SvgMultiPolygon {

5104

210

                        rings: crate::svg::SvgPathVec::from_vec(vec![

5105

210

                            crate::svg_path_parser::svg_rect_to_path(x, y, w, h, rx, ry)

5106

210

]),

5107

210

})

5108

                } else {

5109

42

                    None

5110

5111

5112

252

            "ellipse" => {

5113

84

                let cx = parse_svg_float(xml_node.attributes.get_key("cx")).unwrap_or(0.0);

5114

84

                let cy = parse_svg_float(xml_node.attributes.get_key("cy")).unwrap_or(0.0);

5115

84

                let rx = parse_svg_float(xml_node.attributes.get_key("rx")).unwrap_or(0.0);

5116

84

                let ry = parse_svg_float(xml_node.attributes.get_key("ry")).unwrap_or(0.0);

5117

84

                if rx > 0.0 && ry > 0.0 {

5118

                    use azul_css::props::basic::{SvgPoint, SvgCubicCurve};

5119

                    const KAPPA: f32 = 0.5522847498;

5120

84

                    let kx = rx * KAPPA;

5121

84

                    let ky = ry * KAPPA;

5122

84

                    let elements = vec![

5123

84

                        crate::svg::SvgPathElement::CubicCurve(SvgCubicCurve {

5124

84

                            start: SvgPoint { x: cx, y: cy - ry },

5125

84

                            ctrl_1: SvgPoint { x: cx + kx, y: cy - ry },

5126

84

                            ctrl_2: SvgPoint { x: cx + rx, y: cy - ky },

5127

84

                            end: SvgPoint { x: cx + rx, y: cy },

5128

84

}),

5129

84

                        crate::svg::SvgPathElement::CubicCurve(SvgCubicCurve {

5130

84

                            start: SvgPoint { x: cx + rx, y: cy },

5131

84

                            ctrl_1: SvgPoint { x: cx + rx, y: cy + ky },

5132

84

                            ctrl_2: SvgPoint { x: cx + kx, y: cy + ry },

5133

84

                            end: SvgPoint { x: cx, y: cy + ry },

5134

84

}),

5135

84

                        crate::svg::SvgPathElement::CubicCurve(SvgCubicCurve {

5136

84

                            start: SvgPoint { x: cx, y: cy + ry },

5137

84

                            ctrl_1: SvgPoint { x: cx - kx, y: cy + ry },

5138

84

                            ctrl_2: SvgPoint { x: cx - rx, y: cy + ky },

5139

84

                            end: SvgPoint { x: cx - rx, y: cy },

5140

84

}),

5141

84

                        crate::svg::SvgPathElement::CubicCurve(SvgCubicCurve {

5142

84

                            start: SvgPoint { x: cx - rx, y: cy },

5143

84

                            ctrl_1: SvgPoint { x: cx - rx, y: cy - ky },

5144

84

                            ctrl_2: SvgPoint { x: cx - kx, y: cy - ry },

5145

84

                            end: SvgPoint { x: cx, y: cy - ry },

5146

84

}),

5147

];

5148

84

                    Some(crate::svg::SvgMultiPolygon {

5149

84

                        rings: crate::svg::SvgPathVec::from_vec(vec![

5150

84

                            crate::svg::SvgPath { items: crate::svg::SvgPathElementVec::from_vec(elements) }

5151

84

]),

5152

84

})

5153

                } else {

5154

                    None

5155

5156

5157

168

            "line" => {

5158

42

                let x1 = parse_svg_float(xml_node.attributes.get_key("x1")).unwrap_or(0.0);

5159

42

                let y1 = parse_svg_float(xml_node.attributes.get_key("y1")).unwrap_or(0.0);

5160

42

                let x2 = parse_svg_float(xml_node.attributes.get_key("x2")).unwrap_or(0.0);

5161

42

                let y2 = parse_svg_float(xml_node.attributes.get_key("y2")).unwrap_or(0.0);

5162

42

                Some(crate::svg::SvgMultiPolygon {

5163

42

                    rings: crate::svg::SvgPathVec::from_vec(vec![

5164

42

                        crate::svg::SvgPath {

5165

42

                            items: crate::svg::SvgPathElementVec::from_vec(vec![

5166

42

                                crate::svg::SvgPathElement::Line(crate::svg::SvgLine::new(

5167

42

                                    azul_css::props::basic::SvgPoint { x: x1, y: y1 },

5168

42

                                    azul_css::props::basic::SvgPoint { x: x2, y: y2 },

5169

42

))

5170

42

]),

5171

42

5172

42

]),

5173

42

})

5174

5175

126

            "polygon" | "polyline" => {

5176

126

                xml_node.attributes.get_key("points").and_then(|pts| {

5177

126

                    parse_svg_points(pts.as_str(), tag == "polygon")

5178

126

})

5179

5180

            _ => None,

5181

};

5182

882

        if let Some(mp) = clip {

5183

798

            node_data.set_svg_data(crate::dom::SvgNodeData::Path(mp));

5184

798

5185

9408

5186

5187

    // Open this node in the builder

5188

10290

    builder.open_node(node_data);

5189

5190

    // Recursively convert children

5191

14154

    for child in xml_node.children.as_ref().iter() {

5192

14154

        match child {

5193

7140

            XmlNodeChild::Element(child_node) => {

5194

7140

                xml_node_to_fast_dom(child_node, component_map, child_inside_svg, builder)?;

5195

5196

7014

            XmlNodeChild::Text(text) => {

5197

7014

                builder.add_leaf(NodeData::create_text(AzString::from(text.as_str())));

5198

7014

5199

5200

5201

5202

    // Close this node

5203

10290

    builder.close_node();

5204

5205

10290

    Ok(())

5206

10290

5207

5208

/// Render a DOM from an XML body node using the fast arena-based path.

5209

/// Builds a FastDom directly (no tree intermediary), then creates StyledDom.

5210

3150

fn render_dom_from_body_node_fast<'a>(

5211

3150

    body_node: &'a XmlNode,

5212

3150

    mut global_css: Option<Css>,

5213

3150

    component_map: &'a ComponentMap,

5214

3150

    max_width: Option<f32>,

5215

3150

) -> Result<StyledDom, RenderDomError> {

5216

    use crate::dom::{NodeData, NodeType};

5217

5218

3150

    let mut builder = CompactDomBuilder::new();

5219

5220

    // Build the HTML > Body wrapper + body content in one pass

5221

    // Open <html>

5222

3150

    builder.open_node(NodeData::create_node(NodeType::Html));

5223

    // Open <body> (the body_node content goes inside)

5224

3150

    xml_node_to_fast_dom(body_node, component_map, false, &mut builder)?;

5225

    // Close <html>

5226

3150

    builder.close_node();

5227

5228

    // Collect CSS rules from each source.

5229

3150

    let mut combined_rules: Vec<azul_css::css::CssRuleBlock> = Vec::new();

5230

3150

    if let Some(max_width) = max_width {

5231

        let max_width_css = Css::from_string(

5232

            format!("html {{ max-width: {max_width}px; }}").into(),

5233

);

5234

        combined_rules.extend(max_width_css.rules.into_library_owned_vec());

5235

3150

5236

3150

    if let Some(css) = global_css.take() {

5237

2310

        combined_rules.extend(css.rules.into_library_owned_vec());

5238

2310

5239

3150

    let combined_css = Css::new(combined_rules);

5240

5241

    // Add CSS to the FastDom

5242

3150

    let mut fast_dom = builder.finish();

5243

3150

    fast_dom.css = vec![crate::dom::CssWithNodeId {

5244

3150

        node_id: 0, // Global scope (root)

5245

3150

        css: combined_css,

5246

3150

    }].into();

5247

5248

    // Create StyledDom via the fast path (no tree→arena conversion)

5249

3150

    let styled = StyledDom::create_from_fast_dom(fast_dom);

5250

3150

    Ok(styled)

5251

3150

5252

5253

// render_dom_from_body_node() removed — use render_dom_from_body_node_fast() or str_to_dom()

5254

5255

fn set_stringified_attributes(

5256

    dom_string: &mut String,

5257

    xml_attributes: &XmlAttributeMap,

5258

    filtered_xml_attributes: &ComponentArgumentVec,

5259

    tabs: usize,

5260

) {

5261

    let t0 = String::from("    ").repeat(tabs);

5262

    let t = String::from("    ").repeat(tabs + 1);

5263

5264

    // push ids and classes

5265

    let mut ids_and_classes = String::new();

5266

5267

    for id in xml_attributes

5268

        .get_key("id")

5269

        .map(|s| s.split_whitespace().collect::<Vec<_>>())

5270

        .unwrap_or_default()

5271

5272

        ids_and_classes.push_str(&format!(

5273

            "{}    Id(AzString::from_const_str(\"{}\")),\r\n",

5274

t0,

5275

            format_args_dynamic(id, &filtered_xml_attributes)

5276

));

5277

5278

5279

    for class in xml_attributes

5280

        .get_key("class")

5281

        .map(|s| s.split_whitespace().collect::<Vec<_>>())

5282

        .unwrap_or_default()

5283

5284

        ids_and_classes.push_str(&format!(

5285

            "{}    Class(AzString::from_const_str(\"{}\")),\r\n",

5286

t0,

5287

            format_args_dynamic(class, &filtered_xml_attributes)

5288

));

5289

5290

5291

    if !ids_and_classes.is_empty() {

5292

        use azul_css::format_rust_code::GetHash;

5293

        let id = ids_and_classes.get_hash();

5294

        dom_string.push_str(&format!(

5295

            "\r\n{t0}.with_ids_and_classes({{\r\n{t}const IDS_AND_CLASSES_{id}: &[IdOrClass] = \

5296

             &[\r\n{t}{ids_and_classes}\r\n{t}];\r\\

5297

             n{t}IdOrClassVec::from_const_slice(IDS_AND_CLASSES_{id})\r\n{t0}}})",

5298

            t0 = t0,

5299

            t = t,

5300

            ids_and_classes = ids_and_classes,

5301

            id = id

5302

));

5303

5304

5305

    if let Some(focusable) = xml_attributes

5306

        .get_key("focusable")

5307

        .map(|f| format_args_dynamic(f, &filtered_xml_attributes))

5308

        .and_then(|f| parse_bool(&f))

5309

5310

        match focusable {

5311

            true => dom_string.push_str(&format!("\r\n{}.with_tab_index(TabIndex::Auto)", t)),

5312

            false => dom_string.push_str(&format!(

5313

                "\r\n{}.with_tab_index(TabIndex::NoKeyboardFocus)",

5314

5315

)),

5316

5317

5318

5319

    if let Some(tab_index) = xml_attributes

5320

        .get_key("tabindex")

5321

        .map(|val| format_args_dynamic(val, &filtered_xml_attributes))

5322

        .and_then(|val| val.parse::<isize>().ok())

5323

5324

        match tab_index {

5325

            0 => dom_string.push_str(&format!("\r\n{}.with_tab_index(TabIndex::Auto)", t)),

5326

            i if i > 0 => dom_string.push_str(&format!(

5327

                "\r\n{}.with_tab_index(TabIndex::OverrideInParent({}))",

5328

                t, i as usize

5329

)),

5330

            _ => dom_string.push_str(&format!(

5331

                "\r\n{}.with_tab_index(TabIndex::NoKeyboardFocus)",

5332

5333

)),

5334

5335

5336

5337

5338

/// Item of a split string - either a variable name (with optional format spec) or a string

5339

#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]

5340

pub enum DynamicItem {

5341

    /// A variable reference, e.g. {counter} or {counter:?} or {price:.2}

5342

    Var {

5343

        name: String,

5344

        /// Optional format specifier after the colon: "?" for debug, ".2" for precision, etc.

5345

        format_spec: Option<String>,

5346

},

5347

    Str(String),

5348

5349

5350

/// Splits a string into formatting arguments, supporting format specifiers like `{var:?}`

5351

/// ```rust

5352

/// # use azul_core::xml::DynamicItem::*;

5353

/// # use azul_core::xml::split_dynamic_string;

5354

/// let s = "hello {a}, {b}{{ {c} }}";

5355

/// let split = split_dynamic_string(s);

5356

/// let output = vec![

5357

///     Str("hello ".to_string()),

5358

///     Var { name: "a".to_string(), format_spec: None },

5359

///     Str(", ".to_string()),

5360

///     Var { name: "b".to_string(), format_spec: None },

5361

///     Str("{ ".to_string()),

5362

///     Var { name: "c".to_string(), format_spec: None },

5363

///     Str(" }".to_string()),

5364

/// ];

5365

/// assert_eq!(output, split);

5366

/// ```

5367

pub fn split_dynamic_string(input: &str) -> Vec<DynamicItem> {

5368

    use self::DynamicItem::*;

5369

5370

    let input: Vec<char> = input.chars().collect();

5371

    let input_chars_len = input.len();

5372

5373

    let mut items = Vec::new();

5374

    let mut current_idx = 0;

5375

    let mut last_idx = 0;

5376

5377

    while current_idx < input_chars_len {

5378

        let c = input[current_idx];

5379

        match c {

5380

            '{' if input.get(current_idx + 1).copied() != Some('{') => {

5381

                // variable start, search until next closing brace or whitespace or end of string

5382

                let mut start_offset = 1;

5383

                let mut has_found_variable = false;

5384

                while let Some(c) = input.get(current_idx + start_offset) {

5385

                    if c.is_whitespace() {

5386

                        break;

5387

5388

                    if *c == '}' && input.get(current_idx + start_offset + 1).copied() != Some('}')

5389

5390

                        start_offset += 1;

5391

                        has_found_variable = true;

5392

                        break;

5393

5394

                    start_offset += 1;

5395

5396

5397

                // advance current_idx accordingly

5398

                // on fail, set cursor to end

5399

                // set last_idx accordingly

5400

                if has_found_variable {

5401

                    if last_idx != current_idx {

5402

                        items.push(Str(input[last_idx..current_idx].iter().collect()));

5403

5404

5405

                    // subtract 1 from start for opening brace, one from end for closing brace

5406

                    let var_content: String = input

5407

                        [(current_idx + 1)..(current_idx + start_offset - 1)]

5408

                        .iter()

5409

                        .collect();

5410

                    // Split on first ':' to separate variable name from format specifier

5411

                    let (var_name, format_spec) = if let Some(colon_pos) = var_content.find(':') {

5412

                        let name = var_content[..colon_pos].to_string();

5413

                        let spec = var_content[(colon_pos + 1)..].to_string();

5414

                        (name, Some(spec))

5415

                    } else {

5416

                        (var_content, None)

5417

};

5418

                    items.push(Var { name: var_name, format_spec });

5419

                    current_idx = current_idx + start_offset;

5420

                    last_idx = current_idx;

5421

                } else {

5422

                    current_idx += start_offset;

5423

5424

5425

            _ => {

5426

                current_idx += 1;

5427

5428

5429

5430

5431

    if current_idx != last_idx {

5432

        items.push(Str(input[last_idx..].iter().collect()));

5433

5434

5435

    for item in &mut items {

5436

        // replace {{ with { in strings

5437

        if let Str(s) = item {

5438

            *s = s.replace("{{", "{").replace("}}", "}");

5439

5440

5441

5442

    items

5443

5444

5445

/// Combines the split string back into its original form while replacing the variables with their

5446

/// values

5447

///

5448

/// let variables = btreemap!{ "a" => "value1", "b" => "value2" };

5449

/// [Str("hello "), Var("a"), Str(", "), Var("b"), Str("{ "), Var("c"), Str(" }}")]

5450

/// => "hello value1, valuec{ {c} }"

5451

fn combine_and_replace_dynamic_items(

5452

    input: &[DynamicItem],

5453

    variables: &ComponentArgumentVec,

5454

) -> String {

5455

    let mut s = String::new();

5456

5457

    for item in input {

5458

        match item {

5459

            DynamicItem::Var { name, format_spec } => {

5460

                let variable_name = normalize_casing(name.trim());

5461

                match variables

5462

                    .iter()

5463

                    .find(|s| s.name.as_str() == variable_name)

5464

                    .map(|q| &q.arg_type)

5465

5466

                    Some(resolved_var) => {

5467

                        // Format specifiers are applied at compile time, not at runtime replacement

5468

                        s.push_str(&resolved_var);

5469

5470

                    None => {

5471

                        s.push('{');

5472

                        s.push_str(name);

5473

                        if let Some(spec) = format_spec {

5474

                            s.push(':');

5475

                            s.push_str(spec);

5476

5477

                        s.push('}');

5478

5479

5480

5481

            DynamicItem::Str(dynamic_str) => {

5482

                s.push_str(&dynamic_str);

5483

5484

5485

5486

5487

5488

5489

5490

/// Given a string and a key => value mapping, replaces parts of the string with the value, i.e.:

5491

///

5492

/// ```rust

5493

/// # use azul_core::xml::{format_args_dynamic, ComponentArgument, ComponentArgumentVec};

5494

/// # use azul_css::AzString;

5495

/// let variables: ComponentArgumentVec = vec![

5496

///     ComponentArgument { name: AzString::from("a"), arg_type: AzString::from("value1") },

5497

///     ComponentArgument { name: AzString::from("b"), arg_type: AzString::from("value2") },

5498

/// ].into();

5499

///

5500

/// let initial = "hello {a}, {b}{{ {c} }}";

5501

/// let expected = "hello value1, value2{ {c} }".to_string();

5502

/// assert_eq!(format_args_dynamic(initial, &variables), expected);

5503

/// ```

5504

///

5505

/// Note: the number (0, 1, etc.) is the order of the argument, it is irrelevant for

5506

/// runtime formatting, only important for keeping the component / function arguments

5507

/// in order when compiling the arguments to Rust code

5508

pub fn format_args_dynamic(input: &str, variables: &ComponentArgumentVec) -> String {

5509

    let dynamic_str_items = split_dynamic_string(input);

5510

    combine_and_replace_dynamic_items(&dynamic_str_items, variables)

5511

5512

5513

// NOTE: Two sequential returns count as a single return, while single returns get ignored.

5514

pub fn prepare_string(input: &str) -> String {

5515

    const SPACE: &str = " ";

5516

    const RETURN: &str = "\n";

5517

5518

    let input = input.trim();

5519

5520

    if input.is_empty() {

5521

        return String::new();

5522

5523

5524

    let input = input.replace("&lt;", "<");

5525

    let input = input.replace("&gt;", ">");

5526

5527

    let input_len = input.len();

5528

    let mut final_lines: Vec<String> = Vec::new();

5529

    let mut last_line_was_empty = false;

5530

5531

    for line in input.lines() {

5532

        let line = line.trim();

5533

        let line = line.replace("&nbsp;", " ");

5534

        let current_line_is_empty = line.is_empty();

5535

5536

        if !current_line_is_empty {

5537

            if last_line_was_empty {

5538

                final_lines.push(format!("{}{}", RETURN, line));

5539

            } else {

5540

                final_lines.push(line.to_string());

5541

5542

5543

5544

        last_line_was_empty = current_line_is_empty;

5545

5546

5547

    let line_len = final_lines.len();

5548

    let mut target = String::with_capacity(input_len);

5549

    for (line_idx, line) in final_lines.iter().enumerate() {

5550

        if !(line.starts_with(RETURN) || line_idx == 0 || line_idx == line_len.saturating_sub(1)) {

5551

            target.push_str(SPACE);

5552

5553

        target.push_str(line);

5554

5555

    target

5556

5557

5558

/// Parses a string ("true" or "false")

5559

pub fn parse_bool(input: &str) -> Option<bool> {

5560

    match input {

5561

        "true" => Some(true),

5562

        "false" => Some(false),

5563

        _ => None,

5564

5565

5566

5567

#[derive(Clone)]

5568

pub struct CssMatcher {

5569

    path: Vec<CssPathSelector>,

5570

    indices_in_parent: Vec<usize>,

5571

    children_length: Vec<usize>,

5572

5573

5574

impl CssMatcher {

5575

    fn get_hash(&self) -> u64 {

5576

        use core::hash::Hash;

5577

5578

        use core::hash::Hasher;

5579

5580

        let mut hasher = crate::hash::DefaultHasher::new();

5581

        for p in self.path.iter() {

5582

            p.hash(&mut hasher);

5583

5584

        hasher.finish()

5585

5586

5587

5588

impl CssMatcher {

5589

    fn matches(&self, path: &CssPath) -> bool {

5590

        use azul_css::css::CssPathSelector::*;

5591

5592

        use crate::style::{CssGroupIterator, CssGroupSplitReason};

5593

5594

        if self.path.is_empty() {

5595

            return false;

5596

5597

        if path.selectors.as_ref().is_empty() {

5598

            return false;

5599

5600

5601

        // self_matcher is only ever going to contain "Children" selectors, never "DirectChildren"

5602

        let mut path_groups = CssGroupIterator::new(path.selectors.as_ref()).collect::<Vec<_>>();

5603

        path_groups.reverse();

5604

5605

        if path_groups.is_empty() {

5606

            return false;

5607

5608

        let mut self_groups = CssGroupIterator::new(self.path.as_ref()).collect::<Vec<_>>();

5609

        self_groups.reverse();

5610

        if self_groups.is_empty() {

5611

            return false;

5612

5613

5614

        if self.indices_in_parent.len() != self_groups.len() {

5615

            return false;

5616

5617

        if self.children_length.len() != self_groups.len() {

5618

            return false;

5619

5620

5621

        // self_groups = [ // HTML

5622

        //     "body",

5623

        //     "div.__azul_native-ribbon-container"

5624

        //     "div.__azul_native-ribbon-tabs"

5625

        //     "p.home"

5626

        // ]

5627

//

5628

        // path_groups = [ // CSS

5629

        //     ".__azul_native-ribbon-tabs"

5630

        //     "div.after-tabs"

5631

        // ]

5632

5633

        // get the first path group and see if it matches anywhere in the self group

5634

        let mut cur_selfgroup_scan = 0;

5635

        let mut cur_pathgroup_scan = 0;

5636

        let mut valid = false;

5637

        let mut path_group = path_groups[cur_pathgroup_scan].clone();

5638

5639

        while cur_selfgroup_scan < self_groups.len() {

5640

            let mut advance = None;

5641

5642

            // scan all remaining path groups

5643

            for (id, cg) in self_groups[cur_selfgroup_scan..].iter().enumerate() {

5644

                let gm = group_matches(

5645

                    &path_group.0,

5646

                    &self_groups[cur_selfgroup_scan + id].0,

5647

                    self.indices_in_parent[cur_selfgroup_scan + id],

5648

                    self.children_length[cur_selfgroup_scan + id],

5649

);

5650

5651

                if gm {

5652

                    // ok: ".__azul_native-ribbon-tabs" was found within self_groups

5653

                    // advance the self_groups by n

5654

                    advance = Some(id);

5655

                    break;

5656

5657

5658

5659

            match advance {

5660

                Some(n) => {

5661

                    // group was found in remaining items

5662

                    // advance cur_pathgroup_scan by 1 and cur_selfgroup_scan by n

5663

                    if cur_pathgroup_scan == path_groups.len() - 1 {

5664

                        // last path group

5665

                        return cur_selfgroup_scan + n == self_groups.len() - 1;

5666

                    } else {

5667

                        cur_pathgroup_scan += 1;

5668

                        cur_selfgroup_scan += n;

5669

                        path_group = path_groups[cur_pathgroup_scan].clone();

5670

5671

5672

                None => return false, // group was not found in remaining items

5673

5674

5675

5676

        // only return true if all path_groups matched

5677

        return cur_pathgroup_scan == path_groups.len() - 1;

5678

5679

5680

5681

// does p.home match div.after-tabs?

5682

// a: div.after-tabs

5683

fn group_matches(

5684

    a: &[&CssPathSelector],

5685

    b: &[&CssPathSelector],

5686

    idx_in_parent: usize,

5687

    parent_children: usize,

5688

) -> bool {

5689

    use azul_css::css::{CssNthChildSelector, CssPathPseudoSelector, CssPathSelector::*};

5690

5691

    for selector in a {

5692

        match selector {

5693

            // always matches

5694

            Global => {}

5695

            PseudoSelector(CssPathPseudoSelector::Hover) => {}

5696

            PseudoSelector(CssPathPseudoSelector::Active) => {}

5697

            PseudoSelector(CssPathPseudoSelector::Focus) => {}

5698

5699

            Type(tag) => {

5700

                if !b.iter().any(|t| **t == Type(tag.clone())) {

5701

                    return false;

5702

5703

5704

            Class(class) => {

5705

                if !b.iter().any(|t| **t == Class(class.clone())) {

5706

                    return false;

5707

5708

5709

            Id(id) => {

5710

                if !b.iter().any(|t| **t == Id(id.clone())) {

5711

                    return false;

5712

5713

5714

            PseudoSelector(CssPathPseudoSelector::First) => {

5715

                if idx_in_parent != 0 {

5716

                    return false;

5717

5718

5719

            PseudoSelector(CssPathPseudoSelector::Last) => {

5720

                if idx_in_parent != parent_children.saturating_sub(1) {

5721

                    return false;

5722

5723

5724

            PseudoSelector(CssPathPseudoSelector::NthChild(CssNthChildSelector::Number(i))) => {

5725

                if idx_in_parent != *i as usize {

5726

                    return false;

5727

5728

5729

            PseudoSelector(CssPathPseudoSelector::NthChild(CssNthChildSelector::Even)) => {

5730

                if idx_in_parent % 2 != 0 {

5731

                    return false;

5732

5733

5734

            PseudoSelector(CssPathPseudoSelector::NthChild(CssNthChildSelector::Odd)) => {

5735

                if idx_in_parent % 2 == 0 {

5736

                    return false;

5737

5738

5739

            PseudoSelector(CssPathPseudoSelector::NthChild(CssNthChildSelector::Pattern(p))) => {

5740

                if idx_in_parent.saturating_sub(p.offset as usize) % p.pattern_repeat as usize != 0

5741

5742

                    return false;

5743

5744

5745

5746

            _ => return false, // can't happen

5747

5748

5749

5750

    true

5751

5752

5753

struct CssBlock {

5754

    ending: Option<CssPathPseudoSelector>,

5755

    block: CssRuleBlock,

5756

5757

5758

pub fn compile_body_node_to_rust_code<'a>(

5759

    body_node: &'a XmlNode,

5760

    component_map: &'a ComponentMap,

5761

    extra_blocks: &mut VecContents,

5762

    css_blocks: &mut BTreeMap<String, String>,

5763

    css: &Css,

5764

    mut matcher: CssMatcher,

5765

) -> Result<String, CompileError> {

5766

    use azul_css::css::CssDeclaration;

5767

5768

    let t = "";

5769

    let t2 = "    ";

5770

    let mut dom_string = String::from("Dom::create_body()");

5771

    let node_type = CssPathSelector::Type(NodeTypeTag::Body);

5772

    matcher.path.push(node_type);

5773

5774

    let ids = body_node

5775

        .attributes

5776

        .get_key("id")

5777

        .map(|s| s.split_whitespace().collect::<Vec<_>>())

5778

        .unwrap_or_default();

5779

    matcher.path.extend(

5780

        ids.into_iter()

5781

            .map(|id| CssPathSelector::Id(id.to_string().into())),

5782

);

5783

    let classes = body_node

5784

        .attributes

5785

        .get_key("class")

5786

        .map(|s| s.split_whitespace().collect::<Vec<_>>())

5787

        .unwrap_or_default();

5788

    matcher.path.extend(

5789

        classes

5790

            .into_iter()

5791

            .map(|class| CssPathSelector::Class(class.to_string().into())),

5792

);

5793

5794

    let matcher_hash = matcher.get_hash();

5795

    let css_blocks_for_this_node = get_css_blocks(css, &matcher);

5796

    if !css_blocks_for_this_node.is_empty() {

5797

        use azul_css::props::property::format_static_css_prop;

5798

5799

        let css_strings = css_blocks_for_this_node

5800

            .iter()

5801

            .rev()

5802

            .map(|css_block| {

5803

                let wrapper = match css_block.ending {

5804

                    Some(CssPathPseudoSelector::Hover) => "Hover",

5805

                    Some(CssPathPseudoSelector::Active) => "Active",

5806

                    Some(CssPathPseudoSelector::Focus) => "Focus",

5807

                    _ => "Normal",

5808

};

5809

5810

                for declaration in css_block.block.declarations.as_ref().iter() {

5811

                    let prop = match declaration {

5812

                        CssDeclaration::Static(s) => s,

5813

                        CssDeclaration::Dynamic(d) => &d.default_value,

5814

};

5815

                    extra_blocks.insert_from_css_property(prop);

5816

5817

5818

                let formatted = css_block

5819

                    .block

5820

                    .declarations

5821

                    .as_ref()

5822

                    .iter()

5823

                    .rev()

5824

                    .map(|s| match &s {

5825

                        CssDeclaration::Static(s) => format!(

5826

                            "NodeDataInlineCssProperty::{}({})",

5827

                            wrapper,

5828

                            format_static_css_prop(s, 1)

5829

),

5830

                        CssDeclaration::Dynamic(d) => format!(

5831

                            "NodeDataInlineCssProperty::{}({})",

5832

                            wrapper,

5833

                            format_static_css_prop(&d.default_value, 1)

5834

),

5835

})

5836

                    .collect::<Vec<String>>();

5837

5838

                format!("// {}\r\n{}", css_block.block.path, formatted.join(",\r\n"))

5839

})

5840

            .collect::<Vec<_>>()

5841

            .join(",\r\n");

5842

5843

        css_blocks.insert(format!("CSS_MATCH_{:09}", matcher_hash), css_strings);

5844

        dom_string.push_str(&format!(

5845

            "\r\n{}.with_inline_css_props(CSS_MATCH_{:09})",

5846

            t2, matcher_hash

5847

));

5848

5849

5850

    if !body_node.children.as_ref().is_empty() {

5851

        use azul_css::format_rust_code::GetHash;

5852

        let children_hash = body_node.children.as_ref().get_hash();

5853

        dom_string.push_str(&format!("\r\n.with_children(DomVec::from_vec(vec![\r\n"));

5854

5855

        for (child_idx, child) in body_node.children.as_ref().iter().enumerate() {

5856

            match child {

5857

                XmlNodeChild::Element(child_node) => {

5858

                    let mut matcher = matcher.clone();

5859

                    matcher.path.push(CssPathSelector::Children);

5860

                    matcher.indices_in_parent.push(child_idx);

5861

                    matcher.children_length.push(body_node.children.len());

5862

5863

                    dom_string.push_str(&format!(

5864

                        "{}{},\r\n",

5865

t,

5866

                        compile_node_to_rust_code_inner(

5867

                            child_node,

5868

                            component_map,

5869

1,

5870

                            extra_blocks,

5871

                            css_blocks,

5872

                            css,

5873

                            matcher,

5874

)?

5875

));

5876

5877

                XmlNodeChild::Text(text) => {

5878

                    let text = text.trim();

5879

                    if !text.is_empty() {

5880

                        let escaped = text.replace("\\", "\\\\").replace("\"", "\\\"");

5881

                        dom_string

5882

                            .push_str(&format!("{}Dom::create_text(\"{}\".into()),\r\n", t, escaped));

5883

5884

5885

5886

5887

        dom_string.push_str(&format!("\r\n{}]))", t));

5888

5889

5890

    let dom_string = dom_string.trim();

5891

    Ok(dom_string.to_string())

5892

5893

5894

fn get_css_blocks(css: &Css, matcher: &CssMatcher) -> Vec<CssBlock> {

5895

    let mut blocks = Vec::new();

5896

5897

    for css_block in css.rules.as_ref() {

5898

        if matcher.matches(&css_block.path) {

5899

            let mut ending = None;

5900

5901

            if let Some(CssPathSelector::PseudoSelector(p)) =

5902

                css_block.path.selectors.as_ref().last()

5903

5904

                ending = Some(p.clone());

5905

5906

5907

            blocks.push(CssBlock {

5908

                ending,

5909

                block: css_block.clone(),

5910

});

5911

5912

5913

5914

    blocks

5915

5916

5917

fn compile_and_format_dynamic_items(input: &[DynamicItem]) -> String {

5918

    use self::DynamicItem::*;

5919

    if input.is_empty() {

5920

        String::from("AzString::from_const_str(\"\")")

5921

    } else if input.len() == 1 {

5922

        // common: there is only one "dynamic item" - skip the "format!()" macro

5923

        match &input[0] {

5924

            Var { name, format_spec } => {

5925

                let var_name = normalize_casing(name.trim());

5926

                if let Some(spec) = format_spec {

5927

                    format!("format!(\"{{:{}}}\", {}).into()", spec, var_name)

5928

                } else {

5929

                    var_name

5930

5931

5932

            Str(s) => format!("AzString::from_const_str(\"{}\")", s),

5933

5934

    } else {

5935

        // build a "format!("{var}, blah", var)" string

5936

        let mut formatted_str = String::from("format!(\"");

5937

        let mut variables = Vec::new();

5938

        for item in input {

5939

            match item {

5940

                Var { name, format_spec } => {

5941

                    let variable_name = normalize_casing(name.trim());

5942

                    if let Some(spec) = format_spec {

5943

                        formatted_str.push_str(&format!("{{{}:{}}}", variable_name, spec));

5944

                    } else {

5945

                        formatted_str.push_str(&format!("{{{}}}", variable_name));

5946

5947

                    variables.push(variable_name.clone());

5948

5949

                Str(s) => {

5950

                    let s = s.replace("\"", "\\\"");

5951

                    formatted_str.push_str(&s);

5952

5953

5954

5955

5956

        formatted_str.push('\"');

5957

        if !variables.is_empty() {

5958

            formatted_str.push_str(", ");

5959

5960

5961

        formatted_str.push_str(&variables.join(", "));

5962

        formatted_str.push_str(").into()");

5963

        formatted_str

5964

5965

5966

5967

fn format_args_for_rust_code(input: &str) -> String {

5968

    let dynamic_str_items = split_dynamic_string(input);

5969

    compile_and_format_dynamic_items(&dynamic_str_items)

5970

5971

5972

fn compile_node_to_rust_code_inner<'a>(

5973

    node: &XmlNode,

5974

    component_map: &'a ComponentMap,

5975

    tabs: usize,

5976

    extra_blocks: &mut VecContents,

5977

    css_blocks: &mut BTreeMap<String, String>,

5978

    css: &Css,

5979

    mut matcher: CssMatcher,

5980

) -> Result<String, CompileError> {

5981

    use azul_css::css::CssDeclaration;

5982

5983

    let t = String::from("    ").repeat(tabs - 1);

5984

    let t2 = String::from("    ").repeat(tabs);

5985

5986

    let component_name = normalize_casing(&node.node_type);

5987

5988

    // Build the data model from XML attributes

5989

    let def = component_map.get_unqualified(&component_name);

5990

5991

    // Look up the CSS NodeTypeTag

5992

    let node_type_tag = tag_to_node_type_tag(&component_name);

5993

    let node_type = CssPathSelector::Type(node_type_tag);

5994

5995

    // Generate DOM creation code using the component's compile_fn

5996

    let text_content = node.get_text_content();

5997

    let text_content_trimmed = text_content.trim();

5998

    let mut dom_string = if let Some(d) = def {

5999

        let data_model = xml_attrs_to_data_model(

6000

            &d.data_model,

6001

            &node.attributes,

6002

            if text_content_trimmed.is_empty() { None } else { Some(text_content_trimmed) },

6003

);

6004

        match (d.compile_fn)(d, &CompileTarget::Rust, &data_model, tabs) {

6005

            ResultStringCompileError::Ok(s) => format!("{}{}", t2, s.as_str()),

6006

            ResultStringCompileError::Err(_) => {

6007

                // Fallback: generate basic DOM node

6008

                let node_type = tag_to_node_type(&component_name);

6009

                format!("{}Dom::create_node(NodeType::{:?})", t2, node_type)

6010

6011

6012

    } else {

6013

        // Unknown component, generate div fallback

6014

        format!("{}Dom::create_node(NodeType::Div) /* {} */", t2, component_name)

6015

};

6016

6017

    matcher.path.push(node_type);

6018

    let ids = node

6019

        .attributes

6020

        .get_key("id")

6021

        .map(|s| s.split_whitespace().collect::<Vec<_>>())

6022

        .unwrap_or_default();

6023

6024

    matcher.path.extend(

6025

        ids.into_iter()

6026

            .map(|id| CssPathSelector::Id(id.to_string().into())),

6027

);

6028

6029

    let classes = node

6030

        .attributes

6031

        .get_key("class")

6032

        .map(|s| s.split_whitespace().collect::<Vec<_>>())

6033

        .unwrap_or_default();

6034

6035

    matcher.path.extend(

6036

        classes

6037

            .into_iter()

6038

            .map(|class| CssPathSelector::Class(class.to_string().into())),

6039

);

6040

6041

    let matcher_hash = matcher.get_hash();

6042

    let css_blocks_for_this_node = get_css_blocks(css, &matcher);

6043

    if !css_blocks_for_this_node.is_empty() {

6044

        use azul_css::props::property::format_static_css_prop;

6045

6046

        let css_strings = css_blocks_for_this_node

6047

            .iter()

6048

            .rev()

6049

            .map(|css_block| {

6050

                let wrapper = match css_block.ending {

6051

                    Some(CssPathPseudoSelector::Hover) => "Hover",

6052

                    Some(CssPathPseudoSelector::Active) => "Active",

6053

                    Some(CssPathPseudoSelector::Focus) => "Focus",

6054

                    _ => "Normal",

6055

};

6056

6057

                for declaration in css_block.block.declarations.as_ref().iter() {

6058

                    let prop = match declaration {

6059

                        CssDeclaration::Static(s) => s,

6060

                        CssDeclaration::Dynamic(d) => &d.default_value,

6061

};

6062

                    extra_blocks.insert_from_css_property(prop);

6063

6064

6065

                let formatted = css_block

6066

                    .block

6067

                    .declarations

6068

                    .as_ref()

6069

                    .iter()

6070

                    .rev()

6071

                    .map(|s| match &s {

6072

                        CssDeclaration::Static(s) => format!(

6073

                            "NodeDataInlineCssProperty::{}({})",

6074

                            wrapper,

6075

                            format_static_css_prop(s, 1)

6076

),

6077

                        CssDeclaration::Dynamic(d) => format!(

6078

                            "NodeDataInlineCssProperty::{}({})",

6079

                            wrapper,

6080

                            format_static_css_prop(&d.default_value, 1)

6081

),

6082

})

6083

                    .collect::<Vec<String>>();

6084

6085

                format!("// {}\r\n{}", css_block.block.path, formatted.join(",\r\n"))

6086

})

6087

            .collect::<Vec<_>>()

6088

            .join(",\r\n");

6089

6090

        css_blocks.insert(format!("CSS_MATCH_{:09}", matcher_hash), css_strings);

6091

        dom_string.push_str(&format!(

6092

            "\r\n{}.with_inline_css_props(CSS_MATCH_{:09})",

6093

            t2, matcher_hash

6094

));

6095

6096

6097

    set_stringified_attributes(

6098

        &mut dom_string,

6099

        &node.attributes,

6100

        &ComponentArgumentVec::new(),

6101

        tabs,

6102

);

6103

6104

    let mut children_string = node

6105

        .children

6106

        .as_ref()

6107

        .iter()

6108

        .enumerate()

6109

        .filter_map(|(child_idx, c)| match c {

6110

            XmlNodeChild::Element(child_node) => {

6111

                let mut matcher = matcher.clone();

6112

                matcher.path.push(CssPathSelector::Children);

6113

                matcher.indices_in_parent.push(child_idx);

6114

                matcher.children_length.push(node.children.len());

6115

6116

                Some(compile_node_to_rust_code_inner(

6117

                    child_node,

6118

                    component_map,

6119

                    tabs + 1,

6120

                    extra_blocks,

6121

                    css_blocks,

6122

                    css,

6123

                    matcher,

6124

))

6125

6126

            XmlNodeChild::Text(text) => {

6127

                let text = text.trim();

6128

                if text.is_empty() {

6129

                    None

6130

                } else {

6131

                    let t2 = String::from("    ").repeat(tabs);

6132

                    let escaped = text.replace("\\", "\\\\").replace("\"", "\\\"");

6133

                    Some(Ok(format!("{}Dom::create_text(\"{}\".into())", t2, escaped)))

6134

6135

6136

})

6137

        .collect::<Result<Vec<_>, _>>()?

6138

        .join(&format!(",\r\n"));

6139

6140

    if !children_string.is_empty() {

6141

        dom_string.push_str(&format!(

6142

            "\r\n{}.with_children(DomVec::from_vec(vec![\r\n{}\r\n{}]))",

6143

            t2, children_string, t2

6144

));

6145

6146

6147

    Ok(dom_string)

6148

6149

6150

#[cfg(test)]

6151

mod tests {

6152

    use super::*;

6153

    use crate::dom::{Dom, NodeType};

6154

6155

    #[test]

6156

1

    fn test_inline_span_parsing() {

6157

        // This test verifies that HTML with inline spans is parsed correctly

6158

        // The DOM structure should preserve text nodes before, inside, and after the span

6159

6160

1

        let html = r#"<p>Text before <span class="highlight">inline text</span> text after.</p>"#;

6161

6162

        // Expected DOM structure:

6163

        // <p>

6164

        //   ├─ TextNode: "Text before "

6165

        //   ├─ <span class="highlight">

6166

        //   │   └─ TextNode: "inline text"

6167

        //   └─ TextNode: " text after."

6168

6169

        // For this test, we'll create the DOM structure manually

6170

        // since we're testing the parsing logic

6171

1

        let expected_dom = Dom::create_p().with_children(

6172

1

            vec![

6173

1

                Dom::create_text("Text before "),

6174

1

                Dom::create_node(NodeType::Span)

6175

1

                    .with_children(vec![Dom::create_text("inline text")].into()),

6176

1

                Dom::create_text(" text after."),

6177

6178

1

            .into(),

6179

);

6180

6181

        // Verify the structure has 3 children at the top level

6182

1

        assert_eq!(expected_dom.children.as_ref().len(), 3);

6183

6184

        // Verify the middle child is a span

6185

1

        match &expected_dom.children.as_ref()[1].root.node_type {

6186

1

            NodeType::Span => {}

6187

            other => panic!("Expected Span, got {:?}", other),

6188

6189

6190

        // Verify the span has 1 child (the text node)

6191

1

        assert_eq!(expected_dom.children.as_ref()[1].children.as_ref().len(), 1);

6192

6193

1

        println!("Test passed: Inline span parsing structure is correct");

6194

1

6195

6196

    #[test]

6197

1

    fn test_xml_node_structure() {

6198

        // Test the basic XmlNode structure to ensure text content is preserved

6199

        // Updated to use XmlNodeChild enum (Text/Element)

6200

6201

1

        let node = XmlNode {

6202

1

            node_type: "p".into(),

6203

1

            attributes: XmlAttributeMap {

6204

1

                inner: StringPairVec::from_const_slice(&[]),

6205

1

},

6206

1

            children: vec![

6207

1

                XmlNodeChild::Text("Before ".into()),

6208

1

                XmlNodeChild::Element(XmlNode {

6209

1

                    node_type: "span".into(),

6210

1

                    children: vec![XmlNodeChild::Text("inline".into())].into(),

6211

1

                    ..Default::default()

6212

1

}),

6213

1

                XmlNodeChild::Text(" after".into()),

6214

1

6215

1

            .into(),

6216

1

};

6217

6218

        // Verify structure

6219

1

        assert_eq!(node.children.as_ref().len(), 3);

6220

1

        assert_eq!(node.children.as_ref()[0].as_text(), Some("Before "));

6221

1

        assert_eq!(

6222

1

            node.children.as_ref()[1]

6223

1

                .as_element()

6224

1

                .unwrap()

6225

1

                .node_type

6226

1

                .as_str(),

6227

            "span"

6228

);

6229

1

        assert_eq!(node.children.as_ref()[2].as_text(), Some(" after"));

6230

6231

        // Verify span's child

6232

1

        let span = node.children.as_ref()[1].as_element().unwrap();

6233

1

        assert_eq!(span.children.as_ref().len(), 1);

6234

1

        assert_eq!(span.children.as_ref()[0].as_text(), Some("inline"));

6235

6236

1

        println!("Test passed: XmlNode structure preserves text nodes correctly");

6237

1

6238

6239

    #[test]

6240

1

    fn test_img_tag_becomes_image_node_with_src_tag() {

6241

        // `<img src="cat.jpg" width="300" height="169">` must become a

6242

        // `NodeType::Image` whose `NullImage` carries the `src` string as its

6243

        // `tag` (so a renderer can resolve the bytes later), plus the declared

6244

        // intrinsic size.

6245

        use crate::resources::DecodedImage;

6246

        use crate::window::{AzStringPair, StringPairVec};

6247

6248

1

        let img_node = XmlNode {

6249

1

            node_type: "img".into(),

6250

1

            attributes: XmlAttributeMap::from(StringPairVec::from_vec(alloc::vec![

6251

1

                AzStringPair { key: "src".into(), value: "cat.jpg".into() },

6252

1

                AzStringPair { key: "width".into(), value: "300".into() },

6253

1

                AzStringPair { key: "height".into(), value: "169".into() },

6254

1

            ])),

6255

1

            children: alloc::vec::Vec::new().into(),

6256

1

};

6257

6258

1

        let component_map = ComponentMap::default();

6259

1

        let dom = super::xml_node_to_dom_fast(&img_node, &component_map, false)

6260

1

            .expect("xml_node_to_dom_fast for <img> should succeed");

6261

6262

1

        match dom.root.get_node_type() {

6263

1

            NodeType::Image(image_ref) => match image_ref.as_ref().get_data() {

6264

1

                DecodedImage::NullImage { tag, width, height, .. } => {

6265

1

                    assert_eq!(

6266

1

                        core::str::from_utf8(tag).unwrap(),

6267

                        "cat.jpg",

6268

                        "image tag must carry the src string"

6269

);

6270

1

                    assert_eq!(*width, 300, "width attribute should set intrinsic width");

6271

1

                    assert_eq!(*height, 169, "height attribute should set intrinsic height");

6272

6273

                other => panic!("expected NullImage carrying the src tag, got {:?}", other),

6274

},

6275

            other => panic!("expected NodeType::Image for <img>, got {:?}", other),

6276

6277

6278

1

        println!("Test passed: <img src=\"cat.jpg\"> -> NodeType::Image tagged \"cat.jpg\"");

6279

1

6280

6281

    #[test]

6282

1

    fn test_tag_to_node_type_img_is_image() {

6283

        // The bare tag mapping should also yield an Image (placeholder, empty tag).

6284

1

        match tag_to_node_type("img") {

6285

1

            NodeType::Image(_) => {}

6286

            other => panic!("tag_to_node_type(\"img\") should be Image, got {:?}", other),

6287

6288

1

6289