@pure-ds/core 0.6.8 → 0.6.10

package/src/js/pds-core/pds-live.js

@@ -4,7 +4,18 @@
  */
 import { Generator } from "./pds-generator.js";
 import { applyStyles, adoptLayers, adoptPrimitives } from "./pds-runtime.js";
-import { presets, defaultLog, PDS_CONFIG_RELATIONS } from "./pds-config.js";
+import {
+  presets,
+  defaultLog,
+  PDS_CONFIG_RELATIONS,
+  PDS_DESIGN_CONFIG_SPEC,
+  PDS_DEFAULT_CONFIG_EDITOR_METADATA,
+  PDS_DEFAULT_CONFIG_FORM_SCHEMA,
+  buildDesignConfigFormSchema,
+  getDesignConfigEditorMetadata,
+  validateDesignConfig,
+  validateInitConfig,
+} from "./pds-config.js";
 import { defaultPDSEnhancers } from "./pds-enhancers.js";
 import { defaultPDSEnhancerMetadata } from "./pds-enhancers-meta.js";
 import { resolvePublicAssetURL } from "./pds-paths.js";
@@ -21,6 +32,7 @@ import {
 } from "./pds-start-helpers.js";
 import {
   isPresetThemeCompatible,
+  normalizePresetThemes,
   resolveThemePreference,
 } from "./pds-theme-utils.js";
 
@@ -90,6 +102,142 @@ function applyStoredConfigOverrides(baseConfig) {
   return nextConfig;
 }
 
+function buildPresetOmniboxSettings(PDS, options = {}) {
+  const {
+    hideCategory = true,
+    itemGrid = "45px 1fr",
+    includeIncompatible = true,
+    disableIncompatible = true,
+    categoryName = "Presets",
+    theme,
+    onSelect,
+    iconHandler,
+  } = options || {};
+
+  const resolvedTheme = resolveThemePreference(theme ?? PDS?.theme);
+
+  const defaultIconHandler = (item) => {
+    const preset = findPresetById(item?.id);
+    const colors = preset?.colors || {};
+    const primary = colors?.primary;
+    const secondary = colors?.secondary;
+    const accent = colors?.accent;
+
+    if (primary && secondary && accent) {
+      return `<span style="display:flex;gap:1px;flex-shrink:0;" aria-hidden="true">
+        <span style="display:inline-block;width:10px;height:20px;background-color:${primary};">&nbsp;</span>
+        <span style="display:inline-block;width:10px;height:20px;background-color:${secondary};">&nbsp;</span>
+        <span style="display:inline-block;width:10px;height:20px;background-color:${accent};">&nbsp;</span>
+      </span>`;
+    }
+
+    if (item?.icon) {
+      return `<pds-icon icon="${item.icon}" size="sm"></pds-icon>`;
+    }
+    return "";
+  };
+
+  const getPresetEntries = () => {
+    const source = PDS?.presets || {};
+    return Object.values(source || {}).filter((preset) => {
+      const presetId = preset?.id || preset?.name;
+      return Boolean(presetId);
+    });
+  };
+
+  const findPresetById = (presetId) => {
+    if (!presetId) return null;
+    const entries = getPresetEntries();
+    return (
+      entries.find((preset) => String(preset?.id || preset?.name) === String(presetId)) ||
+      null
+    );
+  };
+
+  return {
+    hideCategory,
+    itemGrid,
+    iconHandler:
+      typeof iconHandler === "function" ? iconHandler : defaultIconHandler,
+    categories: {
+      [categoryName]: {
+        trigger: () => true,
+        getItems: (context = {}) => {
+          const query = String(context?.search || "").toLowerCase().trim();
+          const entries = getPresetEntries();
+
+          return entries
+            .filter((preset) => {
+              const name = String(preset?.name || preset?.id || "").toLowerCase();
+              const description = String(preset?.description || "").toLowerCase();
+              const tags = Array.isArray(preset?.tags)
+                ? preset.tags.map((tag) => String(tag).toLowerCase())
+                : [];
+
+              if (query) {
+                const matchesQuery =
+                  name.includes(query) ||
+                  description.includes(query) ||
+                  tags.some((tag) => tag.includes(query));
+                if (!matchesQuery) return false;
+              }
+
+              const compatible = isPresetThemeCompatible(preset, resolvedTheme);
+              if (!includeIncompatible && !compatible) return false;
+              return true;
+            })
+            .map((preset) => {
+              const presetId = preset?.id || preset?.name;
+              const compatible = isPresetThemeCompatible(preset, resolvedTheme);
+              const supportedThemes = normalizePresetThemes(preset);
+              const themeHint =
+                supportedThemes.length === 1
+                  ? `${supportedThemes[0]} only`
+                  : `Not available in ${resolvedTheme} mode`;
+              const baseDescription = String(preset?.description || "").trim();
+              const description = compatible
+                ? baseDescription
+                : baseDescription
+                  ? `${baseDescription} - ${themeHint}`
+                  : themeHint;
+
+              return {
+                id: presetId,
+                text: preset?.name || String(presetId),
+                description,
+                icon: "palette",
+                class:
+                  !compatible && disableIncompatible ? "disabled" : "",
+                disabled: !compatible && disableIncompatible,
+                tooltip: !compatible ? themeHint : "",
+              };
+            })
+            .sort((a, b) =>
+              String(a.text || "").localeCompare(String(b.text || ""))
+            );
+        },
+        action: async (selection) => {
+          if (!selection?.id) return selection?.id;
+          if (selection?.disabled) return selection?.id;
+
+          const preset = findPresetById(selection.id);
+          if (!preset) return selection?.id;
+
+          if (typeof onSelect === "function") {
+            return await onSelect({ preset, selection, resolvedTheme });
+          }
+
+          if (typeof PDS?.applyLivePreset === "function") {
+            await PDS.applyLivePreset(preset.id || selection.id);
+          }
+
+          return preset.id || selection.id;
+        },
+      },
+    },
+  };
+}
+
 async function __attachLiveAPIs(PDS, { applyResolvedTheme, setupSystemListenerIfNeeded }) {
   if (__liveApiReady) return;
 
@@ -113,6 +261,11 @@ async function __attachLiveAPIs(PDS, { applyResolvedTheme, setupSystemListenerIf
   PDS.common = commonModule || {};
   PDS.presets = presets;
   PDS.configRelations = PDS_CONFIG_RELATIONS;
+  PDS.configSpec = PDS_DESIGN_CONFIG_SPEC;
+  PDS.configEditorMetadata = PDS_DEFAULT_CONFIG_EDITOR_METADATA;
+  PDS.configFormSchema = PDS_DEFAULT_CONFIG_FORM_SCHEMA;
+  PDS.buildConfigFormSchema = buildDesignConfigFormSchema;
+  PDS.getConfigEditorMetadata = getDesignConfigEditorMetadata;
   PDS.enhancerMetadata = defaultPDSEnhancerMetadata;
   PDS.applyStyles = function(generator) {
     return applyStyles(generator || Generator.instance);
@@ -140,6 +293,9 @@ async function __attachLiveAPIs(PDS, { applyResolvedTheme, setupSystemListenerIf
     const queryEngine = new __queryClass(PDS);
     return await queryEngine.search(question);
   };
+  PDS.buildPresetOmniboxSettings = function(options = {}) {
+    return buildPresetOmniboxSettings(PDS, options);
+  };
 
   PDS.applyLivePreset = async function(presetId, options = {}) {
     if (!presetId) return false;
@@ -158,6 +314,8 @@ async function __attachLiveAPIs(PDS, { applyResolvedTheme, setupSystemListenerIf
     const normalized = normalizeInitConfig(inputConfig, {}, {
       presets,
       defaultLog,
+      validateDesignConfig,
+      validateInitConfig,
     });
 
     const resolvedTheme = resolveThemePreference(PDS.theme);
@@ -199,6 +357,12 @@ async function __attachLiveAPIs(PDS, { applyResolvedTheme, setupSystemListenerIf
       design: structuredClone(normalized.generatorConfig.design),
       theme: normalized.generatorConfig.theme || baseConfig.theme,
     });
+    PDS.configEditorMetadata = getDesignConfigEditorMetadata(
+      normalized.generatorConfig.design
+    );
+    PDS.configFormSchema = buildDesignConfigFormSchema(
+      normalized.generatorConfig.design
+    );
 
     const persist = options?.persist !== false;
     if (persist && typeof window !== "undefined") {
@@ -351,7 +515,12 @@ export async function startLive(PDS, config, { emitReady, applyResolvedTheme, se
     });
 
     // 2) Normalize first-arg API: support { preset, design, enhancers }
-    const normalized = normalizeInitConfig(config, {}, { presets, defaultLog });
+    const normalized = normalizeInitConfig(config, {}, {
+      presets,
+      defaultLog,
+      validateDesignConfig,
+      validateInitConfig,
+    });
     if (manageTheme && !isPresetThemeCompatible(normalized.generatorConfig.design, resolvedTheme)) {
       const presetName =
         normalized.presetInfo?.name ||
@@ -509,6 +678,12 @@ export async function startLive(PDS, config, { emitReady, applyResolvedTheme, se
       theme: resolvedTheme,
       enhancers: mergedEnhancers,
     });
+    PDS.configEditorMetadata = getDesignConfigEditorMetadata(
+      normalized.generatorConfig.design
+    );
+    PDS.configFormSchema = buildDesignConfigFormSchema(
+      normalized.generatorConfig.design
+    );
 
     
     if (config?.liveEdit && typeof document !== "undefined") {

package/src/js/pds-core/pds-ontology.js

@@ -461,6 +461,12 @@ export const ontology = {
       description: "Toggle switch from checkbox",
       tags: ["switch", "boolean", "form"]
     },
+    {
+      id: "color-input",
+      selector: "label[data-color]",
+      description: "Enhanced color input with swatch shell and hex output",
+      tags: ["color", "input", "form"]
+    },
     {
       id: "range",
       selector: 'input[type="range"]',

package/src/js/pds-core/pds-start-helpers.js

@@ -3,8 +3,6 @@
  * Kept separate to avoid pulling live-only logic into the base runtime bundle.
  */
 
-import { validateDesignConfig, validateInitConfig } from "./pds-config.js";
-
 const __ABSOLUTE_URL_PATTERN__ = /^[a-z][a-z0-9+\-.]*:\/\//i;
 const __MODULE_URL__ = (() => {
   try {
@@ -131,7 +129,11 @@ export function stripFunctions(obj) {
 }
 
 // Internal: normalize first-arg config to a full generator config and extract enhancers if provided inline
-export function normalizeInitConfig(inputConfig = {}, options = {}, { presets, defaultLog }) {
+export function normalizeInitConfig(
+  inputConfig = {},
+  options = {},
+  { presets, defaultLog, validateDesignConfig, validateInitConfig } = {}
+) {
   const logFn =
     inputConfig && typeof inputConfig.log === "function"
       ? inputConfig.log
@@ -174,7 +176,7 @@ export function normalizeInitConfig(inputConfig = {}, options = {}, { presets, d
     "design" in (inputConfig || {}) ||
     "enhancers" in (inputConfig || {});
 
-  if (inputConfig && typeof inputConfig === "object") {
+  if (inputConfig && typeof inputConfig === "object" && typeof validateInitConfig === "function") {
     validateInitConfig(inputConfig, { log: logFn, context: "PDS.start" });
   }
 
@@ -182,7 +184,11 @@ export function normalizeInitConfig(inputConfig = {}, options = {}, { presets, d
   let presetInfo = null;
 
   if (hasNewShape) {
-    if (designOverrides && typeof designOverrides === "object") {
+    if (
+      designOverrides &&
+      typeof designOverrides === "object" &&
+      typeof validateDesignConfig === "function"
+    ) {
       validateDesignConfig(designOverrides, { log: logFn, context: "PDS.start" });
     }
     // Always resolve a preset; default if none provided
@@ -242,7 +248,9 @@ export function normalizeInitConfig(inputConfig = {}, options = {}, { presets, d
       log: userLog || defaultLog,
     };
   } else if (hasDesignKeys) {
-    validateDesignConfig(inputConfig, { log: logFn, context: "PDS.start" });
+    if (typeof validateDesignConfig === "function") {
+      validateDesignConfig(inputConfig, { log: logFn, context: "PDS.start" });
+    }
     // Back-compat: treat the provided object as the full design, wrap it
     const { log: userLog, ...designConfig } = inputConfig;
     generatorConfig = {

package/src/js/pds.d.ts

@@ -174,6 +174,35 @@ export class PDS extends EventTarget {
   static isLiveMode: () => boolean;
   static findComponentForElement?: (el: Element) => ComponentDef | null;
   static presets?: Record<string, any>;
+  static configRelations?: Record<string, any>;
+  static configSpec?: Record<string, any> | null;
+  static configEditorMetadata?: Record<string, any>;
+  static configFormSchema?: {
+    schema: Record<string, any>;
+    uiSchema: Record<string, any>;
+    values: Record<string, any>;
+    metadata: Record<string, any>;
+  } | null;
+  static buildConfigFormSchema?: (designConfig?: Record<string, any>) => {
+    schema: Record<string, any>;
+    uiSchema: Record<string, any>;
+    values: Record<string, any>;
+    metadata: Record<string, any>;
+  };
+  static buildPresetOmniboxSettings?: (options?: {
+    hideCategory?: boolean;
+    includeIncompatible?: boolean;
+    disableIncompatible?: boolean;
+    categoryName?: string;
+    theme?: string | null;
+    onSelect?: (context: {
+      preset: Record<string, any>;
+      selection: Record<string, any>;
+      resolvedTheme: string;
+    }) => Promise<any> | any;
+    iconHandler?: (item: Record<string, any>) => string;
+  }) => Record<string, any>;
+  static getConfigEditorMetadata?: (designConfig?: Record<string, any>) => Record<string, any>;
   static enhancerMetadata?: Array<{ selector: string; description?: string; demoHtml?: string }>;
   static defaultEnhancers?: Array<any>;
   static ontology?: any;
@@ -328,6 +357,7 @@ export interface JsonFormOptions {
     icons?: boolean;
     datalists?: boolean;
     rangeOutput?: boolean;
+    colorInput?: boolean;
   };
   validation?: {
     showErrors?: boolean;

package/src/js/pds.js

@@ -62,24 +62,15 @@ import {
   ensureAbsoluteAssetURL,
   ensureTrailingSlash,
   attachFoucListener,
-  normalizeInitConfig,
   resolveRuntimeAssetRoot,
   resolveThemeAndApply,
   setupAutoDefinerAndEnhancers,
-  stripFunctions,
 } from "./pds-core/pds-start-helpers.js";
 import {
   isPresetThemeCompatible,
   resolveThemePreference,
 } from "./pds-core/pds-theme-utils.js";
 
-const __slugifyPreset = (str = "") =>
-  String(str)
-    .toLowerCase()
-    .replace(/&/g, " and ")
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "");
-
 const __defaultLog = function (level = "log", message, ...data) {
   const isStaticMode = Boolean(PDS.registry && !PDS.registry.isLive);
   const debug =
@@ -99,6 +90,27 @@ const __defaultLog = function (level = "log", message, ...data) {
   }
 };
 
+function __stripFunctionsForClone(value) {
+  if (value === null || value === undefined) return value;
+  if (typeof value === "function") return undefined;
+  if (typeof value !== "object") return value;
+
+  if (Array.isArray(value)) {
+    return value
+      .map((item) => __stripFunctionsForClone(item))
+      .filter((item) => item !== undefined);
+  }
+
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    const stripped = __stripFunctionsForClone(entry);
+    if (stripped !== undefined) {
+      result[key] = stripped;
+    }
+  }
+  return result;
+}
+
 async function __loadRuntimeConfig(assetRootURL, config = {}) {
   if (config?.runtimeConfig === false) return null;
   if (typeof fetch !== "function") return null;
@@ -435,57 +447,21 @@ async function staticInit(config) {
       setupSystemListenerIfNeeded: __setupSystemListenerIfNeeded,
     });
 
-    // Normalize first-arg to allow { preset, design, enhancers }
+    // Load runtime config for static assets; config metadata remains live-mode only
     const runtimeConfig = await __loadRuntimeConfig(assetRootURL, config);
-    const runtimeDesign =
-      runtimeConfig?.config?.design || runtimeConfig?.design || null;
-    const runtimePresetLabel =
-      runtimeConfig?.config?.preset || runtimeConfig?.preset || "default";
-    const runtimePresetId =
-      runtimeConfig?.presetId || __slugifyPreset(runtimePresetLabel) || "default";
-    const runtimePresets = runtimeDesign
-      ? {
-          [String(runtimePresetId).toLowerCase()]: runtimeDesign,
-          ...(String(runtimePresetId).toLowerCase() !== "default"
-            ? { default: runtimeDesign }
-            : {}),
-        }
-      : null;
-
-    const inlineDesign =
-      config?.design && typeof config.design === "object"
-        ? stripFunctions(config.design)
-        : null;
-    const inlinePresetId = __slugifyPreset(config?.preset || "default") || "default";
-    const inlinePresets = inlineDesign
-      ? {
-          [String(inlinePresetId).toLowerCase()]: inlineDesign,
-          ...(String(inlinePresetId).toLowerCase() !== "default"
-            ? { default: inlineDesign }
-            : {}),
-        }
-      : null;
-
-    const presets = runtimePresets || config?.presets || inlinePresets || {};
-    if (!Object.keys(presets || {}).length) {
-      throw new Error(
-        "PDS static mode requires preset data. Run pds:build or provide config.presets/config.design."
-      );
-    }
-    const normalizedInput = runtimeConfig?.config
+    const userEnhancers = Array.isArray(config?.enhancers)
+      ? config.enhancers
+      : config?.enhancers && typeof config.enhancers === "object"
+        ? Object.values(config.enhancers)
+        : [];
+    const resolvedConfig = runtimeConfig?.config
       ? {
           ...runtimeConfig.config,
           ...config,
-          preset: config?.preset || runtimePresetId,
-          design: inlineDesign || runtimeDesign || runtimeConfig?.config?.design,
+          design: config?.design || runtimeConfig.config.design,
+          preset: config?.preset || runtimeConfig.config.preset,
         }
-      : config;
-
-    const normalized = normalizeInitConfig(normalizedInput, {}, {
-      presets,
-      defaultLog: __defaultLog,
-    });
-    const userEnhancers = normalized.enhancers;
+      : { ...config };
     
 
     // 2) Derive static asset URLs from the normalized public root
@@ -545,12 +521,12 @@ async function staticInit(config) {
 
     // Expose current config as frozen read-only on PDS, preserving input shape
     // Strip functions before cloning to avoid DataCloneError
-    const cloneableConfig = stripFunctions(config);
+    const cloneableConfig = __stripFunctionsForClone(config);
     PDS.currentConfig = Object.freeze({
       mode: "static",
       ...structuredClone(cloneableConfig),
-      design: structuredClone(normalized.generatorConfig.design),
-      preset: normalized.generatorConfig.preset,
+      design: structuredClone(resolvedConfig.design || {}),
+      preset: resolvedConfig.preset,
       theme: resolvedTheme,
       enhancers: mergedEnhancers,
     });
@@ -558,12 +534,12 @@ async function staticInit(config) {
     // 6) Emit ready event (unified)
     __emitPDSReady({
       mode: "static",
-      config: normalized.generatorConfig,
+      config: resolvedConfig,
       theme: resolvedTheme,
       autoDefiner,
     });
     return {
-      config: normalized.generatorConfig,
+      config: resolvedConfig,
       theme: resolvedTheme,
       autoDefiner,
     };