@pyreon/connector-document 0.11.5 → 0.11.6

package/lib/index.d.ts

@@ -25,7 +25,7 @@ declare function parseBoxModel(value: string | number | undefined, rootSize?: nu
 /**
  * Parse a CSS font-weight value.
  */
-declare function parseFontWeight(value: string | number | undefined): "normal" | "bold" | number | undefined;
+declare function parseFontWeight(value: string | number | undefined): 'normal' | 'bold' | number | undefined;
 /**
  * Parse a CSS line-height value to a unitless number.
  */

package/package.json

@@ -1,24 +1,13 @@
 {
   "name": "@pyreon/connector-document",
-  "version": "0.11.5",
+  "version": "0.11.6",
+  "description": "Bridge between @pyreon/pyreon styled components and @pyreon/document rendering",
+  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/pyreon/pyreon",
     "directory": "packages/ui-system/connector-document"
   },
-  "description": "Bridge between @pyreon/pyreon styled components and @pyreon/document rendering",
-  "license": "MIT",
-  "type": "module",
-  "sideEffects": false,
-  "exports": {
-    ".": {
-      "bun": "./src/index.ts",
-      "import": "./lib/index.js",
-      "types": "./lib/index.d.ts"
-    }
-  },
-  "types": "./lib/index.d.ts",
-  "main": "./lib/index.js",
   "files": [
     "lib",
     "!lib/**/*.map",
@@ -27,8 +16,16 @@
     "LICENSE",
     "src"
   ],
-  "engines": {
-    "node": ">= 22"
+  "type": "module",
+  "sideEffects": false,
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "import": "./lib/index.js",
+      "types": "./lib/index.d.ts"
+    }
   },
   "publishConfig": {
     "access": "public"
@@ -37,20 +34,23 @@
     "prepublish": "bun run build",
     "build": "bun run vl_rolldown_build",
     "build:watch": "bun run vl_rolldown_build-watch",
-    "lint": "biome check src/",
+    "lint": "oxlint .",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit"
   },
+  "devDependencies": {
+    "@pyreon/core": "^0.11.6",
+    "@pyreon/document": "^0.11.6",
+    "@pyreon/typescript": "^0.11.6",
+    "@vitus-labs/tools-rolldown": "^1.15.4"
+  },
   "peerDependencies": {
-    "@pyreon/core": "^0.11.5",
-    "@pyreon/document": "^0.11.5"
+    "@pyreon/core": "^0.11.6",
+    "@pyreon/document": "^0.11.6"
   },
-  "devDependencies": {
-    "@pyreon/core": "^0.11.5",
-    "@pyreon/document": "^0.11.5",
-    "@vitus-labs/tools-rolldown": "^1.15.4",
-    "@pyreon/typescript": "^0.11.5"
+  "engines": {
+    "node": ">= 22"
   }
 }

package/src/__tests__/cssValueParser.test.ts

@@ -1,136 +1,136 @@
-import { describe, expect, it } from "vitest"
+import { describe, expect, it } from 'vitest'
 import {
   parseBoxModel,
   parseCssDimension,
   parseFontWeight,
   parseLineHeight,
-} from "../cssValueParser"
+} from '../cssValueParser'
 
-describe("parseCssDimension", () => {
-  it("passes through numbers", () => {
+describe('parseCssDimension', () => {
+  it('passes through numbers', () => {
     expect(parseCssDimension(14)).toBe(14)
     expect(parseCssDimension(0)).toBe(0)
     expect(parseCssDimension(-5)).toBe(-5)
     expect(parseCssDimension(1.5)).toBe(1.5)
   })
 
-  it("parses px values", () => {
-    expect(parseCssDimension("14px")).toBe(14)
-    expect(parseCssDimension("0px")).toBe(0)
-    expect(parseCssDimension("-5px")).toBe(-5)
-    expect(parseCssDimension("1.5px")).toBe(1.5)
+  it('parses px values', () => {
+    expect(parseCssDimension('14px')).toBe(14)
+    expect(parseCssDimension('0px')).toBe(0)
+    expect(parseCssDimension('-5px')).toBe(-5)
+    expect(parseCssDimension('1.5px')).toBe(1.5)
   })
 
-  it("parses rem values", () => {
-    expect(parseCssDimension("1rem")).toBe(16)
-    expect(parseCssDimension("1.5rem")).toBe(24)
-    expect(parseCssDimension("0.5rem")).toBe(8)
-    expect(parseCssDimension("2rem", 20)).toBe(40)
+  it('parses rem values', () => {
+    expect(parseCssDimension('1rem')).toBe(16)
+    expect(parseCssDimension('1.5rem')).toBe(24)
+    expect(parseCssDimension('0.5rem')).toBe(8)
+    expect(parseCssDimension('2rem', 20)).toBe(40)
   })
 
-  it("parses em values", () => {
-    expect(parseCssDimension("1em")).toBe(16)
-    expect(parseCssDimension("2em")).toBe(32)
+  it('parses em values', () => {
+    expect(parseCssDimension('1em')).toBe(16)
+    expect(parseCssDimension('2em')).toBe(32)
   })
 
-  it("parses pt values", () => {
-    expect(parseCssDimension("12pt")).toBeCloseTo(16)
-    expect(parseCssDimension("9pt")).toBeCloseTo(12)
+  it('parses pt values', () => {
+    expect(parseCssDimension('12pt')).toBeCloseTo(16)
+    expect(parseCssDimension('9pt')).toBeCloseTo(12)
   })
 
-  it("parses bare number strings", () => {
-    expect(parseCssDimension("14")).toBe(14)
-    expect(parseCssDimension("0")).toBe(0)
-    expect(parseCssDimension("-5")).toBe(-5)
+  it('parses bare number strings', () => {
+    expect(parseCssDimension('14')).toBe(14)
+    expect(parseCssDimension('0')).toBe(0)
+    expect(parseCssDimension('-5')).toBe(-5)
   })
 
-  it("returns undefined for unresolvable values", () => {
-    expect(parseCssDimension("auto")).toBeUndefined()
-    expect(parseCssDimension("100%")).toBeUndefined()
-    expect(parseCssDimension("calc(100% - 20px)")).toBeUndefined()
-    expect(parseCssDimension("var(--spacing)")).toBeUndefined()
+  it('returns undefined for unresolvable values', () => {
+    expect(parseCssDimension('auto')).toBeUndefined()
+    expect(parseCssDimension('100%')).toBeUndefined()
+    expect(parseCssDimension('calc(100% - 20px)')).toBeUndefined()
+    expect(parseCssDimension('var(--spacing)')).toBeUndefined()
   })
 
-  it("trims whitespace", () => {
-    expect(parseCssDimension(" 14px ")).toBe(14)
-    expect(parseCssDimension("  1rem  ")).toBe(16)
+  it('trims whitespace', () => {
+    expect(parseCssDimension(' 14px ')).toBe(14)
+    expect(parseCssDimension('  1rem  ')).toBe(16)
   })
 })
 
-describe("parseBoxModel", () => {
-  it("returns undefined for null/undefined", () => {
+describe('parseBoxModel', () => {
+  it('returns undefined for null/undefined', () => {
     expect(parseBoxModel(undefined)).toBeUndefined()
     expect(parseBoxModel(null as any)).toBeUndefined()
   })
 
-  it("passes through numbers", () => {
+  it('passes through numbers', () => {
     expect(parseBoxModel(8)).toBe(8)
     expect(parseBoxModel(0)).toBe(0)
   })
 
-  it("parses single value", () => {
-    expect(parseBoxModel("8px")).toBe(8)
-    expect(parseBoxModel("1rem")).toBe(16)
+  it('parses single value', () => {
+    expect(parseBoxModel('8px')).toBe(8)
+    expect(parseBoxModel('1rem')).toBe(16)
   })
 
-  it("parses two values (vertical horizontal)", () => {
-    expect(parseBoxModel("8px 16px")).toEqual([8, 16])
+  it('parses two values (vertical horizontal)', () => {
+    expect(parseBoxModel('8px 16px')).toEqual([8, 16])
   })
 
-  it("parses three values (top horizontal bottom)", () => {
-    expect(parseBoxModel("8px 16px 12px")).toEqual([8, 16, 12, 16])
+  it('parses three values (top horizontal bottom)', () => {
+    expect(parseBoxModel('8px 16px 12px')).toEqual([8, 16, 12, 16])
   })
 
-  it("parses four values", () => {
-    expect(parseBoxModel("8px 16px 12px 4px")).toEqual([8, 16, 12, 4])
+  it('parses four values', () => {
+    expect(parseBoxModel('8px 16px 12px 4px')).toEqual([8, 16, 12, 4])
   })
 
-  it("returns undefined when any part is unresolvable", () => {
-    expect(parseBoxModel("8px auto")).toBeUndefined()
-    expect(parseBoxModel("8px 16px auto 4px")).toBeUndefined()
+  it('returns undefined when any part is unresolvable', () => {
+    expect(parseBoxModel('8px auto')).toBeUndefined()
+    expect(parseBoxModel('8px 16px auto 4px')).toBeUndefined()
   })
 })
 
-describe("parseFontWeight", () => {
-  it("passes through numbers", () => {
+describe('parseFontWeight', () => {
+  it('passes through numbers', () => {
     expect(parseFontWeight(400)).toBe(400)
     expect(parseFontWeight(700)).toBe(700)
   })
 
-  it("handles string keywords", () => {
-    expect(parseFontWeight("normal")).toBe("normal")
-    expect(parseFontWeight("bold")).toBe("bold")
+  it('handles string keywords', () => {
+    expect(parseFontWeight('normal')).toBe('normal')
+    expect(parseFontWeight('bold')).toBe('bold')
   })
 
-  it("parses numeric strings", () => {
-    expect(parseFontWeight("400")).toBe(400)
-    expect(parseFontWeight("700")).toBe(700)
+  it('parses numeric strings', () => {
+    expect(parseFontWeight('400')).toBe(400)
+    expect(parseFontWeight('700')).toBe(700)
   })
 
-  it("returns undefined for null/undefined", () => {
+  it('returns undefined for null/undefined', () => {
     expect(parseFontWeight(undefined)).toBeUndefined()
   })
 
-  it("returns undefined for unrecognized values", () => {
-    expect(parseFontWeight("lighter")).toBeUndefined()
+  it('returns undefined for unrecognized values', () => {
+    expect(parseFontWeight('lighter')).toBeUndefined()
   })
 })
 
-describe("parseLineHeight", () => {
-  it("passes through numbers (unitless)", () => {
+describe('parseLineHeight', () => {
+  it('passes through numbers (unitless)', () => {
     expect(parseLineHeight(1.5)).toBe(1.5)
     expect(parseLineHeight(2)).toBe(2)
   })
 
-  it("parses px values", () => {
-    expect(parseLineHeight("24px")).toBe(24)
+  it('parses px values', () => {
+    expect(parseLineHeight('24px')).toBe(24)
   })
 
   it("returns undefined for 'normal'", () => {
-    expect(parseLineHeight("normal")).toBeUndefined()
+    expect(parseLineHeight('normal')).toBeUndefined()
   })
 
-  it("returns undefined for null/undefined", () => {
+  it('returns undefined for null/undefined', () => {
     expect(parseLineHeight(undefined)).toBeUndefined()
   })
 })

package/src/__tests__/extractDocumentTree.test.ts

@@ -1,6 +1,6 @@
-import { describe, expect, it } from "vitest"
-import type { DocumentMarker } from "../extractDocumentTree"
-import { extractDocumentTree } from "../extractDocumentTree"
+import { describe, expect, it } from 'vitest'
+import type { DocumentMarker } from '../extractDocumentTree'
+import { extractDocumentTree } from '../extractDocumentTree'
 
 // Helper: create a mock VNode
 const vnode = (
@@ -11,143 +11,143 @@ const vnode = (
 
 // Helper: create a document-marked component function
 const docComponent = (docType: string, render?: (...args: any[]) => any) => {
-  const fn = render ?? ((props: any) => vnode("div", props, props.children ? [props.children] : []))
+  const fn = render ?? ((props: any) => vnode('div', props, props.children ? [props.children] : []))
   ;(fn as any)._documentType = docType
   return fn as ((...args: any[]) => any) & DocumentMarker
 }
 
-describe("extractDocumentTree", () => {
-  it("extracts a simple document node", () => {
-    const Heading = docComponent("heading")
+describe('extractDocumentTree', () => {
+  it('extracts a simple document node', () => {
+    const Heading = docComponent('heading')
     const tree = vnode(
       Heading,
-      { $rocketstyle: { fontSize: 24, fontWeight: "bold" }, _documentProps: { level: 1 } },
-      ["Hello World"],
+      { $rocketstyle: { fontSize: 24, fontWeight: 'bold' }, _documentProps: { level: 1 } },
+      ['Hello World'],
     )
 
     const result = extractDocumentTree(tree)
 
-    expect(result.type).toBe("heading")
+    expect(result.type).toBe('heading')
     expect(result.props).toEqual({ level: 1 })
-    expect(result.children).toEqual(["Hello World"])
-    expect(result.styles).toEqual({ fontSize: 24, fontWeight: "bold" })
+    expect(result.children).toEqual(['Hello World'])
+    expect(result.styles).toEqual({ fontSize: 24, fontWeight: 'bold' })
   })
 
-  it("extracts nested document nodes", () => {
-    const Section = docComponent("section")
-    const Text = docComponent("text")
+  it('extracts nested document nodes', () => {
+    const Section = docComponent('section')
+    const Text = docComponent('text')
 
     const tree = vnode(Section, { $rocketstyle: { padding: 16 } }, [
-      vnode(Text, { $rocketstyle: { fontSize: 14, color: "#333" } }, ["Paragraph one"]),
-      vnode(Text, { $rocketstyle: { fontSize: 14, color: "#333" } }, ["Paragraph two"]),
+      vnode(Text, { $rocketstyle: { fontSize: 14, color: '#333' } }, ['Paragraph one']),
+      vnode(Text, { $rocketstyle: { fontSize: 14, color: '#333' } }, ['Paragraph two']),
     ])
 
     const result = extractDocumentTree(tree)
 
-    expect(result.type).toBe("section")
+    expect(result.type).toBe('section')
     expect(result.styles).toEqual({ padding: 16 })
     expect(result.children).toHaveLength(2)
-    expect((result.children[0] as any).type).toBe("text")
-    expect((result.children[1] as any).type).toBe("text")
+    expect((result.children[0] as any).type).toBe('text')
+    expect((result.children[1] as any).type).toBe('text')
   })
 
-  it("flattens transparent wrappers", () => {
-    const Section = docComponent("section")
-    const Text = docComponent("text")
+  it('flattens transparent wrappers', () => {
+    const Section = docComponent('section')
+    const Text = docComponent('text')
 
     // A plain div wrapper (no _documentType) should be transparent
     const tree = vnode(Section, {}, [
-      vnode("div", {}, [vnode(Text, { $rocketstyle: { fontSize: 14 } }, ["Hello"])]),
+      vnode('div', {}, [vnode(Text, { $rocketstyle: { fontSize: 14 } }, ['Hello'])]),
     ])
 
     const result = extractDocumentTree(tree)
 
-    expect(result.type).toBe("section")
+    expect(result.type).toBe('section')
     expect(result.children).toHaveLength(1)
-    expect((result.children[0] as any).type).toBe("text")
+    expect((result.children[0] as any).type).toBe('text')
   })
 
-  it("handles string children", () => {
-    const Text = docComponent("text")
-    const tree = vnode(Text, {}, ["Hello", " ", "World"])
+  it('handles string children', () => {
+    const Text = docComponent('text')
+    const tree = vnode(Text, {}, ['Hello', ' ', 'World'])
 
     const result = extractDocumentTree(tree)
 
-    expect(result.children).toEqual(["Hello", " ", "World"])
+    expect(result.children).toEqual(['Hello', ' ', 'World'])
   })
 
-  it("handles number children", () => {
-    const Text = docComponent("text")
+  it('handles number children', () => {
+    const Text = docComponent('text')
     const tree = vnode(Text, {}, [42])
 
     const result = extractDocumentTree(tree)
 
-    expect(result.children).toEqual(["42"])
+    expect(result.children).toEqual(['42'])
   })
 
-  it("skips null and boolean children", () => {
-    const Section = docComponent("section")
-    const tree = vnode(Section, {}, [null, false, true, "visible"])
+  it('skips null and boolean children', () => {
+    const Section = docComponent('section')
+    const tree = vnode(Section, {}, [null, false, true, 'visible'])
 
     const result = extractDocumentTree(tree)
 
-    expect(result.children).toEqual(["visible"])
+    expect(result.children).toEqual(['visible'])
   })
 
-  it("resolves reactive getter children", () => {
-    const Text = docComponent("text")
-    const tree = vnode(Text, {}, [() => "dynamic text"])
+  it('resolves reactive getter children', () => {
+    const Text = docComponent('text')
+    const tree = vnode(Text, {}, [() => 'dynamic text'])
 
     const result = extractDocumentTree(tree)
 
-    expect(result.children).toEqual(["dynamic text"])
+    expect(result.children).toEqual(['dynamic text'])
   })
 
-  it("omits styles when includeStyles is false", () => {
-    const Heading = docComponent("heading")
-    const tree = vnode(Heading, { $rocketstyle: { fontSize: 24 } }, ["Hello"])
+  it('omits styles when includeStyles is false', () => {
+    const Heading = docComponent('heading')
+    const tree = vnode(Heading, { $rocketstyle: { fontSize: 24 } }, ['Hello'])
 
     const result = extractDocumentTree(tree, { includeStyles: false })
 
     expect(result.styles).toBeUndefined()
   })
 
-  it("wraps in document node when root has no _documentType", () => {
-    const tree = vnode("div", {}, ["raw text"])
+  it('wraps in document node when root has no _documentType', () => {
+    const tree = vnode('div', {}, ['raw text'])
 
     const result = extractDocumentTree(tree)
 
-    expect(result.type).toBe("document")
-    expect(result.children).toEqual(["raw text"])
+    expect(result.type).toBe('document')
+    expect(result.children).toEqual(['raw text'])
   })
 
-  it("handles component functions without _documentType by calling them", () => {
-    const Text = docComponent("text")
+  it('handles component functions without _documentType by calling them', () => {
+    const Text = docComponent('text')
     const Wrapper = (props: any) =>
       vnode(Text, { $rocketstyle: { fontSize: 14 } }, [props.children])
 
-    const tree = vnode(Wrapper, {}, ["wrapped text"])
+    const tree = vnode(Wrapper, {}, ['wrapped text'])
 
     const result = extractDocumentTree(tree)
 
-    expect(result.type).toBe("text")
-    expect(result.children).toEqual(["wrapped text"])
+    expect(result.type).toBe('text')
+    expect(result.children).toEqual(['wrapped text'])
   })
 
-  it("handles function passed directly", () => {
-    const Text = docComponent("text")
-    const template = () => vnode(Text, { $rocketstyle: { fontSize: 14 } }, ["Hello"])
+  it('handles function passed directly', () => {
+    const Text = docComponent('text')
+    const template = () => vnode(Text, { $rocketstyle: { fontSize: 14 } }, ['Hello'])
 
     const result = extractDocumentTree(template)
 
-    expect(result.type).toBe("text")
-    expect(result.children).toEqual(["Hello"])
+    expect(result.type).toBe('text')
+    expect(result.children).toEqual(['Hello'])
   })
 
-  it("creates empty document for null input", () => {
+  it('creates empty document for null input', () => {
     const result = extractDocumentTree(null)
 
-    expect(result.type).toBe("document")
+    expect(result.type).toBe('document')
     expect(result.children).toEqual([])
   })
 })

package/src/__tests__/resolveStyles.test.ts

@@ -1,37 +1,37 @@
-import { describe, expect, it } from "vitest"
-import { resolveStyles } from "../resolveStyles"
+import { describe, expect, it } from 'vitest'
+import { resolveStyles } from '../resolveStyles'
 
-describe("resolveStyles", () => {
-  it("resolves typography properties", () => {
+describe('resolveStyles', () => {
+  it('resolves typography properties', () => {
     const result = resolveStyles({
-      fontSize: "14px",
-      fontFamily: "system-ui, sans-serif",
-      fontWeight: "bold",
-      fontStyle: "italic",
-      textDecoration: "underline",
-      color: "#333333",
-      textAlign: "center",
+      fontSize: '14px',
+      fontFamily: 'system-ui, sans-serif',
+      fontWeight: 'bold',
+      fontStyle: 'italic',
+      textDecoration: 'underline',
+      color: '#333333',
+      textAlign: 'center',
       lineHeight: 1.5,
-      letterSpacing: "0.5px",
+      letterSpacing: '0.5px',
     })
 
     expect(result).toEqual({
       fontSize: 14,
-      fontFamily: "system-ui, sans-serif",
-      fontWeight: "bold",
-      fontStyle: "italic",
-      textDecoration: "underline",
-      color: "#333333",
-      textAlign: "center",
+      fontFamily: 'system-ui, sans-serif',
+      fontWeight: 'bold',
+      fontStyle: 'italic',
+      textDecoration: 'underline',
+      color: '#333333',
+      textAlign: 'center',
       lineHeight: 1.5,
       letterSpacing: 0.5,
     })
   })
 
-  it("resolves box model properties", () => {
+  it('resolves box model properties', () => {
     const result = resolveStyles({
-      padding: "8px 16px",
-      margin: "12px",
+      padding: '8px 16px',
+      margin: '12px',
     })
 
     expect(result).toEqual({
@@ -40,37 +40,37 @@ describe("resolveStyles", () => {
     })
   })
 
-  it("resolves border properties", () => {
+  it('resolves border properties', () => {
     const result = resolveStyles({
-      borderRadius: "4px",
-      borderWidth: "1px",
-      borderColor: "#dddddd",
-      borderStyle: "solid",
+      borderRadius: '4px',
+      borderWidth: '1px',
+      borderColor: '#dddddd',
+      borderStyle: 'solid',
     })
 
     expect(result).toEqual({
       borderRadius: 4,
       borderWidth: 1,
-      borderColor: "#dddddd",
-      borderStyle: "solid",
+      borderColor: '#dddddd',
+      borderStyle: 'solid',
     })
   })
 
-  it("resolves sizing properties", () => {
+  it('resolves sizing properties', () => {
     const result = resolveStyles({
-      width: "200px",
+      width: '200px',
       height: 100,
-      maxWidth: "100%",
+      maxWidth: '100%',
     })
 
     expect(result).toEqual({
       width: 200,
       height: 100,
-      maxWidth: "100%",
+      maxWidth: '100%',
     })
   })
 
-  it("handles numeric values directly", () => {
+  it('handles numeric values directly', () => {
     const result = resolveStyles({
       fontSize: 14,
       padding: 8,
@@ -84,41 +84,41 @@ describe("resolveStyles", () => {
     })
   })
 
-  it("ignores irrelevant CSS properties", () => {
+  it('ignores irrelevant CSS properties', () => {
     const result = resolveStyles({
       fontSize: 14,
-      transition: "all 0.2s",
-      cursor: "pointer",
-      display: "flex",
-      position: "relative",
-      transform: "translateX(10px)",
+      transition: 'all 0.2s',
+      cursor: 'pointer',
+      display: 'flex',
+      position: 'relative',
+      transform: 'translateX(10px)',
     })
 
     expect(result).toEqual({ fontSize: 14 })
   })
 
-  it("skips invalid values", () => {
+  it('skips invalid values', () => {
     const result = resolveStyles({
-      fontStyle: "oblique",
-      textDecoration: "overline",
-      borderStyle: "none",
-      textAlign: "start",
+      fontStyle: 'oblique',
+      textDecoration: 'overline',
+      borderStyle: 'none',
+      textAlign: 'start',
     })
 
     expect(result).toEqual({})
   })
 
-  it("returns empty object for empty input", () => {
+  it('returns empty object for empty input', () => {
     expect(resolveStyles({})).toEqual({})
   })
 
-  it("handles backgroundColor", () => {
-    const result = resolveStyles({ backgroundColor: "#4f46e5" })
-    expect(result).toEqual({ backgroundColor: "#4f46e5" })
+  it('handles backgroundColor', () => {
+    const result = resolveStyles({ backgroundColor: '#4f46e5' })
+    expect(result).toEqual({ backgroundColor: '#4f46e5' })
   })
 
-  it("converts rem values using rootSize", () => {
-    const result = resolveStyles({ fontSize: "1.5rem" }, 20)
+  it('converts rem values using rootSize', () => {
+    const result = resolveStyles({ fontSize: '1.5rem' }, 20)
     expect(result).toEqual({ fontSize: 30 })
   })
 })

package/src/cssValueParser.ts

@@ -20,8 +20,8 @@ export function parseCssDimension(
   rootSize = DEFAULT_ROOT_SIZE,
 ): number | undefined {
   if (value == null) return undefined
-  if (typeof value === "number") return value
-  if (typeof value !== "string") return undefined
+  if (typeof value === 'number') return value
+  if (typeof value !== 'string') return undefined
 
   const trimmed = value.trim()
 
@@ -58,7 +58,7 @@ export function parseBoxModel(
   rootSize = DEFAULT_ROOT_SIZE,
 ): BoxModelResult {
   if (value == null) return undefined
-  if (typeof value === "number") return value
+  if (typeof value === 'number') return value
 
   const parts = value
     .trim()
@@ -83,10 +83,10 @@ export function parseBoxModel(
  */
 export function parseFontWeight(
   value: string | number | undefined,
-): "normal" | "bold" | number | undefined {
+): 'normal' | 'bold' | number | undefined {
   if (value == null) return undefined
-  if (typeof value === "number") return value
-  if (value === "normal" || value === "bold") return value
+  if (typeof value === 'number') return value
+  if (value === 'normal' || value === 'bold') return value
   const num = Number.parseInt(value, 10)
   if (!Number.isNaN(num)) return num
   return undefined
@@ -100,8 +100,8 @@ export function parseLineHeight(
   rootSize = DEFAULT_ROOT_SIZE,
 ): number | undefined {
   if (value == null) return undefined
-  if (typeof value === "number") return value
-  if (value === "normal") return undefined
+  if (typeof value === 'number') return value
+  if (value === 'normal') return undefined
 
   const dim = parseCssDimension(value, rootSize)
   if (dim != null) return dim

package/src/extractDocumentTree.ts

@@ -1,5 +1,5 @@
-import { resolveStyles } from "./resolveStyles"
-import type { DocChild, DocNode, NodeType } from "./types"
+import { resolveStyles } from './resolveStyles'
+import type { DocChild, DocNode, NodeType } from './types'
 
 /** Marker interface: components with _documentType are extractable. */
 export interface DocumentMarker {
@@ -20,15 +20,15 @@ type VNodeLike = {
 }
 
 function isVNode(value: unknown): value is VNodeLike {
-  return value != null && typeof value === "object" && "type" in value && "props" in value
+  return value != null && typeof value === 'object' && 'type' in value && 'props' in value
 }
 
 function getDocumentType(fn: unknown): NodeType | undefined {
-  if (typeof fn !== "function") return undefined
+  if (typeof fn !== 'function') return undefined
   const meta = (fn as any).meta
   if (meta?._documentType) return meta._documentType as NodeType
   // Fallback: check directly on function (non-rocketstyle components)
-  if ("_documentType" in fn) return (fn as any)._documentType as NodeType
+  if ('_documentType' in fn) return (fn as any)._documentType as NodeType
   return undefined
 }
 
@@ -37,7 +37,7 @@ function flattenChildren(children: unknown[]): unknown[] {
   for (const child of children) {
     if (Array.isArray(child)) {
       result.push(...flattenChildren(child))
-    } else if (typeof child === "function") {
+    } else if (typeof child === 'function') {
       // Reactive getter — call to resolve
       const resolved = child()
       if (Array.isArray(resolved)) {
@@ -59,12 +59,12 @@ function extractChildren(children: unknown[], options: ExtractOptions): DocChild
   for (const child of flat) {
     if (child == null || child === false || child === true) continue
 
-    if (typeof child === "string") {
+    if (typeof child === 'string') {
       result.push(child)
       continue
     }
 
-    if (typeof child === "number") {
+    if (typeof child === 'number') {
       result.push(String(child))
       continue
     }
@@ -93,7 +93,7 @@ function extractNode(vnode: VNodeLike, options: ExtractOptions): DocNode | DocCh
     const docProps: Record<string, unknown> = {}
 
     // Extract document-specific props from _documentProps
-    if (props._documentProps && typeof props._documentProps === "object") {
+    if (props._documentProps && typeof props._documentProps === 'object') {
       Object.assign(docProps, props._documentProps)
     }
 
@@ -120,7 +120,7 @@ function extractNode(vnode: VNodeLike, options: ExtractOptions): DocNode | DocCh
   }
 
   // Component function WITHOUT _documentType — call it to get its VNode output
-  if (typeof type === "function") {
+  if (typeof type === 'function') {
     const mergedProps = { ...props }
     if (children && children.length > 0) {
       mergedProps.children = children.length === 1 ? children[0] : children
@@ -133,13 +133,13 @@ function extractNode(vnode: VNodeLike, options: ExtractOptions): DocNode | DocCh
     }
 
     // The component returned a primitive or null
-    if (typeof result === "string") return [result]
-    if (typeof result === "number") return [String(result)]
+    if (typeof result === 'string') return [result]
+    if (typeof result === 'number') return [String(result)]
     return null
   }
 
   // DOM element (string type like 'div', 'span') — transparent, extract children
-  if (typeof type === "string") {
+  if (typeof type === 'string') {
     const docChildren = extractChildren(children ?? [], options)
     // If there's text content in the DOM element, collect it
     if (docChildren.length > 0) return docChildren
@@ -168,14 +168,14 @@ export function extractDocumentTree(vnode: unknown, options: ExtractOptions = {}
 
     // Wrap loose children in a document node
     const children = Array.isArray(result) ? result : []
-    return { type: "document", props: {}, children }
+    return { type: 'document', props: {}, children }
   }
 
   // If passed a component function directly, call it
-  if (typeof vnode === "function") {
+  if (typeof vnode === 'function') {
     const result = (vnode as () => unknown)()
     return extractDocumentTree(result, options)
   }
 
-  return { type: "document", props: {}, children: [] }
+  return { type: 'document', props: {}, children: [] }
 }

package/src/index.ts

@@ -3,8 +3,8 @@ export {
   parseCssDimension,
   parseFontWeight,
   parseLineHeight,
-} from "./cssValueParser"
-export type { DocumentMarker, ExtractOptions } from "./extractDocumentTree"
-export { extractDocumentTree } from "./extractDocumentTree"
-export { resolveStyles } from "./resolveStyles"
-export type { DocChild, DocNode, NodeType, ResolvedStyles } from "./types"
+} from './cssValueParser'
+export type { DocumentMarker, ExtractOptions } from './extractDocumentTree'
+export { extractDocumentTree } from './extractDocumentTree'
+export { resolveStyles } from './resolveStyles'
+export type { DocChild, DocNode, NodeType, ResolvedStyles } from './types'

package/src/resolveStyles.ts

@@ -3,13 +3,13 @@ import {
   parseCssDimension,
   parseFontWeight,
   parseLineHeight,
-} from "./cssValueParser"
-import type { ResolvedStyles } from "./types"
+} from './cssValueParser'
+import type { ResolvedStyles } from './types'
 
-const TEXT_ALIGN_VALUES = new Set(["left", "center", "right", "justify"])
-const FONT_STYLE_VALUES = new Set(["normal", "italic"])
-const TEXT_DECORATION_VALUES = new Set(["none", "underline", "line-through"])
-const BORDER_STYLE_VALUES = new Set(["solid", "dashed", "dotted"])
+const TEXT_ALIGN_VALUES = new Set(['left', 'center', 'right', 'justify'])
+const FONT_STYLE_VALUES = new Set(['normal', 'italic'])
+const TEXT_DECORATION_VALUES = new Set(['none', 'underline', 'line-through'])
+const BORDER_STYLE_VALUES = new Set(['solid', 'dashed', 'dotted'])
 
 /**
  * Convert a rocketstyle `$rocketstyle` theme object into a `ResolvedStyles`
@@ -25,27 +25,27 @@ export function resolveStyles(rocketstyle: Record<string, unknown>, rootSize = 1
   const fontSize = parseCssDimension(rocketstyle.fontSize as string | number, rootSize)
   if (fontSize != null) styles.fontSize = fontSize
 
-  if (typeof rocketstyle.fontFamily === "string") styles.fontFamily = rocketstyle.fontFamily
+  if (typeof rocketstyle.fontFamily === 'string') styles.fontFamily = rocketstyle.fontFamily
 
   const fontWeight = parseFontWeight(rocketstyle.fontWeight as string | number | undefined)
   if (fontWeight != null) styles.fontWeight = fontWeight
 
-  if (typeof rocketstyle.fontStyle === "string" && FONT_STYLE_VALUES.has(rocketstyle.fontStyle))
-    styles.fontStyle = rocketstyle.fontStyle as "normal" | "italic"
+  if (typeof rocketstyle.fontStyle === 'string' && FONT_STYLE_VALUES.has(rocketstyle.fontStyle))
+    styles.fontStyle = rocketstyle.fontStyle as 'normal' | 'italic'
 
   if (
-    typeof rocketstyle.textDecoration === "string" &&
+    typeof rocketstyle.textDecoration === 'string' &&
     TEXT_DECORATION_VALUES.has(rocketstyle.textDecoration)
   )
-    styles.textDecoration = rocketstyle.textDecoration as "none" | "underline" | "line-through"
+    styles.textDecoration = rocketstyle.textDecoration as 'none' | 'underline' | 'line-through'
 
-  if (typeof rocketstyle.color === "string") styles.color = rocketstyle.color
+  if (typeof rocketstyle.color === 'string') styles.color = rocketstyle.color
 
-  if (typeof rocketstyle.backgroundColor === "string")
+  if (typeof rocketstyle.backgroundColor === 'string')
     styles.backgroundColor = rocketstyle.backgroundColor
 
-  if (typeof rocketstyle.textAlign === "string" && TEXT_ALIGN_VALUES.has(rocketstyle.textAlign))
-    styles.textAlign = rocketstyle.textAlign as "left" | "center" | "right" | "justify"
+  if (typeof rocketstyle.textAlign === 'string' && TEXT_ALIGN_VALUES.has(rocketstyle.textAlign))
+    styles.textAlign = rocketstyle.textAlign as 'left' | 'center' | 'right' | 'justify'
 
   const lineHeight = parseLineHeight(
     rocketstyle.lineHeight as string | number | undefined,
@@ -70,13 +70,13 @@ export function resolveStyles(rocketstyle: Record<string, unknown>, rootSize = 1
   const borderWidth = parseCssDimension(rocketstyle.borderWidth as string | number, rootSize)
   if (borderWidth != null) styles.borderWidth = borderWidth
 
-  if (typeof rocketstyle.borderColor === "string") styles.borderColor = rocketstyle.borderColor
+  if (typeof rocketstyle.borderColor === 'string') styles.borderColor = rocketstyle.borderColor
 
   if (
-    typeof rocketstyle.borderStyle === "string" &&
+    typeof rocketstyle.borderStyle === 'string' &&
     BORDER_STYLE_VALUES.has(rocketstyle.borderStyle)
   )
-    styles.borderStyle = rocketstyle.borderStyle as "solid" | "dashed" | "dotted"
+    styles.borderStyle = rocketstyle.borderStyle as 'solid' | 'dashed' | 'dotted'
 
   // Sizing
   if (rocketstyle.width != null) {
@@ -95,7 +95,7 @@ export function resolveStyles(rocketstyle: Record<string, unknown>, rootSize = 1
   }
 
   // Opacity
-  if (typeof rocketstyle.opacity === "number") styles.opacity = rocketstyle.opacity
+  if (typeof rocketstyle.opacity === 'number') styles.opacity = rocketstyle.opacity
 
   return styles
 }

package/src/types.ts

@@ -1 +1 @@
-export type { DocChild, DocNode, NodeType, ResolvedStyles } from "@pyreon/document"
+export type { DocChild, DocNode, NodeType, ResolvedStyles } from '@pyreon/document'