@postxl/generators 1.12.2 → 1.13.0

package/dist/frontend-actions/generators/command-palette-store.generator.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCommandPaletteStore = generateCommandPaletteStore;
+function generateCommandPaletteStore() {
+    return `import { useMemo, useSyncExternalStore } from 'react'
+
+import { CommandPaletteAction, CommandPaletteActionPage, CommandPaletteActionResult } from './command-palette-action'
+
+type GroupedActions = {
+  group: string
+  actions: CommandPaletteAction[]
+}
+
+type CommandPaletteState = {
+  page: CommandPaletteActionPage
+  componentActions: CommandPaletteAction[]
+  globalActions: CommandPaletteAction[]
+  running: boolean
+  search: string
+  globalRenderer: ((component: React.FC | null) => void) | null
+}
+
+type CommandPaletteActions = {
+  find: (key: string) => CommandPaletteAction | undefined
+  back: () => void
+  reset: () => void
+  cancel: () => void
+  select: (key: string, signal: AbortSignal, query?: string, input?: unknown) => Promise<CommandPaletteActionResult>
+  registerPageActions: (page: CommandPaletteActionPage) => void
+  deregisterPageActions: () => void
+  registerComponentActions: (actions: CommandPaletteAction[]) => void
+  deregisterComponentActions: (actions: CommandPaletteAction[]) => void
+  registerGlobalActions: (...actions: CommandPaletteAction[]) => void
+  registerGlobalRenderer: (render: (component: React.FC | null) => void) => void
+  calculateAvailableLLMActions: () => CommandPaletteAction[]
+}
+
+type CommandPaletteStore = CommandPaletteState & { actions: CommandPaletteActions }
+
+const listeners = new Set<() => void>()
+const rootPage: CommandPaletteActionPage = { actions: [] }
+
+const into = (back: CommandPaletteActionPage, page: CommandPaletteActionPage): CommandPaletteActionPage => ({
+  ...page,
+  back,
+})
+
+const subscribe = (listener: () => void) => {
+  listeners.add(listener)
+  return () => listeners.delete(listener)
+}
+
+const notify = () => {
+  for (const listener of listeners) {
+    listener()
+  }
+}
+
+const setStore = (update: Partial<CommandPaletteState>) => {
+  store = {
+    ...store,
+    ...update,
+  }
+  notify()
+}
+
+const createActions = (): CommandPaletteActions => ({
+  calculateAvailableLLMActions() {
+    const { page, componentActions, globalActions } = store
+    const isRoot = !page.back
+    const isVisibleToLLM = (action: CommandPaletteAction) => action.visibility === 'visible' || action.visibility === 'llm'
+    const all = [
+      ...page.actions.filter(isVisibleToLLM),
+      ...(isRoot ? componentActions.filter(isVisibleToLLM) : []),
+      ...globalActions.filter(isVisibleToLLM),
+    ]
+
+    const seen = new Set<string>()
+    return all.filter((action) => {
+      if (seen.has(action.key)) {
+        return false
+      }
+
+      seen.add(action.key)
+      return true
+    })
+  },
+
+  find(key: string) {
+    const { page, componentActions, globalActions } = store
+    const isRoot = !page.back
+
+    return (
+      page.actions.find((action) => action.key === key) ??
+      (isRoot ? componentActions.find((action) => action.key === key) : undefined) ??
+      globalActions.find((action) => action.key === key)
+    )
+  },
+
+  back() {
+    const { page } = store
+    if (page.back) {
+      setStore({ page: page.back })
+    }
+  },
+
+  reset() {
+    let next = store.page
+
+    while (next.back) {
+      next = next.back
+    }
+
+    setStore({ page: next })
+  },
+
+  cancel() {
+    const { globalRenderer } = store
+    globalRenderer?.(null)
+    setStore({ running: false })
+  },
+
+  async select(key, signal, query = '', input = undefined) {
+    const { page, componentActions, globalActions, globalRenderer, running: wasRunning } = store
+    const isRoot = !page.back
+
+    const action =
+      page.actions.find((candidate) => candidate.key === key) ??
+      (isRoot ? componentActions.find((candidate) => candidate.key === key) : undefined) ??
+      globalActions.find((candidate) => candidate.key === key)
+
+    if (!action) {
+      return { kind: 'close' }
+    }
+
+    setStore({ running: true })
+
+    try {
+      signal.throwIfAborted()
+      const result = await action.run(query, input, signal, globalRenderer ?? (() => null))
+
+      if (result.kind === 'page') {
+        setStore({ page: into(page, result) })
+      }
+
+      return result
+    } finally {
+      globalRenderer?.(null)
+      setStore({ running: wasRunning })
+    }
+  },
+
+  registerPageActions(page) {
+    setStore({ page })
+  },
+
+  deregisterPageActions() {
+    setStore({ page: rootPage })
+  },
+
+  registerComponentActions(actions) {
+    const incoming = new Set(actions.map((action) => action.key))
+    const componentActions = [...store.componentActions.filter((action) => !incoming.has(action.key)), ...actions]
+    setStore({ componentActions })
+  },
+
+  deregisterComponentActions(actions) {
+    const toRemove = new Set(actions.map((action) => action.key))
+    setStore({ componentActions: store.componentActions.filter((action) => !toRemove.has(action.key)) })
+  },
+
+  registerGlobalActions(...actions) {
+    const incoming = new Set(actions.map((action) => action.key))
+    const globalActions = [...store.globalActions.filter((action) => !incoming.has(action.key)), ...actions]
+    setStore({ globalActions })
+  },
+
+  registerGlobalRenderer(render) {
+    setStore({ globalRenderer: render })
+  },
+})
+
+let store: CommandPaletteStore = {
+  page: rootPage,
+  componentActions: [],
+  globalActions: [],
+  running: false,
+  search: '',
+  globalRenderer: null,
+  actions: {} as CommandPaletteActions,
+}
+store.actions = createActions()
+
+export const useCommandPaletteState = <T>(selector: (state: CommandPaletteState) => T): T =>
+  useSyncExternalStore(subscribe, () => selector(store), () => selector(store))
+
+export const useCommandPaletteActions = (): CommandPaletteActions =>
+  useSyncExternalStore(subscribe, () => store.actions, () => store.actions)
+
+export const useCommandPaletteAvailableActions = (query: string): GroupedActions[] => {
+  const page = useCommandPaletteState((state) => state.page)
+  const componentActions = useCommandPaletteState((state) => state.componentActions)
+  const globalActions = useCommandPaletteState((state) => state.globalActions)
+
+  return useMemo(
+    () => calculateAvailableActions({ page, componentActions, globalActions, query }),
+    [page, componentActions, globalActions, query],
+  )
+}
+
+const calculateAvailableActions = ({
+  page,
+  componentActions,
+  globalActions,
+  query,
+}: {
+  page: CommandPaletteActionPage
+  componentActions: CommandPaletteAction[]
+  globalActions: CommandPaletteAction[]
+  query: string
+}): GroupedActions[] => {
+  const hasQuery = query.trim().length > 0
+  const isRoot = !page.back
+
+  const canBeShownToUser = (action: CommandPaletteAction) => action.visibility === 'visible' || action.visibility === 'user'
+
+  const actionByGroup = new Map<string, CommandPaletteAction[]>()
+  const ungrouped: CommandPaletteAction[] = []
+  const seen = new Set<string>()
+
+  for (const action of [...page.actions, ...(isRoot ? componentActions : [])]) {
+    if (!canBeShownToUser(action)) {
+      continue
+    }
+
+    if (seen.has(action.key)) {
+      continue
+    }
+
+    if (action.group) {
+      const existing = actionByGroup.get(action.group) ?? []
+      actionByGroup.set(action.group, [...existing, action])
+    } else {
+      ungrouped.push(action)
+    }
+
+    seen.add(action.key)
+  }
+
+  const result: GroupedActions[] = []
+
+  if (isRoot) {
+    const filteredGlobal = globalActions.filter((action) => canBeShownToUser(action) && !seen.has(action.key))
+    if (filteredGlobal.length > 0) {
+      result.push({ group: 'Global actions', actions: filteredGlobal })
+    }
+  }
+
+  if (ungrouped.length > 0) {
+    result.push({ group: 'On this page', actions: ungrouped })
+  }
+
+  for (const [group, actions] of actionByGroup.entries()) {
+    result.push({ group, actions })
+  }
+
+  if (!hasQuery) {
+    return result
+  }
+
+  const terms = query
+    .toLowerCase()
+    .split(/\\s+/)
+    .map((term) => term.trim())
+    .filter(Boolean)
+
+  const matches = (action: CommandPaletteAction) => {
+    const text = [action.label, ...(action.keywords ?? [])].join(' ').toLowerCase()
+    return terms.every((term) => text.includes(term))
+  }
+
+  return result
+    .map((group) => ({ ...group, actions: group.actions.filter(matches) }))
+    .filter((group) => group.actions.length > 0)
+}
+`;
+}
+//# sourceMappingURL=command-palette-store.generator.js.map

package/dist/frontend-actions/generators/command-palette-store.generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-palette-store.generator.js","sourceRoot":"","sources":["../../../src/frontend-actions/generators/command-palette-store.generator.ts"],"names":[],"mappings":";;AAAA,kEA2RC;AA3RD,SAAgB,2BAA2B;IACzC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyRR,CAAA;AACD,CAAC"}

package/dist/frontend-actions/generators/command-palette.generator.d.ts

@@ -0,0 +1,5 @@
+import * as Generator from '@postxl/generator';
+import { WithFrontendActions } from '../actions.generator';
+export declare function generateCommandPalette({ context }: {
+    context: WithFrontendActions<Generator.Context>;
+}): string;

package/dist/frontend-actions/generators/command-palette.generator.js

@@ -0,0 +1,332 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCommandPalette = generateCommandPalette;
+const Generator = __importStar(require("@postxl/generator"));
+function generateCommandPalette({ context }) {
+    const imports = Generator.ImportGenerator.from(Generator.toFilePath('./command-palette.tsx'))
+        .addImport({
+        from: Generator.toPackageName('react'),
+        items: [
+            Generator.toClassName('Component'),
+            Generator.toTypeName('ErrorInfo'),
+            Generator.toTypeName('PropsWithChildren'),
+            Generator.toFunctionName('useCallback'),
+            Generator.toFunctionName('useDeferredValue'),
+            Generator.toFunctionName('useEffect'),
+            Generator.toFunctionName('useMemo'),
+            Generator.toFunctionName('useRef'),
+            Generator.toFunctionName('useState'),
+        ],
+    })
+        .addImport({
+        from: Generator.toPackageName('@postxl/ui-components'),
+        items: [
+            Generator.toFunctionName('CommandDialog'),
+            Generator.toFunctionName('CommandGroup'),
+            Generator.toFunctionName('CommandInput'),
+            Generator.toFunctionName('CommandItem'),
+            Generator.toFunctionName('CommandList'),
+        ],
+    })
+        .addImport({ from: Generator.toBackendModuleLocation('@lib/router'), items: [Generator.toConstantName('router')] });
+    for (const hook of context.frontendActions.globalActionHooks) {
+        imports.add(hook);
+    }
+    const hookCalls = context.frontendActions.globalActionHooks.map((hook) => `  ${hook.name}()`).join('\n');
+    return `
+${imports.generate()}
+
+import {
+  useCommandPaletteActions,
+  useCommandPaletteAvailableActions,
+  useCommandPaletteState,
+} from './command-palette-store'
+
+type CommandPaletteErrorBoundaryState = {
+  hasError: boolean
+}
+
+class CommandPaletteErrorBoundary extends Component<PropsWithChildren, CommandPaletteErrorBoundaryState> {
+  public constructor(props: PropsWithChildren) {
+    super(props)
+    this.state = { hasError: false }
+  }
+
+  public static getDerivedStateFromError(): CommandPaletteErrorBoundaryState {
+    return { hasError: true }
+  }
+
+  public componentDidCatch(error: unknown, info: ErrorInfo) {
+    console.error('CommandPalette rendering failed:', error, info)
+  }
+
+  public render() {
+    if (this.state.hasError) {
+      return null
+    }
+
+    return this.props.children
+  }
+}
+
+export function CommandPalette() {
+  return (
+    <CommandPaletteErrorBoundary>
+      <CommandPaletteInner />
+    </CommandPaletteErrorBoundary>
+  )
+}
+
+function CommandPaletteInner() {
+  const { find, cancel, registerGlobalRenderer, deregisterPageActions } = useCommandPaletteActions()
+  const isRunning = useCommandPaletteState((state) => state.running)
+  const {
+    mode,
+    open,
+    value,
+    inputRef,
+    handleKeydown,
+    handleOpenChange: onOpenChange,
+    handleSelect,
+    handleValueChange,
+  } = useCommandPaletteInput()
+
+  const deferredValue = useDeferredValue(value)
+  const availableActions = useCommandPaletteAvailableActions(deferredValue)
+
+${hookCalls}
+
+  const suggestions = useMemo(() => {
+    if (mode.value === 'search') {
+      return []
+    }
+
+    return find(mode.key)?.suggestions ?? []
+  }, [mode, find])
+
+  const [CustomContent, setCustomContent] = useState<React.FC | null>(null)
+
+  const handleOpenChange = useCallback(
+    (isOpen: boolean) => {
+      if (!isOpen) {
+        cancel()
+        setCustomContent(null)
+      }
+
+      onOpenChange(isOpen)
+    },
+    [cancel, onOpenChange],
+  )
+
+  useEffect(() => {
+    registerGlobalRenderer((component) => setCustomContent(() => component))
+  }, [registerGlobalRenderer])
+
+  useEffect(() => {
+    const down = (event: KeyboardEvent) => {
+      if (event.key.toLowerCase() === 'k' && (event.metaKey || event.ctrlKey)) {
+        event.preventDefault()
+        handleOpenChange(true)
+      }
+
+      handleKeydown(event)
+    }
+
+    document.addEventListener('keydown', down)
+    return () => document.removeEventListener('keydown', down)
+  }, [handleKeydown, handleOpenChange])
+
+  useEffect(() => {
+    return router.subscribe('onBeforeRouteMount', () => {
+      deregisterPageActions()
+    })
+  }, [deregisterPageActions])
+
+  return (
+    <CommandDialog open={open} onOpenChange={handleOpenChange}>
+      <CommandInput
+        ref={inputRef}
+        value={value}
+        onValueChange={handleValueChange}
+        placeholder={mode.value === 'search' ? 'Type a command or search...' : 'Enter value...'}
+      />
+
+      {CustomContent ? (
+        <CustomContent />
+      ) : (
+        <CommandList>
+          {mode.value === 'input' &&
+            suggestions.map((suggestion) => (
+              <CommandItem key={suggestion} value={suggestion} onSelect={() => handleSelect(suggestion, 'input')}>
+                {suggestion}
+              </CommandItem>
+            ))}
+
+          {availableActions.map(({ group, actions }) => (
+            <CommandGroup key={group} heading={group}>
+              {actions.map((action) => (
+                <CommandItem
+                  key={action.key}
+                  value={action.key}
+                  keywords={action.keywords}
+                  onSelect={() => handleSelect(action.key, action.kind)}
+                >
+                  {action.icon}
+                  {action.label}
+                </CommandItem>
+              ))}
+            </CommandGroup>
+          ))}
+        </CommandList>
+      )}
+
+      {isRunning && <div className="px-3 py-2 text-sm text-muted-foreground">Running action...</div>}
+    </CommandDialog>
+  )
+}
+
+const useCommandPaletteInput = () => {
+  const { select, back, reset } = useCommandPaletteActions()
+
+  const didSelect = useRef(false)
+  const inputRef = useRef<HTMLInputElement | null>(null)
+  const abortRef = useRef<AbortController | null>(null)
+
+  const [open, setOpen] = useState(false)
+  const [value, setValue] = useState('')
+  const [mode, setMode] = useState<{ value: 'search' } | { value: 'input'; key: string }>({ value: 'search' })
+
+  const handleOpenChange = useCallback(
+    (isOpen: boolean) => {
+      setOpen(isOpen)
+
+      if (!isOpen) {
+        setValue('')
+        setMode({ value: 'search' })
+        reset()
+        abortRef.current?.abort()
+      }
+
+      if (isOpen) {
+        setTimeout(() => inputRef.current?.focus(), 75)
+      }
+    },
+    [reset],
+  )
+
+  const runAction = useCallback(
+    async (key: string, query = '', input: unknown = undefined) => {
+      abortRef.current = new AbortController()
+      const result = await select(key, abortRef.current.signal, query, input)
+      handleOpenChange(result.kind !== 'close')
+      setMode({ value: 'search' })
+      return result
+    },
+    [handleOpenChange, select],
+  )
+
+  const handleKeydown = useCallback(
+    (event: KeyboardEvent) => {
+      if (!open) {
+        return
+      }
+
+      if (event.key === 'Backspace' && value === '') {
+        if (mode.value === 'input') {
+          setMode({ value: 'search' })
+          return
+        }
+
+        back()
+        return
+      }
+
+      if (event.key === 'Escape') {
+        handleOpenChange(false)
+        return
+      }
+
+      if (event.key === 'Enter') {
+        event.preventDefault()
+
+        if (didSelect.current) {
+          didSelect.current = false
+          return
+        }
+
+        if (mode.value === 'input') {
+          void runAction(mode.key, value, { query: value })
+          return
+        }
+      }
+    },
+    [open, value, mode, back, handleOpenChange, runAction],
+  )
+
+  const handleSelect = useCallback(
+    (key: string, kind: 'command' | 'input') => {
+      didSelect.current = true
+
+      if (mode.value === 'search') {
+        if (kind === 'input') {
+          setValue('')
+          setMode({ value: 'input', key })
+          return
+        }
+
+        void runAction(key)
+        return
+      }
+
+      void runAction(mode.key, key, { query: key })
+    },
+    [mode, runAction],
+  )
+
+  return {
+    mode,
+    open,
+    value,
+    inputRef,
+    handleOpenChange,
+    handleKeydown,
+    handleSelect,
+    handleValueChange: setValue,
+  }
+}
+`;
+}
+//# sourceMappingURL=command-palette.generator.js.map

package/dist/frontend-actions/generators/command-palette.generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-palette.generator.js","sourceRoot":"","sources":["../../../src/frontend-actions/generators/command-palette.generator.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,wDAwSC;AA5SD,6DAA8C;AAI9C,SAAgB,sBAAsB,CAAC,EAAE,OAAO,EAAuD;IACrG,MAAM,OAAO,GAAG,SAAS,CAAC,eAAe,CAAC,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,uBAAuB,CAAC,CAAC;SAC1F,SAAS,CAAC;QACT,IAAI,EAAE,SAAS,CAAC,aAAa,CAAC,OAAO,CAAC;QACtC,KAAK,EAAE;YACL,SAAS,CAAC,WAAW,CAAC,WAAW,CAAC;YAClC,SAAS,CAAC,UAAU,CAAC,WAAW,CAAC;YACjC,SAAS,CAAC,UAAU,CAAC,mBAAmB,CAAC;YACzC,SAAS,CAAC,cAAc,CAAC,aAAa,CAAC;YACvC,SAAS,CAAC,cAAc,CAAC,kBAAkB,CAAC;YAC5C,SAAS,CAAC,cAAc,CAAC,WAAW,CAAC;YACrC,SAAS,CAAC,cAAc,CAAC,SAAS,CAAC;YACnC,SAAS,CAAC,cAAc,CAAC,QAAQ,CAAC;YAClC,SAAS,CAAC,cAAc,CAAC,UAAU,CAAC;SACrC;KACF,CAAC;SACD,SAAS,CAAC;QACT,IAAI,EAAE,SAAS,CAAC,aAAa,CAAC,uBAAuB,CAAC;QACtD,KAAK,EAAE;YACL,SAAS,CAAC,cAAc,CAAC,eAAe,CAAC;YACzC,SAAS,CAAC,cAAc,CAAC,cAAc,CAAC;YACxC,SAAS,CAAC,cAAc,CAAC,cAAc,CAAC;YACxC,SAAS,CAAC,cAAc,CAAC,aAAa,CAAC;YACvC,SAAS,CAAC,cAAc,CAAC,aAAa,CAAC;SACxC;KACF,CAAC;SACD,SAAS,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,uBAAuB,CAAC,aAAa,CAAC,EAAE,KAAK,EAAE,CAAC,SAAS,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAA;IAErH,KAAK,MAAM,IAAI,IAAI,OAAO,CAAC,eAAe,CAAC,iBAAiB,EAAE,CAAC;QAC7D,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;IACnB,CAAC;IAED,MAAM,SAAS,GAAG,OAAO,CAAC,eAAe,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAExG,OAAO;EACP,OAAO,CAAC,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4DlB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwMV,CAAA;AACD,CAAC"}

package/dist/frontend-actions/generators/filter-utils.generator.d.ts

@@ -0,0 +1 @@
+export declare function generateFilterUtils(): string;

package/dist/frontend-actions/generators/filter-utils.generator.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFilterUtils = generateFilterUtils;
+function generateFilterUtils() {
+    return `import { z } from 'zod'
+
+export const stringFilterInputSchema = z.object({
+  values: z.array(z.string()).optional(),
+  contains: z.string().optional(),
+  startsWith: z.string().optional(),
+  endsWith: z.string().optional(),
+  exclude: z.string().optional(),
+})
+
+export const numberFilterInputSchema = z.object({
+  values: z.array(z.number()).optional(),
+  min: z.number().optional(),
+  max: z.number().optional(),
+})
+
+export const dateFilterInputSchema = z.object({
+  values: z.array(z.string()).optional(),
+  start: z.string().optional(),
+  end: z.string().optional(),
+})
+
+export const booleanFilterInputSchema = z.object({
+  values: z.array(z.boolean()).optional(),
+})
+
+export const parseBooleanQuery = (query: string): boolean[] | undefined => {
+  const normalized = query.trim().toLowerCase()
+  if (normalized === 'true') {
+    return [true]
+  }
+  if (normalized === 'false') {
+    return [false]
+  }
+  return undefined
+}
+
+export const toFilterActionLabel = (value: string): string =>
+  value
+    .replaceAll(/([A-Z])([A-Z][a-z])/g, '$1 $2')
+    .replaceAll(/([a-z])([A-Z])/g, '$1 $2')
+    .replaceAll(/[-_]+/, ' ')
+    .replace(/^./, (char) => char.toUpperCase())
+`;
+}
+//# sourceMappingURL=filter-utils.generator.js.map

package/dist/frontend-actions/generators/filter-utils.generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-utils.generator.js","sourceRoot":"","sources":["../../../src/frontend-actions/generators/filter-utils.generator.ts"],"names":[],"mappings":";;AAAA,kDA6CC;AA7CD,SAAgB,mBAAmB;IACjC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2CR,CAAA;AACD,CAAC"}

package/dist/frontend-actions/generators/sidepanel-toggle.generator.d.ts

@@ -0,0 +1 @@
+export declare function generateSidepanelToggle(): string;