@elytracms/studio 0.0.17 → 0.0.18

package/dist/router/match.d.ts

@@ -11,33 +11,33 @@
  * convention without needing a router instance.
  *
  * EC-239 (app-view modularization): the route table is no longer a hardcoded
- * per-section switch — the studio's surfaces are a config-extendable module
- * registry, so the matcher is now registry-AGNOSTIC. It splits the splat into a
- * module id (the first segment) + that module's trailing segments; the screen
- * resolver looks the id up in the registry and the module's own `parsePath`
+ * per-section switch — the studio's surfaces are a config-extendable VIEW registry
+ * derived from the section rail, so the matcher is registry-AGNOSTIC. It splits the
+ * splat into a view id (the first segment) + that view's trailing segments; the
+ * screen resolver looks the id up in the registry and the view's own `parsePath`
  * interprets the segments (CMS: collection/document; components: id; flat: none).
- * Keeping the matcher free of the surface list is what lets a consuming repo add
- * a routable custom module purely from config.
+ * Keeping the matcher free of the surface list is what lets a consuming repo add a
+ * routable custom view purely from config.
  *
- *   /$projectId                      → { section: 'index' }                 (redirect to first module)
- *   /$projectId/<id>                 → { section: 'module', moduleId: '<id>', segments: [] }
- *   /$projectId/<id>/a/b             → { section: 'module', moduleId: '<id>', segments: ['a','b'] }
+ *   /$projectId                      → { section: 'index' }              (redirect to first view)
+ *   /$projectId/<id>                 → { section: 'view', viewId: '<id>', segments: [] }
+ *   /$projectId/<id>/a/b             → { section: 'view', viewId: '<id>', segments: ['a','b'] }
  *
- * The module decides whether its segments resolve; an unknown id or an
- * over-deep path becomes a not-found at the resolver, not here.
+ * The view decides whether its segments resolve; an unknown id or an over-deep
+ * path becomes a not-found at the resolver, not here.
  */
 export type StudioRouteMatch = {
     section: 'index';
 } | {
-    section: 'module';
-    moduleId: string;
+    section: 'view';
+    viewId: string;
     segments: string[];
 };
 /**
- * Match the trailing pathname of the project splat (`_splat`) into a module id +
+ * Match the trailing pathname of the project splat (`_splat`) into a view id +
  * its segments. `splat` is everything after `/$projectId/` — e.g. `'cms/page/abc'`
- * for `/p1/cms/page/abc` → `{ moduleId: 'cms', segments: ['page', 'abc'] }`. An
- * empty splat is the bare project index (which redirects to the first module).
+ * for `/p1/cms/page/abc` → `{ viewId: 'cms', segments: ['page', 'abc'] }`. An
+ * empty splat is the bare project index (which redirects to the first view).
  */
 export declare function matchStudioRoute(splat: string): StudioRouteMatch;
 /**

package/dist/router/match.js

@@ -11,20 +11,20 @@
  * convention without needing a router instance.
  *
  * EC-239 (app-view modularization): the route table is no longer a hardcoded
- * per-section switch — the studio's surfaces are a config-extendable module
- * registry, so the matcher is now registry-AGNOSTIC. It splits the splat into a
- * module id (the first segment) + that module's trailing segments; the screen
- * resolver looks the id up in the registry and the module's own `parsePath`
+ * per-section switch — the studio's surfaces are a config-extendable VIEW registry
+ * derived from the section rail, so the matcher is registry-AGNOSTIC. It splits the
+ * splat into a view id (the first segment) + that view's trailing segments; the
+ * screen resolver looks the id up in the registry and the view's own `parsePath`
  * interprets the segments (CMS: collection/document; components: id; flat: none).
- * Keeping the matcher free of the surface list is what lets a consuming repo add
- * a routable custom module purely from config.
+ * Keeping the matcher free of the surface list is what lets a consuming repo add a
+ * routable custom view purely from config.
  *
- *   /$projectId                      → { section: 'index' }                 (redirect to first module)
- *   /$projectId/<id>                 → { section: 'module', moduleId: '<id>', segments: [] }
- *   /$projectId/<id>/a/b             → { section: 'module', moduleId: '<id>', segments: ['a','b'] }
+ *   /$projectId                      → { section: 'index' }              (redirect to first view)
+ *   /$projectId/<id>                 → { section: 'view', viewId: '<id>', segments: [] }
+ *   /$projectId/<id>/a/b             → { section: 'view', viewId: '<id>', segments: ['a','b'] }
  *
- * The module decides whether its segments resolve; an unknown id or an
- * over-deep path becomes a not-found at the resolver, not here.
+ * The view decides whether its segments resolve; an unknown id or an over-deep
+ * path becomes a not-found at the resolver, not here.
  */
 /** Split a splat pathname into clean segments (drops empty/leading/trailing slashes). */
 function segments(splat) {
@@ -34,16 +34,16 @@ function segments(splat) {
         .filter(Boolean);
 }
 /**
- * Match the trailing pathname of the project splat (`_splat`) into a module id +
+ * Match the trailing pathname of the project splat (`_splat`) into a view id +
  * its segments. `splat` is everything after `/$projectId/` — e.g. `'cms/page/abc'`
- * for `/p1/cms/page/abc` → `{ moduleId: 'cms', segments: ['page', 'abc'] }`. An
- * empty splat is the bare project index (which redirects to the first module).
+ * for `/p1/cms/page/abc` → `{ viewId: 'cms', segments: ['page', 'abc'] }`. An
+ * empty splat is the bare project index (which redirects to the first view).
  */
 export function matchStudioRoute(splat) {
-    const [moduleId, ...rest] = segments(splat);
-    if (moduleId === undefined)
+    const [viewId, ...rest] = segments(splat);
+    if (viewId === undefined)
         return { section: 'index' };
-    return { section: 'module', moduleId, segments: rest };
+    return { section: 'view', viewId, segments: rest };
 }
 /**
  * The inverse of {@link matchStudioRoute}: build the `_splat` subpath for a

package/dist/router/match.js.map

@@ -1 +1 @@
-{"version":3,"file":"match.js","sourceRoot":"","sources":["../../src/router/match.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAMH,yFAAyF;AACzF,SAAS,QAAQ,CAAC,KAAa;IAC7B,OAAO,KAAK;SACT,KAAK,CAAC,GAAG,CAAC;SACV,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;SAChC,MAAM,CAAC,OAAO,CAAC,CAAA;AACpB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAa;IAC5C,MAAM,CAAC,QAAQ,EAAE,GAAG,IAAI,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAA;IAC3C,IAAI,QAAQ,KAAK,SAAS;QAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,CAAA;IACvD,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAA;AACxD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,KAAK,EAAE,GAAG,EAAE,CAAC,EAAE;IACf,QAAQ,EAAE,GAAG,EAAE,CAAC,UAAU;IAC1B,MAAM,EAAE,GAAG,EAAE,CAAC,QAAQ;IACtB,MAAM,EAAE,GAAG,EAAE,CAAC,QAAQ;IACtB,UAAU,EAAE,GAAG,EAAE,CAAC,YAAY;IAC9B,OAAO,EAAE,GAAG,EAAE,CAAC,SAAS;IACxB,UAAU,EAAE,GAAG,EAAE,CAAC,YAAY;IAC9B,SAAS,EAAE,CAAC,WAAmB,EAAE,EAAE,CAAC,cAAc,WAAW,EAAE;IAC/D,GAAG,EAAE,GAAG,EAAE,CAAC,KAAK;IAChB,aAAa,EAAE,CAAC,YAAoB,EAAE,EAAE,CAAC,OAAO,YAAY,EAAE;IAC9D,WAAW,EAAE,CAAC,YAAoB,EAAE,UAAkB,EAAE,EAAE,CACxD,OAAO,YAAY,IAAI,UAAU,EAAE;CAC7B,CAAA","sourcesContent":["/**\n * Studio route table (EC-223 Stage 6 — catch-all routing). The studio mounts as\n * a SINGLE splat route per project (`/$projectId/$`); this pure matcher turns the\n * splat's trailing pathname into a typed match that the screen resolver renders.\n * Keeping the URL→screen map inside the engine (instead of in per-consumer route\n * files) is what lets the package own its navigation with a near-empty consumer\n * route tree — the goal of Stage 6.\n *\n * Deterministic and dependency-free: every screen state is reproducible from a\n * pathname string (see `match.test.ts`), satisfying the fixtures-reproducibility\n * convention without needing a router instance.\n *\n * EC-239 (app-view modularization): the route table is no longer a hardcoded\n * per-section switch — the studio's surfaces are a config-extendable module\n * registry, so the matcher is now registry-AGNOSTIC. It splits the splat into a\n * module id (the first segment) + that module's trailing segments; the screen\n * resolver looks the id up in the registry and the module's own `parsePath`\n * interprets the segments (CMS: collection/document; components: id; flat: none).\n * Keeping the matcher free of the surface list is what lets a consuming repo add\n * a routable custom module purely from config.\n *\n *   /$projectId                      → { section: 'index' }                 (redirect to first module)\n *   /$projectId/<id>                 → { section: 'module', moduleId: '<id>', segments: [] }\n *   /$projectId/<id>/a/b             → { section: 'module', moduleId: '<id>', segments: ['a','b'] }\n *\n * The module decides whether its segments resolve; an unknown id or an\n * over-deep path becomes a not-found at the resolver, not here.\n */\n\nexport type StudioRouteMatch =\n  | { section: 'index' }\n  | { section: 'module'; moduleId: string; segments: string[] }\n\n/** Split a splat pathname into clean segments (drops empty/leading/trailing slashes). */\nfunction segments(splat: string): string[] {\n  return splat\n    .split('/')\n    .map((segment) => segment.trim())\n    .filter(Boolean)\n}\n\n/**\n * Match the trailing pathname of the project splat (`_splat`) into a module id +\n * its segments. `splat` is everything after `/$projectId/` — e.g. `'cms/page/abc'`\n * for `/p1/cms/page/abc` → `{ moduleId: 'cms', segments: ['page', 'abc'] }`. An\n * empty splat is the bare project index (which redirects to the first module).\n */\nexport function matchStudioRoute(splat: string): StudioRouteMatch {\n  const [moduleId, ...rest] = segments(splat)\n  if (moduleId === undefined) return { section: 'index' }\n  return { section: 'module', moduleId, segments: rest }\n}\n\n/**\n * The inverse of {@link matchStudioRoute}: build the `_splat` subpath for a\n * screen. Navigation addresses the single project splat as\n * `to={STUDIO_PROJECT_ROUTE} params={{ projectId, _splat: studioPath.X(...) }}`,\n * so the URL-construction lives in exactly one place — the same module that\n * parses it back. `matchStudioRoute(studioPath.cmsDocument(c, d))` round-trips\n * (pinned in `match.test.ts`), which is what keeps the two directions in sync.\n */\nexport const studioPath = {\n  index: () => '',\n  settings: () => 'settings',\n  assets: () => 'assets',\n  routes: () => 'routes',\n  extensions: () => 'extensions',\n  builder: () => 'builder',\n  components: () => 'components',\n  component: (componentId: string) => `components/${componentId}`,\n  cms: () => 'cms',\n  cmsCollection: (collectionId: string) => `cms/${collectionId}`,\n  cmsDocument: (collectionId: string, documentId: string) =>\n    `cms/${collectionId}/${documentId}`,\n} as const\n"]}
+{"version":3,"file":"match.js","sourceRoot":"","sources":["../../src/router/match.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAMH,yFAAyF;AACzF,SAAS,QAAQ,CAAC,KAAa;IAC7B,OAAO,KAAK;SACT,KAAK,CAAC,GAAG,CAAC;SACV,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;SAChC,MAAM,CAAC,OAAO,CAAC,CAAA;AACpB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAa;IAC5C,MAAM,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAA;IACzC,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,CAAA;IACrD,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAA;AACpD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,KAAK,EAAE,GAAG,EAAE,CAAC,EAAE;IACf,QAAQ,EAAE,GAAG,EAAE,CAAC,UAAU;IAC1B,MAAM,EAAE,GAAG,EAAE,CAAC,QAAQ;IACtB,MAAM,EAAE,GAAG,EAAE,CAAC,QAAQ;IACtB,UAAU,EAAE,GAAG,EAAE,CAAC,YAAY;IAC9B,OAAO,EAAE,GAAG,EAAE,CAAC,SAAS;IACxB,UAAU,EAAE,GAAG,EAAE,CAAC,YAAY;IAC9B,SAAS,EAAE,CAAC,WAAmB,EAAE,EAAE,CAAC,cAAc,WAAW,EAAE;IAC/D,GAAG,EAAE,GAAG,EAAE,CAAC,KAAK;IAChB,aAAa,EAAE,CAAC,YAAoB,EAAE,EAAE,CAAC,OAAO,YAAY,EAAE;IAC9D,WAAW,EAAE,CAAC,YAAoB,EAAE,UAAkB,EAAE,EAAE,CACxD,OAAO,YAAY,IAAI,UAAU,EAAE;CAC7B,CAAA","sourcesContent":["/**\n * Studio route table (EC-223 Stage 6 — catch-all routing). The studio mounts as\n * a SINGLE splat route per project (`/$projectId/$`); this pure matcher turns the\n * splat's trailing pathname into a typed match that the screen resolver renders.\n * Keeping the URL→screen map inside the engine (instead of in per-consumer route\n * files) is what lets the package own its navigation with a near-empty consumer\n * route tree — the goal of Stage 6.\n *\n * Deterministic and dependency-free: every screen state is reproducible from a\n * pathname string (see `match.test.ts`), satisfying the fixtures-reproducibility\n * convention without needing a router instance.\n *\n * EC-239 (app-view modularization): the route table is no longer a hardcoded\n * per-section switch — the studio's surfaces are a config-extendable VIEW registry\n * derived from the section rail, so the matcher is registry-AGNOSTIC. It splits the\n * splat into a view id (the first segment) + that view's trailing segments; the\n * screen resolver looks the id up in the registry and the view's own `parsePath`\n * interprets the segments (CMS: collection/document; components: id; flat: none).\n * Keeping the matcher free of the surface list is what lets a consuming repo add a\n * routable custom view purely from config.\n *\n *   /$projectId                      → { section: 'index' }              (redirect to first view)\n *   /$projectId/<id>                 → { section: 'view', viewId: '<id>', segments: [] }\n *   /$projectId/<id>/a/b             → { section: 'view', viewId: '<id>', segments: ['a','b'] }\n *\n * The view decides whether its segments resolve; an unknown id or an over-deep\n * path becomes a not-found at the resolver, not here.\n */\n\nexport type StudioRouteMatch =\n  | { section: 'index' }\n  | { section: 'view'; viewId: string; segments: string[] }\n\n/** Split a splat pathname into clean segments (drops empty/leading/trailing slashes). */\nfunction segments(splat: string): string[] {\n  return splat\n    .split('/')\n    .map((segment) => segment.trim())\n    .filter(Boolean)\n}\n\n/**\n * Match the trailing pathname of the project splat (`_splat`) into a view id +\n * its segments. `splat` is everything after `/$projectId/` — e.g. `'cms/page/abc'`\n * for `/p1/cms/page/abc` → `{ viewId: 'cms', segments: ['page', 'abc'] }`. An\n * empty splat is the bare project index (which redirects to the first view).\n */\nexport function matchStudioRoute(splat: string): StudioRouteMatch {\n  const [viewId, ...rest] = segments(splat)\n  if (viewId === undefined) return { section: 'index' }\n  return { section: 'view', viewId, segments: rest }\n}\n\n/**\n * The inverse of {@link matchStudioRoute}: build the `_splat` subpath for a\n * screen. Navigation addresses the single project splat as\n * `to={STUDIO_PROJECT_ROUTE} params={{ projectId, _splat: studioPath.X(...) }}`,\n * so the URL-construction lives in exactly one place — the same module that\n * parses it back. `matchStudioRoute(studioPath.cmsDocument(c, d))` round-trips\n * (pinned in `match.test.ts`), which is what keeps the two directions in sync.\n */\nexport const studioPath = {\n  index: () => '',\n  settings: () => 'settings',\n  assets: () => 'assets',\n  routes: () => 'routes',\n  extensions: () => 'extensions',\n  builder: () => 'builder',\n  components: () => 'components',\n  component: (componentId: string) => `components/${componentId}`,\n  cms: () => 'cms',\n  cmsCollection: (collectionId: string) => `cms/${collectionId}`,\n  cmsDocument: (collectionId: string, documentId: string) =>\n    `cms/${collectionId}/${documentId}`,\n} as const\n"]}

package/dist/ui/badge.d.ts

@@ -1,7 +1,7 @@
 import { type VariantProps } from 'class-variance-authority';
 import type { HTMLAttributes } from 'react';
 export declare const badgeVariants: (props?: ({
-    variant?: "error" | "warning" | "default" | "success" | "primary" | "outline" | "info" | null | undefined;
+    variant?: "error" | "default" | "primary" | "outline" | "success" | "warning" | "info" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export interface BadgeProps extends HTMLAttributes<HTMLSpanElement>, VariantProps<typeof badgeVariants> {
 }

package/package.json

@@ -1,13 +1,17 @@
 {
   "name": "@elytracms/studio",
   "author": "finaldream <hi@finaldream.de>",
-  "version": "0.0.17",
+  "version": "0.0.18",
   "private": false,
   "description": "The Elytra studio engine (UI + lib + routes + data-only Convex schema) as an importable package. Extraction staged in EXTRACTION.md (EC-223); Stages 1-2 = UI primitives + router-free lib leaves.",
   "license": "MIT",
   "type": "module",
   "exports": {
     "./styles.css": "./src/styles/studio.css",
+    "./customization": {
+      "types": "./dist/customization.d.ts",
+      "default": "./dist/customization.js"
+    },
     "./ui": {
       "types": "./dist/ui/index.d.ts",
       "default": "./dist/ui/index.js"
@@ -113,7 +117,7 @@
     "lucide-react": "^1.17.0",
     "tailwind-merge": "^3.6.0",
     "zod": "^4.0.0",
-    "@elytracms/core": "^0.0.17"
+    "@elytracms/core": "^0.0.18"
   },
   "peerDependencies": {
     "@tanstack/react-router": "^1.170.0",