@uniweb/build 0.10.1 → 0.10.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.10.1",
+  "version": "0.10.3",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -57,9 +57,9 @@
     "@uniweb/theming": "0.1.3"
   },
   "optionalDependencies": {
-    "@uniweb/runtime": "0.8.1",
-    "@uniweb/schemas": "0.2.1",
-    "@uniweb/content-reader": "1.1.4"
+    "@uniweb/runtime": "0.8.3",
+    "@uniweb/content-reader": "1.1.4",
+    "@uniweb/schemas": "0.2.1"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0",
@@ -68,7 +68,7 @@
     "@tailwindcss/vite": "^4.0.0",
     "@vitejs/plugin-react": "^4.0.0 || ^5.0.0",
     "vite-plugin-svgr": "^4.0.0",
-    "@uniweb/core": "0.7.0"
+    "@uniweb/core": "0.7.2"
   },
   "peerDependenciesMeta": {
     "vite": {

package/src/runtime-schema.js

@@ -27,6 +27,8 @@
  * for the visual editor.
  */
 
+import { isRichSchema } from '@uniweb/core'
+
 /**
  * Parse data string into structured object
  * 'events' -> { type: 'events', limit: null }
@@ -119,7 +121,10 @@ function extractSchemaFields(schemaFields) {
 
 /**
  * Check if a schema value is in the full @uniweb/schemas format
- * Full format has: { name, version?, description?, fields: {...} }
+ * Full format has: { name, version?, description?, fields: { fieldName: fieldDef, ... } }
+ *
+ * The distinguishing feature is that `fields` is a *keyed object*, not an array.
+ * (A rich form schema also has `fields`, but as an array.)
  *
  * @param {Object} schema - Schema value to check
  * @returns {boolean}
@@ -129,10 +134,52 @@ function isFullSchemaFormat(schema) {
     schema &&
     typeof schema === 'object' &&
     typeof schema.fields === 'object' &&
-    schema.fields !== null
+    schema.fields !== null &&
+    !Array.isArray(schema.fields)
   )
 }
 
+/**
+ * Pass a rich form schema through with minimal normalization.
+ *
+ * Rich schemas are passed to the editor (for FormBlock UI rendering) and to
+ * the runtime (for default application). We keep all authored metadata so the
+ * editor has what it needs; we do not strip editor-only fields here because
+ * the same schema feeds both audiences.
+ *
+ * Normalizations:
+ *   - `type: 'string'` → `type: 'text'` (legacy alias; warn in dev)
+ *
+ * @param {Object} schema - Rich schema as authored
+ * @returns {Object} - Normalized rich schema
+ */
+function normalizeRichSchema(schema) {
+  return normalizeRichSchemaValue(schema)
+}
+
+function normalizeRichSchemaValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(normalizeRichSchemaValue)
+  }
+  if (!value || typeof value !== 'object') return value
+  const out = {}
+  for (const [key, v] of Object.entries(value)) {
+    if (key === 'type' && v === 'string') {
+      if (typeof process !== 'undefined' && process.env?.NODE_ENV !== 'production') {
+        console.warn(
+          "[uniweb] form schema field type 'string' is a legacy alias; use 'text' instead."
+        )
+      }
+      out[key] = 'text'
+    } else if (v && typeof v === 'object') {
+      out[key] = normalizeRichSchemaValue(v)
+    } else {
+      out[key] = v
+    }
+  }
+  return out
+}
+
 /**
  * Extract lean schemas from meta.js schemas object
  * Strips editor-only fields while preserving structure
@@ -151,6 +198,13 @@ function extractSchemas(schemas) {
 
   const lean = {}
   for (const [schemaName, schemaValue] of Object.entries(schemas)) {
+    // Rich form schemas: pass through (with normalization). They drive both
+    // the FormBlock editor UI and the runtime default application.
+    if (isRichSchema(schemaValue)) {
+      lean[schemaName] = normalizeRichSchema(schemaValue)
+      continue
+    }
+
     // Handle full schema format (from @uniweb/schemas or npm packages)
     // Extract just the fields, discard name/version/description metadata
     const schemaFields = isFullSchemaFormat(schemaValue)
@@ -166,6 +220,7 @@ function extractSchemas(schemas) {
   return Object.keys(lean).length > 0 ? lean : null
 }
 
+
 /**
  * Extract param defaults from params object
  *

package/src/site/collection-processor.js

@@ -103,6 +103,15 @@ function parseCollectionConfig(name, config) {
     // automatically on dynamic-route pages (entity-store routes the
     // singular detail there) or via the kit's useEntityDetail hook.
     deferred: Array.isArray(config.deferred) ? config.deferred.slice() : null,
+    // `detailUrl:` names the per-record endpoint pattern for API-backed
+    // collections (where the build emits no per-record files because
+    // there are no on-disk source files to materialize). Used by the
+    // runtime's auto-detail injection and the useEntityDetail kit hook.
+    // Pattern uses {slug} as the placeholder; substitution at runtime
+    // pulls from the dynamic-route param (entity-store) or the record's
+    // slug field (useEntityDetail). Markdown-backed collections leave
+    // this null and get the static-file default /data/<name>/<slug>.json.
+    detailUrl: typeof config.detailUrl === 'string' ? config.detailUrl : null,
     // `queryable:` declares the queryable surface — which fields a
     // foundation can offer for filtering UI, with their type and
     // type-specific metadata (enum options, range bounds). Foundations