@pilotiq/pilotiq 0.5.0 → 0.6.1

package/src/schema/containers.test.ts

@@ -399,6 +399,34 @@ describe('Wizard / Step (Plan #8)', () => {
     assert.equal(result[0]!['persist'], false)
   })
 
+  describe('Step.beforeValidation / afterValidation', () => {
+    it('accessors return undefined when no hooks are set', () => {
+      const step = Step.make('x').schema([])
+      assert.equal(step.getBeforeValidation(), undefined)
+      assert.equal(step.getAfterValidation(),  undefined)
+    })
+
+    it('accessors return the registered hook function', () => {
+      const before = async () => {}
+      const after  = () => {}
+      const step = Step.make('x').schema([]).beforeValidation(before).afterValidation(after)
+      assert.equal(step.getBeforeValidation(), before)
+      assert.equal(step.getAfterValidation(),  after)
+    })
+
+    it('hooks are not serialized into the wire shape', async () => {
+      const tree = [
+        Wizard.make().steps([
+          Step.make('a').schema([]).beforeValidation(() => {}).afterValidation(() => {}),
+        ]),
+      ]
+      const result = await resolveSchema(tree)
+      const step = result[0]!.children![0]!
+      assert.equal(step['beforeValidation'], undefined)
+      assert.equal(step['afterValidation'],  undefined)
+    })
+  })
+
   it('all step children resolve so cross-step $get works', async () => {
     // Step 2 has a Section that hides based on a value entered in Step 0;
     // both steps must be resolved on every cycle for the predicate to fire.

package/src/schema/index.ts

@@ -28,6 +28,7 @@ export { Group } from './Group.js'
 export { Fieldset } from './Fieldset.js'
 export { Split, type SplitFrom } from './Split.js'
 export { Wizard, Step } from './Wizard.js'
+export { SlotComponent } from './SlotComponent.js'
 export {
   resolveSchema,
   registerResolver,

package/src/slot-components/index.ts

@@ -0,0 +1,10 @@
+// Slot-component runtime registry — opt-in component registration for
+// `SlotComponent` schema elements. Imported by panel `bootstrap/providers.ts`
+// or by a plugin's `register(panel)` step (e.g. `@pilotiq-pro/ai`'s
+// resource-header agents dropdown).
+export {
+  registerSlotComponents,
+  getSlotComponent,
+  type SlotComponent,
+  type SlotComponentProps,
+} from './registry.js'

package/src/slot-components/registry.ts

@@ -0,0 +1,56 @@
+import type { ComponentType } from 'react'
+
+/**
+ * Render-time component registry for `SlotComponent` schema elements.
+ * Mirrors the widget / entry registry pattern: users register components
+ * by name in their app's `bootstrap/providers.ts` (or via a plugin's
+ * `register(panel)` hook), the `SlotComponent` ships the registered name
+ * on the wire (`{ component: 'BookmarkButton' }`), and the renderer
+ * looks up the actual component at render through `getSlotComponent()`.
+ *
+ * Why a runtime registry rather than the build-time `_components.ts`
+ * manifest the icon system uses: slot components typically live in plugin
+ * packages or app-level bootstrap files, not on Resource / Global / Page
+ * top-level statics, so the existing manifest walker doesn't see them. A
+ * runtime register-by-name keeps the wire compact and mirrors the
+ * `registerWidgetComponents / registerEntryComponents` precedent.
+ *
+ * @example
+ *   // bootstrap/providers.ts
+ *   import { registerSlotComponents } from '@pilotiq/pilotiq/slot-components'
+ *   import { BookmarkButton } from '#components/BookmarkButton.js'
+ *   registerSlotComponents({ BookmarkButton })
+ *
+ *   // Then a render-hook contribution (or any schema slot) can reference it:
+ *   panel.renderHook(
+ *     'panels::resource.pages.edit-record.header.actions.before',
+ *     () => [SlotComponent.make('BookmarkButton').props({ … })],
+ *   )
+ */
+
+/**
+ * Props handed to every registered slot component. The schema-side
+ * `SlotComponent.props({...})` setter ships through verbatim — pack
+ * everything the component needs into that bag (basePath, recordId,
+ * pre-resolved agent metas, etc).
+ */
+export type SlotComponentProps = Record<string, unknown>
+export type SlotComponent      = ComponentType<SlotComponentProps>
+
+const registry: Record<string, SlotComponent> = {}
+
+export function registerSlotComponents(map: Record<string, SlotComponent>): void {
+  for (const key of Object.keys(map)) {
+    const c = map[key]
+    if (c) registry[key] = c
+  }
+}
+
+export function getSlotComponent(name: string): SlotComponent | undefined {
+  return registry[name]
+}
+
+/** Test-only: clear the registry. Not exported from the public entry. */
+export function _resetSlotComponentRegistryForTests(): void {
+  for (const key of Object.keys(registry)) delete registry[key]
+}