@pilotiq/pilotiq 0.24.1 → 0.24.2

package/src/react/parseRecordEditUrl.test.ts

@@ -1,122 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { parseRecordEditUrl, parseRecordPageUrl } from './parseRecordEditUrl.js'
-
-test('parseRecordEditUrl: bare resource edit', () => {
-  assert.deepEqual(
-    parseRecordEditUrl('/admin/articles/123/edit', '/admin'),
-    { resourceSlug: 'articles', recordId: '123' },
-  )
-})
-
-test('parseRecordEditUrl: cluster-prefixed resource edit', () => {
-  assert.deepEqual(
-    parseRecordEditUrl('/admin/blog/articles/123/edit', '/admin'),
-    { resourceSlug: 'blog/articles', recordId: '123' },
-  )
-})
-
-test('parseRecordEditUrl: nested-relation edit picks child id', () => {
-  assert.deepEqual(
-    parseRecordEditUrl('/admin/articles/123/comments/456/edit', '/admin'),
-    { resourceSlug: 'articles/123/comments', recordId: '456' },
-  )
-})
-
-test('parseRecordEditUrl: list page returns null', () => {
-  assert.equal(parseRecordEditUrl('/admin/articles', '/admin'), null)
-  assert.equal(parseRecordEditUrl('/admin/articles/123', '/admin'), null)
-})
-
-test('parseRecordEditUrl: create page returns null', () => {
-  assert.equal(parseRecordEditUrl('/admin/articles/create', '/admin'), null)
-  assert.equal(parseRecordEditUrl('/admin/articles/123/comments/create', '/admin'), null)
-})
-
-test('parseRecordEditUrl: basePath mismatch returns null', () => {
-  assert.equal(parseRecordEditUrl('/site/articles/123/edit', '/admin'), null)
-})
-
-test('parseRecordEditUrl: trailing slashes tolerated on URL', () => {
-  assert.deepEqual(
-    parseRecordEditUrl('/admin/articles/123/edit/', '/admin'),
-    { resourceSlug: 'articles', recordId: '123' },
-  )
-})
-
-test('parseRecordEditUrl: trailing slashes tolerated on basePath', () => {
-  assert.deepEqual(
-    parseRecordEditUrl('/admin/articles/123/edit', '/admin/'),
-    { resourceSlug: 'articles', recordId: '123' },
-  )
-})
-
-test('parseRecordEditUrl: root basePath', () => {
-  assert.deepEqual(
-    parseRecordEditUrl('/articles/123/edit', ''),
-    { resourceSlug: 'articles', recordId: '123' },
-  )
-})
-
-test('parseRecordEditUrl: empty path returns null', () => {
-  assert.equal(parseRecordEditUrl('', '/admin'), null)
-})
-
-test('parseRecordEditUrl: too-short path returns null', () => {
-  assert.equal(parseRecordEditUrl('/admin/edit', '/admin'), null)
-  // 'edit' alone after basePath isn't enough — needs slug + id + 'edit'.
-})
-
-test('parseRecordEditUrl: slug-only edit (no record id) returns null', () => {
-  // '/admin/123/edit' would technically match parts.length===3 with
-  // 'edit' last and '123' as recordId — but with empty slug after the
-  // slice. Defensive: reject when slugParts is empty.
-  assert.equal(parseRecordEditUrl('/admin/edit', '/admin'), null)
-})
-
-// ─── parseRecordPageUrl (role-aware) ─────────────────────────
-
-test('parseRecordPageUrl: edit URL returns role=edit', () => {
-  assert.deepEqual(
-    parseRecordPageUrl('/admin/articles/123/edit', '/admin'),
-    { resourceSlug: 'articles', recordId: '123', role: 'edit' },
-  )
-})
-
-test('parseRecordPageUrl: view URL returns role=view', () => {
-  assert.deepEqual(
-    parseRecordPageUrl('/admin/articles/123/view', '/admin'),
-    { resourceSlug: 'articles', recordId: '123', role: 'view' },
-  )
-})
-
-test('parseRecordPageUrl: cluster-prefixed view URL', () => {
-  assert.deepEqual(
-    parseRecordPageUrl('/admin/blog/articles/123/view', '/admin'),
-    { resourceSlug: 'blog/articles', recordId: '123', role: 'view' },
-  )
-})
-
-test('parseRecordPageUrl: terminal token other than edit|view returns null', () => {
-  // 'delete' / 'restore' / 'force-delete' are POST handlers, not pages.
-  assert.equal(parseRecordPageUrl('/admin/articles/123/delete', '/admin'), null)
-  assert.equal(parseRecordPageUrl('/admin/articles/123/restore', '/admin'), null)
-  // Custom record sub-pages also fall through here — they have their own
-  // gate path (not record-bound for collab purposes in v1).
-  assert.equal(parseRecordPageUrl('/admin/articles/123/history', '/admin'), null)
-})
-
-test('parseRecordPageUrl: view URL in nested-relation form', () => {
-  assert.deepEqual(
-    parseRecordPageUrl('/admin/articles/123/comments/456/view', '/admin'),
-    { resourceSlug: 'articles/123/comments', recordId: '456', role: 'view' },
-  )
-})
-
-// ─── Legacy alias: parseRecordEditUrl filters view URLs ──────
-
-test('parseRecordEditUrl: view URL returns null (back-compat: edit-only)', () => {
-  // A consumer still calling the legacy `parseRecordEditUrl` should
-  // continue to see view URLs filtered out — only edit URLs round-trip.
-  assert.equal(parseRecordEditUrl('/admin/articles/123/view', '/admin'), null)
-})

package/src/react/parseRecordEditUrl.ts

@@ -1,94 +0,0 @@
-/**
- * URL → record-page identity parser. Used by `RecordWrapperGate` (and any
- * plugin that wants to reason about record-bound URLs) to decide whether
- * the current page is a record-edit or record-view route.
- *
- * A URL matches when:
- *   1. it starts with the panel's `basePath`
- *   2. after stripping the prefix it ends with `/edit` or `/view`
- *   3. there are at least three remaining segments (resource slug,
- *      record id, terminal token)
- *
- * The `resourceSlug` is the slash-joined chain of every segment up to
- * the record id — this gives clustered resources (`${base}/blog/articles/123/edit`)
- * and nested-relation edits (`${base}/articles/123/comments/456/edit`)
- * distinct slugs so two URLs that target different records always
- * produce different room names downstream.
- *
- *   `/admin/articles/123/edit`                      → { slug: 'articles',              id: '123', role: 'edit' }
- *   `/admin/articles/123/view`                      → { slug: 'articles',              id: '123', role: 'view' }
- *   `/admin/blog/articles/123/edit`                 → { slug: 'blog/articles',         id: '123', role: 'edit' }
- *   `/admin/articles/123/comments/456/edit`         → { slug: 'articles/123/comments', id: '456', role: 'edit' }
- *   `/admin/articles/123/comments`                  → null  (no trailing /edit or /view)
- *   `/admin/articles/123/comments/create`           → null  (terminal token isn't edit|view)
- *   `/site/articles/123/edit`                       → null  (basePath mismatch when basePath='/admin')
- */
-
-/** Page roles `parseRecordPageUrl` recognizes. `'edit'` and `'view'`
- * are the two record-scoped page roles where collab and other
- * record-bound plugins want to mount their per-record wrapper. */
-export type RecordPageRole = 'edit' | 'view'
-
-export interface RecordPageIdentity {
-  resourceSlug: string
-  recordId:     string
-  /** Which terminal URL segment matched — `'edit'` for the writable edit
-   * page, `'view'` for the read-only view page. Lets the gate decide per
-   * resource whether collab activates on this role (defaults to `'edit'`
-   * only; resources opt into `'view'` for presence-only experiences). */
-  role:         RecordPageRole
-}
-
-const RECOGNIZED_ROLES: ReadonlyArray<RecordPageRole> = ['edit', 'view']
-
-/**
- * Parse a pilotiq URL into a `{ slug, id, role }` identity. Returns
- * `null` for any URL that isn't a record-edit or record-view page.
- */
-export function parseRecordPageUrl(
-  currentPath: string,
-  basePath:    string,
-): RecordPageIdentity | null {
-  if (!currentPath) return null
-  // Normalise — trailing slashes on the URL or trailing slashes on
-  // basePath would otherwise reject perfectly valid matches.
-  const trimmedPath = currentPath.replace(/\/+$/, '')
-  const trimmedBase = basePath.replace(/\/+$/, '')
-
-  if (trimmedBase !== '' && !trimmedPath.startsWith(trimmedBase)) return null
-
-  const tail = trimmedPath.slice(trimmedBase.length).replace(/^\/+/, '')
-  const parts = tail.split('/').filter(Boolean)
-
-  if (parts.length < 3) return null
-  const terminal = parts[parts.length - 1]!
-  if (!RECOGNIZED_ROLES.includes(terminal as RecordPageRole)) return null
-
-  const recordId    = parts[parts.length - 2]!
-  const slugParts   = parts.slice(0, parts.length - 2)
-  if (slugParts.length === 0) return null
-
-  return {
-    resourceSlug: slugParts.join('/'),
-    recordId,
-    role:         terminal as RecordPageRole,
-  }
-}
-
-/** Legacy alias: parse a URL into an edit-only identity. Returns `null`
- * for view URLs (and any non-edit URL). Kept for back-compat with the
- * pre-`parseRecordPageUrl` public API; new code should call
- * `parseRecordPageUrl` and branch on `role`. */
-export interface RecordEditIdentity {
-  resourceSlug: string
-  recordId:     string
-}
-
-export function parseRecordEditUrl(
-  currentPath: string,
-  basePath:    string,
-): RecordEditIdentity | null {
-  const identity = parseRecordPageUrl(currentPath, basePath)
-  if (!identity || identity.role !== 'edit') return null
-  return { resourceSlug: identity.resourceSlug, recordId: identity.recordId }
-}

package/src/react/persistedState.ts

@@ -1,40 +0,0 @@
-/**
- * Thin localStorage wrappers shared by every persistable surface
- * (collapsible sections, dismissible alerts, wizard step, hidden table
- * columns, group fold state, filter strip toggle, Repeater / Builder
- * row collapse + accordion).
- *
- * Every helper silently no-ops on SSR / private mode / quota — callers
- * already treat all three the same way.
- */
-
-export function readStoredString(key: string): string | null {
-  if (typeof window === 'undefined') return null
-  try { return window.localStorage.getItem(key) }
-  catch { return null }
-}
-
-export function writeStoredString(key: string, value: string): void {
-  if (typeof window === 'undefined') return
-  try { window.localStorage.setItem(key, value) } catch { /* quota / blocked */ }
-}
-
-export function removeStoredString(key: string): void {
-  if (typeof window === 'undefined') return
-  try { window.localStorage.removeItem(key) } catch { /* */ }
-}
-
-/**
- * Boolean flag using `'1'` / `'0'` encoding. Returns `defaultValue`
- * when the key is unset, SSR, or storage is blocked.
- */
-export function readStoredFlag(key: string, defaultValue: boolean): boolean {
-  const raw = readStoredString(key)
-  if (raw === '1') return true
-  if (raw === '0') return false
-  return defaultValue
-}
-
-export function writeStoredFlag(key: string, value: boolean): void {
-  writeStoredString(key, value ? '1' : '0')
-}

package/src/react/registry.ts

@@ -1,48 +0,0 @@
-import type { ComponentType } from 'react'
-import type { ElementMeta } from '../schema/Element.js'
-
-/**
- * Props every registered field renderer receives. The renderer owns how it
- * wires the input value into form POST — typically via a hidden `<input>`.
- *
- * Kept narrow on purpose: the renderer reads everything else (rules, options,
- * etc.) off `el` directly. Adding more discrete props here forces every
- * registered renderer to accept them whether it cares or not.
- */
-export interface FieldRendererProps {
-  el:            ElementMeta
-  name:          string
-  defaultValue:  unknown
-  required:      boolean
-  disabled:      boolean
-  placeholder:   string | undefined
-}
-
-const renderers = new Map<string, ComponentType<FieldRendererProps>>()
-
-/**
- * Register a custom React component to render a `fieldType`. Used by external
- * packages (e.g. `@pilotiq/tiptap`) to plug in input UIs without forcing
- * pilotiq core to import their dependencies.
- *
- * Built-in field types (`text`, `textarea`, `select`, `toggle`, `date`, …)
- * are handled by SchemaRenderer's internal switch and don't need to register.
- * Calling `registerFieldRenderer` for a built-in fieldType wins — the registry
- * is checked first.
- *
- * Call once at app boot (client-side). Re-calling with the same fieldType
- * overwrites the previous registration, which is convenient for HMR.
- */
-export function registerFieldRenderer(
-  fieldType: string,
-  Component: ComponentType<FieldRendererProps>,
-): void {
-  renderers.set(fieldType, Component)
-}
-
-/** Look up a registered renderer. Returns undefined for unregistered types. */
-export function getFieldRenderer(
-  fieldType: string,
-): ComponentType<FieldRendererProps> | undefined {
-  return renderers.get(fieldType)
-}

package/src/react/right-panel-registry.tsx

@@ -1,47 +0,0 @@
-import React, { createContext, useContext, type ComponentType } from 'react'
-import type { RightPanelProps } from '../RightPanel.js'
-
-/**
- * Build-time right-panel manifest. Maps each registered contribution's
- * `id` (e.g. `'ai.chat'`) to the React component the user passed as
- * `render`. The Pilotiq Vite plugin emits this map by walking every
- * panel's `cfg.rightPanels` and stamping `_rightPanels[c.id] = c.render`
- * into `pages/(pilotiq)/_components.ts`.
- *
- * The body component never crosses the wire — only its tab-strip meta
- * does (`RightPanelMeta`). The chrome (Phase C) calls
- * `getRightPanelComponent(id)` to resolve a `RightPanelMeta.id` into
- * the actual component at mount time.
- *
- * Sparse: when a panel has no contributions, the registry is `{}` and
- * the chrome never mounts (server-side `RightSidebarMeta` is also
- * absent in that case — defense in depth).
- */
-export type RightPanelRegistry = Record<string, ComponentType<RightPanelProps>>
-
-const Ctx = createContext<RightPanelRegistry | undefined>(undefined)
-
-export function RightPanelRegistryProvider({
-  value,
-  children,
-}: {
-  value: RightPanelRegistry | undefined
-  children: React.ReactNode
-}) {
-  return <Ctx.Provider value={value}>{children}</Ctx.Provider>
-}
-
-/** Read the full registry (for chrome that wants to enumerate). */
-export function useRightPanelRegistry(): RightPanelRegistry | undefined {
-  return useContext(Ctx)
-}
-
-/**
- * Look up a single registered body component by `id`. Returns
- * `undefined` when the registry is missing or the id was never
- * registered — the caller paints its own missing-component fallback.
- */
-export function useRightPanelComponent(id: string): ComponentType<RightPanelProps> | undefined {
-  const registry = useContext(Ctx)
-  return registry?.[id]
-}

package/src/react/schemaRenderer/AlertRenderer.tsx

@@ -1,112 +0,0 @@
-import React, { useEffect, useState } from 'react'
-import type { ComponentType } from 'react'
-import {
-  CircleAlertIcon,
-  CircleCheckIcon,
-  InfoIcon,
-  TriangleAlertIcon,
-  XIcon,
-} from 'lucide-react'
-import { readStoredString, writeStoredString } from '../persistedState.js'
-import { alertStyles, TEXT_COLOR_CLASSES } from './constants.js'
-
-// ─── Alert renderer ─────────────────────────────────────────
-//
-// Owns dismissal state (per-mount + optional localStorage persistence)
-// + icon dispatch + footer-actions alignment. Lifted out of the inline
-// `case 'alert'` branch when Alert gained `dismissible() / iconColor() /
-// footerActionsAlignment()` setters — those need component-local state
-// (the dismiss button, the persisted-dismissal hydration on mount), and
-// inlining the hooks under a switch arm is fragile.
-
-const ALERT_TYPE_ICONS: Record<string, ComponentType<{ className?: string; 'aria-hidden'?: boolean | 'true' | 'false' }>> = {
-  info:    InfoIcon,
-  warning: TriangleAlertIcon,
-  success: CircleCheckIcon,
-  danger:  CircleAlertIcon,
-}
-
-const ALERT_TYPE_DEFAULT_ICON_COLOR: Record<string, string> = {
-  info:    'info',
-  warning: 'warning',
-  success: 'success',
-  danger:  'destructive',
-}
-
-const ALERT_ACTIONS_ALIGNMENT: Record<string, string> = {
-  start:  'justify-start',
-  center: 'justify-center',
-  end:    'justify-end',
-}
-
-function alertPersistKey(persistKey: string): string {
-  return `pilotiq.alert.${persistKey}`
-}
-
-export function AlertRenderer(props: {
-  alertType:         string
-  content:           string
-  title?:            string
-  dismissible?:      boolean
-  persistDismissal?: string
-  iconColor?:        string
-  actionsAlignment?: string
-  footer:            React.ReactNode[]
-}): React.ReactNode {
-  const {
-    alertType, content, title, dismissible,
-    persistDismissal, iconColor, actionsAlignment, footer,
-  } = props
-  const [dismissed, setDismissed] = useState(false)
-
-  // Hydrate persisted-dismissal on first paint. `useState(false)` keeps
-  // SSR + first client paint identical (Hydration safe); the effect
-  // flips to dismissed if localStorage has the flag set.
-  useEffect(() => {
-    if (!persistDismissal) return
-    if (readStoredString(alertPersistKey(persistDismissal)) === '1') {
-      setDismissed(true)
-    }
-  }, [persistDismissal])
-
-  if (dismissed) return null
-
-  const styles    = alertStyles[alertType] ?? alertStyles['info']!
-  const Icon      = ALERT_TYPE_ICONS[alertType] ?? InfoIcon
-  const iconColorKey = iconColor ?? ALERT_TYPE_DEFAULT_ICON_COLOR[alertType] ?? 'info'
-  const iconColorCls = TEXT_COLOR_CLASSES[iconColorKey] ?? ''
-  const alignCls  = ALERT_ACTIONS_ALIGNMENT[actionsAlignment ?? 'start'] ?? 'justify-start'
-
-  const handleDismiss = (): void => {
-    setDismissed(true)
-    if (persistDismissal) writeStoredString(alertPersistKey(persistDismissal), '1')
-  }
-
-  return (
-    <div className={`relative rounded-lg border p-4 ${styles} ${dismissible ? 'pr-9' : ''}`}>
-      <div className="flex gap-3">
-        <Icon className={`size-5 shrink-0 mt-0.5 ${iconColorCls}`} aria-hidden="true" />
-        <div className="flex-1 min-w-0">
-          {title !== undefined && <p className="font-medium mb-1">{title}</p>}
-          <p className="text-sm">{content}</p>
-          {footer.length > 0 && (
-            <div className={`flex items-center gap-2 mt-3 ${alignCls}`}>
-              {footer}
-            </div>
-          )}
-        </div>
-      </div>
-      {dismissible && (
-        <button
-          type="button"
-          onClick={handleDismiss}
-          aria-label="Dismiss"
-          title="Dismiss"
-          className="absolute top-3 right-3 inline-flex h-6 w-6 items-center justify-center rounded opacity-70 hover:opacity-100 transition-opacity"
-        >
-          <XIcon className="size-4" aria-hidden="true" />
-        </button>
-      )}
-    </div>
-  )
-}