@uniweb/semantic-parser 1.1.4 → 1.1.6

package/AGENTS.md

@@ -61,16 +61,16 @@ The parser returns a flat content structure:
   title: '',       // Main heading
   pretitle: '',    // Heading before main title
   subtitle: '',    // Heading after main title
-  subtitle2: '',   // Third heading level
   paragraphs: [],
   links: [],       // All link-like entities (including buttons, documents)
-  imgs: [],
+  images: [],
   icons: [],
   videos: [],
   lists: [],
   quotes: [],
-  data: {},        // Structured data (tagged code blocks, forms, cards)
-  headings: [],    // Overflow headings after title/subtitle/subtitle2
+  snippets: [],    // Fenced code — [{ language, code }]
+  data: {},        // Structured data (tagged data blocks, forms, cards)
+  headings: [],    // Headings after subtitle, in document order
   items: [],       // Child content groups (same structure recursively)
 }
 ```
@@ -125,11 +125,9 @@ Editor-specific nodes are mapped to standard entities:
 - `card-group` → `data[cardType]` arrays (e.g., `data.person`, `data.event`)
 - `document-group` → `links[]` with `role: "document"` and `download: true`
 
-See `docs/entity-consolidation.md` for complete mapping documentation.
+### Tagged Data Blocks
 
-### Tagged Code Blocks
-
-Code blocks with tags route parsed data to the `data` object:
+Data blocks with tags route parsed data to the `data` object:
 
 ```markdown
 ```yaml:nav-links
@@ -164,14 +162,14 @@ Lists maintain hierarchy through nested structure. The `processListItems()` func
 
 ## Content Writing Conventions
 
-The parser implements the semantic conventions documented in `docs/guide.md`. Key patterns:
+Key patterns:
 
 - **Pretitle Pattern**: Any heading followed by a more important heading (e.g., H3→H1, H2→H1, H6→H5, etc.)
 - **Banner Pattern**: Image (with banner role or followed by heading) at start of first group
 - **Divider Mode**: Presence of any `horizontalRule` switches entire document to divider-based grouping
 - **Heading Groups**: Consecutive headings with increasing levels are consumed together
 - **Main Content**: First group is main if it's the only group OR has lower heading level than second group
-- **Body Headings**: Headings that overflow the header slots (title, subtitle, subtitle2) are automatically collected in `body.headings`
+- **Body Headings**: Headings after the title and subtitle slots are collected in `body.headings` in document order
 
 ## Testing Structure
 
@@ -187,6 +185,5 @@ Tests are organized by processor:
 
 - The parser never modifies the original ProseMirror document
 - Text content can include inline HTML for formatting (bold → `<strong>`, italic → `<em>`, links → `<a>`)
-- The `processors_old/` directory contains legacy implementations - do not modify
 - Context information in byType includes position, previous/next elements, and nearest heading
 - Group splitting logic differs significantly between heading mode and divider mode

package/README.md

@@ -68,18 +68,17 @@ result = {
   pretitle: "",             // Heading before main title
   title: "Welcome",         // Main heading
   subtitle: "",             // Heading after main title
-  subtitle2: "",            // Third heading level
 
   // Body fields
   paragraphs: ["Get started today."],
   links: [],                // All links (including buttons, documents)
-  imgs: [],
+  images: [],
   videos: [],
   icons: [],
   lists: [],
   quotes: [],
-  data: {},                 // Structured data (tagged code blocks, forms, cards)
-  headings: [],             // Overflow headings after title/subtitle/subtitle2
+  data: {},                 // Structured data (tagged data blocks, forms, cards)
+  headings: [],             // Headings after subtitle, in document order
 
   // Additional content groups (from headings after content)
   items: [
@@ -143,154 +142,6 @@ sequence.forEach(element => {
 });
 ```
 
-## Content Mapping Utilities
-
-The parser includes optional mapping utilities to transform parsed content into component-specific formats. Perfect for visual editors and component-based systems.
-
-### Type System (Recommended)
-
-Automatically transform content based on field types with context-aware behavior:
-
-```js
-const schema = {
-  title: {
-    path: "title",
-    type: "plaintext",  // Auto-strips <strong>, <em>, etc.
-    maxLength: 60       // Auto-truncates intelligently
-  },
-  excerpt: {
-    path: "paragraphs",
-    type: "excerpt",    // Auto-creates excerpt from paragraphs
-    maxLength: 150
-  },
-  image: {
-    path: "imgs[0].url",
-    type: "image",
-    defaultValue: "/placeholder.jpg"
-  }
-};
-
-// Visual editor mode (default) - silent, graceful cleanup
-const data = mappers.extractBySchema(parsed, schema);
-
-// Build mode - validates and warns
-const data = mappers.extractBySchema(parsed, schema, { mode: 'build' });
-```
-
-**Field Types:** `plaintext`, `richtext`, `excerpt`, `number`, `image`, `link`
-
-### Using Pre-Built Extractors
-
-```js
-import { parseContent, mappers } from "@uniweb/semantic-parser";
-
-const parsed = parseContent(doc);
-
-// Extract hero component data
-const heroData = mappers.extractors.hero(parsed);
-// { title, subtitle, kicker, description, image, cta, ... }
-
-// Extract card data
-const cards = mappers.extractors.card(parsed, { useItems: true });
-
-// Extract statistics
-const stats = mappers.extractors.stats(parsed);
-// [{ value: "12", label: "Partner Labs" }, ...]
-
-// Extract navigation menu
-const nav = mappers.extractors.navigation(parsed);
-
-// Extract features list
-const features = mappers.extractors.features(parsed);
-```
-
-### Schema-Based Mapping
-
-Define custom mappings using schemas:
-
-```js
-const schema = {
-  brand: "pretitle",
-  title: "title",
-  subtitle: "subtitle",
-  image: {
-    path: "imgs[0].url",
-    defaultValue: "/placeholder.jpg"
-  },
-  actions: {
-    path: "links",
-    transform: links => links.map(l => ({ label: l.label, type: "primary" }))
-  }
-};
-
-const componentData = mappers.accessor.extractBySchema(parsed, schema);
-```
-
-### Available Extractors
-
-- `hero` - Hero/banner sections
-- `card` - Card components
-- `article` - Article/blog content
-- `stats` - Statistics/metrics
-- `navigation` - Navigation menus
-- `features` - Feature lists
-- `testimonial` - Testimonials
-- `faq` - FAQ sections
-- `pricing` - Pricing tiers
-- `team` - Team members
-- `gallery` - Image galleries
-
-See **[Mapping Patterns Guide](./docs/mapping-patterns.md)** for complete documentation.
-
-## Rendering Content
-
-After extracting content, render it using a Text component that handles paragraph arrays, rich HTML, and formatting marks.
-
-### Text Component Pattern
-
-```jsx
-import { parseContent, mappers } from '@uniweb/semantic-parser';
-import { H1, P } from './components/Text';
-
-const parsed = parseContent(doc);
-const hero = mappers.extractors.hero(parsed);
-
-// Render extracted content
-<>
-  <H1 text={hero.title} />
-  <P text={hero.description} />  {/* Handles arrays automatically */}
-</>
-```
-
-The Text component:
-- **Handles arrays** - Renders `["Para 1", "Para 2"]` as separate paragraphs
-- **Supports rich HTML** - Preserves formatting marks
-- **Multi-line headings** - Wraps multiple lines in semantic heading tags
-- **Color marks** - Supports `<mark>` and `<span>` for visual emphasis
-
-See **[Text Component Reference](./docs/text-component-reference.md)** for implementation guide.
-
-### Sanitization
-
-Sanitize content at the engine level (during data preparation), not in components:
-
-```javascript
-import { parseContent, mappers } from '@uniweb/semantic-parser';
-
-function prepareData(parsed) {
-  const hero = mappers.extractors.hero(parsed);
-  return {
-    ...hero,
-    title: mappers.types.sanitizeHtml(hero.title, {
-      allowedTags: ['strong', 'em', 'mark', 'span'],
-      allowedAttr: ['class', 'data-variant']
-    })
-  };
-}
-```
-
-The parser provides sanitization utilities but doesn't enforce their use. Your engine decides when to sanitize based on security requirements.
-
 ## Content Grouping
 
 The parser supports two grouping modes:
@@ -346,14 +197,6 @@ Bracketed spans (`[text]{.class}`) are converted to `<span>` elements with their
 
 Spans can have classes, IDs, and custom attributes. They combine with other marks—a span with bold becomes `<strong><span class="...">text</span></strong>`.
 
-## Documentation
-
-- **[Content Writing Guide](./docs/guide.md)**: Learn how to structure content for optimal parsing
-- **[API Reference](./docs/api.md)**: Complete API documentation with all element types
-- **[Mapping Patterns Guide](./docs/mapping-patterns.md)**: Transform content to component-specific formats
-- **[Text Component Reference](./docs/text-component-reference.md)**: Reference implementation for rendering parsed content
-- **[File Structure](./docs/file-structure.md)**: Codebase organization
-
 ## Use Cases
 
 - **Component-based websites**: Extract structured data for React/Vue components

package/package.json

@@ -1,13 +1,11 @@
 {
   "name": "@uniweb/semantic-parser",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "description": "Semantic parser for ProseMirror/TipTap content structures",
   "type": "module",
   "main": "./src/index.js",
   "exports": {
-    ".": "./src/index.js",
-    "./mappers": "./src/mappers/index.js",
-    "./mappers/*": "./src/mappers/*.js"
+    ".": "./src/index.js"
   },
   "keywords": [
     "prosemirror",
@@ -30,7 +28,6 @@
   },
   "homepage": "https://github.com/uniweb/semantic-parser#readme",
   "directories": {
-    "doc": "docs",
     "test": "tests"
   },
   "dependencies": {

package/src/index.js

@@ -1,6 +1,5 @@
 import { processSequence } from "./processors/sequence.js";
 import { processGroups } from "./processors/groups.js";
-import * as mappers from "./mappers/index.js";
 
 /**
  * Parse ProseMirror/TipTap content into semantic structure
@@ -30,4 +29,4 @@ function parseContent(doc, options = {}) {
     };
 }
 
-export { parseContent, mappers };
+export { parseContent };

package/src/processors/groups.js

@@ -9,14 +9,14 @@ function flattenGroup(group) {
         title: group.header.title || '',
         pretitle: group.header.pretitle || '',
         subtitle: group.header.subtitle || '',
-        subtitle2: group.header.subtitle2 || '',
         paragraphs: group.body.paragraphs || [],
         links: group.body.links || [],
-        imgs: group.body.imgs || [],
+        images: group.body.images || [],
         icons: group.body.icons || [],
         lists: group.body.lists || [],
         videos: group.body.videos || [],
         insets: group.body.insets || [],
+        snippets: group.body.snippets || [],
         data: group.body.data || {},
         quotes: group.body.quotes || [],
         headings: group.body.headings || [],
@@ -36,14 +36,14 @@ function processGroups(sequence, options = {}) {
             title: '',
             pretitle: '',
             subtitle: '',
-            subtitle2: '',
             paragraphs: [],
             links: [],
-            imgs: [],
+            images: [],
             icons: [],
             lists: [],
             videos: [],
             insets: [],
+            snippets: [],
             data: {},
             quotes: [],
             headings: [],
@@ -73,10 +73,9 @@ function processGroups(sequence, options = {}) {
         title: '',
         pretitle: '',
         subtitle: '',
-        subtitle2: '',
         paragraphs: [],
         links: [],
-        imgs: [],
+        images: [],
         icons: [],
         lists: [],
         videos: [],
@@ -225,14 +224,14 @@ function processGroupContent(elements) {
         pretitle: "",
         title: "",
         subtitle: "",
-        subtitle2: "",
     };
 
     const body = {
-        imgs: [],
+        images: [],
         icons: [],
         videos: [],
         insets: [],
+        snippets: [],
         paragraphs: [],
         links: [],
         lists: [],
@@ -287,11 +286,8 @@ function processGroupContent(elements) {
             } else if (!header.subtitle) {
                 header.subtitle = element.text;
                 lastSlot = 'subtitle';
-            } else if (!header.subtitle2) {
-                header.subtitle2 = element.text;
-                lastSlot = 'subtitle2';
             } else {
-                // After subtitle2, we're in body - collect heading
+                // After subtitle, remaining headings go to body
                 body.headings.push(element.text);
                 lastSlot = null;
             }
@@ -320,7 +316,7 @@ function processGroupContent(elements) {
                     if (element.attrs?.role === "icon") {
                         body.icons.push(element.attrs);
                     } else {
-                        body.imgs.push(preserveProps);
+                        body.images.push(preserveProps);
                     }
                     break;
 
@@ -366,11 +362,16 @@ function processGroupContent(elements) {
                     break;
 
                 case "codeBlock":
-                    // Fallback: tagged code blocks where parsing failed at build time
-                    // Untagged blocks stay in sequence for display
                     const tag = element.attrs?.tag;
                     if (tag) {
+                        // Tagged block where parsing failed at build time — store as data
                         body.data[tag] = element.text;
+                    } else {
+                        // Untagged code block — collect as a snippet
+                        body.snippets.push({
+                            language: element.attrs?.language || '',
+                            code: typeof element.text === 'string' ? element.text : '',
+                        });
                     }
                     break;