@solidxai/core 0.1.13-beta.2 → 0.1.13-beta.21

package/src/theme/theme-registry.ts

@@ -0,0 +1,181 @@
+import fs from "fs";
+import path from "path";
+
+/**
+ * Backend theme registry.
+ *
+ * Responsibilities:
+ * - discover theme folders from the filesystem
+ * - classify each theme as light/dark from its key
+ * - expose default and grouped theme helpers for backend settings
+ *
+ * Shared pure parsing helpers are intentionally mirrored in solid-core-ui,
+ * but all filesystem discovery stays here.
+ */
+export type ThemeMode = "light" | "dark";
+
+export type AppThemeDefinition = {
+  key: string;
+  label: string;
+  mode: ThemeMode;
+  default?: boolean;
+};
+
+const DEFAULT_THEME_KEYS: Record<ThemeMode, string> = {
+  light: "solid-light-purple",
+  dark: "solid-dark-purple",
+};
+
+const THEME_MODE_TOKENS: Record<ThemeMode, string> = {
+  light: "-light-",
+  dark: "-dark-",
+};
+
+const THEME_MODE_SUFFIXES: Record<ThemeMode, string> = {
+  light: "-light",
+  dark: "-dark",
+};
+
+function normalizeThemeKey(value?: string | null): string | null {
+  const normalized = value?.trim().toLowerCase();
+  return normalized || null;
+}
+
+function matchesThemeMode(value: string, mode: ThemeMode): boolean {
+  return (
+    value.includes(THEME_MODE_TOKENS[mode])
+    || value.endsWith(THEME_MODE_SUFFIXES[mode])
+    || value === mode
+  );
+}
+
+function titleCase(value: string): string {
+  return value
+    .split(/[-_\s]+/)
+    .filter(Boolean)
+    .map((token) => {
+      if (token.toLowerCase() === "solid") return "SolidX";
+      return token.charAt(0).toUpperCase() + token.slice(1);
+    })
+    .join(" ");
+}
+
+export function getThemeModeFromThemeKey(value?: string | null): ThemeMode | null {
+  const normalized = normalizeThemeKey(value);
+  if (!normalized) return null;
+
+  if (matchesThemeMode(normalized, "light")) return "light";
+  if (matchesThemeMode(normalized, "dark")) return "dark";
+
+  return null;
+}
+
+function createThemeDefinition(key: string, defaultTheme = false): AppThemeDefinition {
+  const mode = getThemeModeFromThemeKey(key);
+  if (!mode) {
+    throw new Error(`Invalid theme key: ${key}`);
+  }
+
+  return {
+    key,
+    label: titleCase(key),
+    mode,
+    default: defaultTheme,
+  };
+}
+
+function createDefaultTheme(mode: ThemeMode): AppThemeDefinition {
+  return createThemeDefinition(DEFAULT_THEME_KEYS[mode], true);
+}
+
+function groupThemesByMode(themes: AppThemeDefinition[], mode: ThemeMode): AppThemeDefinition[] {
+  return themes.filter((theme) => theme.mode === mode);
+}
+
+function pickDefaultThemeKey(themes: AppThemeDefinition[], mode: ThemeMode): string {
+  const themesForMode = groupThemesByMode(themes, mode);
+
+  return (
+    themesForMode.find((theme) => theme.default)?.key
+    ?? themesForMode[0]?.key
+    ?? DEFAULT_THEME_KEYS[mode]
+  );
+}
+
+function resolveThemeDirectory(): string | null {
+  const themeDirectory = path.resolve(process.cwd(), "..", "solid-ui", "public", "themes");
+  try {
+    if (fs.existsSync(themeDirectory) && fs.statSync(themeDirectory).isDirectory()) {
+      return path.resolve(themeDirectory);
+    }
+  } catch {
+    return null;
+  }
+
+  return null;
+}
+
+function isThemeDirectory(themeDirectory: string, entryName: string): boolean {
+  return fs.existsSync(path.join(themeDirectory, entryName, "theme.css"));
+}
+
+function readThemesFromPath(): AppThemeDefinition[] {
+  const themeDirectory = resolveThemeDirectory();
+  if (!themeDirectory) {
+    return [];
+  }
+
+  try {
+    const directoryEntries = fs.readdirSync(themeDirectory, { withFileTypes: true });
+
+    return directoryEntries
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name.trim())
+      .filter(Boolean)
+      .filter((entryName) => isThemeDirectory(themeDirectory, entryName))
+      .flatMap((entryName) => {
+        const mode = getThemeModeFromThemeKey(entryName);
+        if (!mode) return [];
+
+        return [createThemeDefinition(entryName, entryName === DEFAULT_THEME_KEYS[mode])];
+      })
+      .sort((left, right) => left.label.localeCompare(right.label));
+  } catch {
+    return [];
+  }
+}
+
+function getThemes(): AppThemeDefinition[] {
+  const discoveredThemes = readThemesFromPath();
+
+  if (discoveredThemes.length) {
+    return discoveredThemes;
+  }
+
+  return [createDefaultTheme("light"), createDefaultTheme("dark")];
+}
+
+export function getCoreThemes(): AppThemeDefinition[] {
+  return getThemes();
+}
+
+export function getRegisteredThemes(): AppThemeDefinition[] {
+  return getThemes();
+}
+
+export function getThemesByMode(mode: ThemeMode): AppThemeDefinition[] {
+  return groupThemesByMode(getRegisteredThemes(), mode);
+}
+
+export function getDefaultThemeKey(mode: ThemeMode = "light"): string {
+  return pickDefaultThemeKey(getRegisteredThemes(), mode);
+}
+
+export function isRegisteredThemeKey(value?: string | null, mode?: ThemeMode): value is string {
+  if (!value) return false;
+
+  return getRegisteredThemes().some((theme) => {
+    if (theme.key !== value) return false;
+    return mode ? theme.mode === mode : true;
+  });
+}

package/src/types/workflow-dsl.types.ts

@@ -200,6 +200,9 @@ export interface WorkflowNodeDefinition {
   /** Child nodes executed when no `switch.cases` entry matches the switch value. */
   defaults?: WorkflowNodeDefinition[];
 
+  /** Child nodes executed when this node or its child subtree fails. */
+  errors?: WorkflowNodeDefinition[];
+
   /**
    * Named child-node collections for `switch`.
    *
@@ -287,6 +290,12 @@ export interface WorkflowDefinitionDsl {
   /** Optional workflow triggers that can create executions. */
   triggers?: WorkflowTriggerDefinition[];
 
+  /** Workflow-level error handler nodes executed sequentially when execution fails. */
+  errors?: WorkflowNodeDefinition[];
+
+  /** Workflow-level cleanup nodes executed sequentially after success or failure. */
+  finally?: WorkflowNodeDefinition[];
+
   /** Workflow-level custom annotations for tooling. */
   metadata?: Record<string, any>;
 }
@@ -578,6 +587,13 @@ export interface WorkflowNodeOutputDefinition {
   /** Whether the output is expected on successful execution. */
   required?: boolean;
 
+  /**
+   * Whether this output is added to `outputs.<nodeId>` for downstream expressions.
+   * Defaults to true. Set false for observability-only outputs that should be
+   * stored on the step execution but not suggested or exposed to later nodes.
+   */
+  includeInRuntimeContext?: boolean;
+
   /** Optional machine schema for this output value. */
   schema?: Record<string, any>;
 }
@@ -867,6 +883,21 @@ export interface WorkflowExpressionResolver {
   resolveExpression(expression: string, context: WorkflowRuntimeContext): any;
 }
 
+/** Loop context exposed to expressions for nested itemized controls. */
+export interface WorkflowLoopContext {
+  /** Current item for this loop frame. */
+  item: any;
+
+  /** Zero-based iteration index for this loop frame. */
+  index: number;
+
+  /** Loop control node id. */
+  nodeId?: string;
+
+  /** Loop control step execution key. */
+  stepExecutionKey?: string;
+}
+
 /** Runtime context shared by workflow execution and node execution. */
 export interface WorkflowRuntimeContext {
   /** Parent workflow execution entity. */
@@ -905,6 +936,18 @@ export interface WorkflowRuntimeContext {
   /** Current item index for itemized/iterative control nodes. */
   index?: number;
 
+  /** Nearest parent loop frame, when inside nested loop children. */
+  parent?: WorkflowLoopContext;
+
+  /** Parent loop frames, nearest first. */
+  parents?: WorkflowLoopContext[];
+
+  /** Loop frames from outermost to innermost, including the current loop. */
+  loops?: WorkflowLoopContext[];
+
+  /** Current error context when executing an error handler. */
+  error?: any;
+
   /** Parent control node id when executing nested child nodes. */
   parentNodeId?: string;