@jigx/core-sdk 1.0.0

package/dist/component/jc.count-up.js

@@ -0,0 +1,42 @@
+import { toNumberOrExpression } from '../abstract/index.js';
+import { toCountUpLabels, toCountUpSize, } from './common/index.js';
+import { ComponentBaseBuilder } from './jc.abstract.js';
+import { COMPONENT_TYPE } from './jc.types.js';
+export class JcCountUpBuilder extends ComponentBaseBuilder {
+    constructor(options = {}) {
+        super(COMPONENT_TYPE.COUNT_UP, options);
+        this._config.startTimestamp = Date.now();
+        if (options.startTimestamp !== undefined) {
+            this._config.startTimestamp = toNumberOrExpression(options.startTimestamp);
+        }
+        if (options.size !== undefined) {
+            this._config.size = toCountUpSize(options.size);
+        }
+        if (options.labels !== undefined) {
+            this._config.labels = toCountUpLabels(options.labels);
+        }
+    }
+    startTimestamp(timestamp) {
+        this._config.startTimestamp = toNumberOrExpression(timestamp);
+        return this;
+    }
+    with(options) {
+        super.with(options);
+        if (options?.startTimestamp !== undefined) {
+            this._config.startTimestamp = toNumberOrExpression(options.startTimestamp);
+        }
+        if (options?.size !== undefined) {
+            this._config.size = toCountUpSize(options.size);
+        }
+        if (options?.labels !== undefined) {
+            this._config.labels = toCountUpLabels(options.labels);
+        }
+        return this;
+    }
+    _validate() {
+        if (this._config.startTimestamp === undefined || this._config.startTimestamp === null) {
+            throw new Error('Count-up startTimestamp is required');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/component/jc.custom-component.interop.d.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod/v4';
+import { type Primitive, type InstanceId, type Expression } from '../abstract/index.js';
+import { type JcBase, type JcAddToJig } from './jc.abstract.js';
+import { type ComponentType } from './jc.types.js';
+export type InteropValue = Primitive | InteropValue[] | {
+    [key: string]: InteropValue;
+};
+declare const CustomComponentSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"component.custom-component">;
+    componentId: z.ZodString;
+    instanceId: z.ZodOptional<z.ZodString>;
+    instanceScope: z.ZodOptional<z.ZodEnum<{
+        jig: "jig";
+        solution: "solution";
+    }>>;
+    when: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<InteropValue, unknown, z.core.$ZodTypeInternals<InteropValue, unknown>>>>;
+    actions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<InteropValue, unknown, z.core.$ZodTypeInternals<InteropValue, unknown>>>>;
+}, z.core.$loose>, z.ZodObject<{
+    type: z.ZodLiteral<"component.custom-component">;
+    instanceId: z.ZodOptional<z.ZodString>;
+    instanceScope: z.ZodOptional<z.ZodEnum<{
+        jig: "jig";
+        solution: "solution";
+    }>>;
+    when: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>;
+    options: z.ZodObject<{
+        children: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodType<InteropValue, unknown, z.core.$ZodTypeInternals<InteropValue, unknown>>>>;
+    }, z.core.$loose>;
+}, z.core.$loose>]>;
+export type JcCustomComponentInterop = z.infer<typeof CustomComponentSchema> & JcBase;
+export type JcCustomComponentInteropInput = {
+    json: JcCustomComponentInterop;
+} | {
+    yaml: string;
+} | {
+    file: string | URL;
+    relativeTo?: string | URL;
+};
+export declare class JcCustomComponentInteropBuilder implements JcAddToJig<JcCustomComponentInterop> {
+    protected readonly _draftJc: JcCustomComponentInterop;
+    constructor(input: JcCustomComponentInteropInput);
+    get type(): ComponentType;
+    when(jsonata: Expression): this;
+    _validate(): void;
+    build(): JcCustomComponentInterop;
+    static from(input: JcCustomComponentInteropInput): JcCustomComponentInteropBuilder;
+    static ref(options: {
+        componentId: string;
+        instanceId?: InstanceId;
+        instanceScope?: 'solution' | 'jig';
+        when?: string | boolean;
+        inputs?: Record<string, unknown>;
+        actions?: Record<string, unknown>;
+    }): JcCustomComponentInteropBuilder;
+}
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jc.custom-component.interop.d.ts","sourceRoot":"","sources":["../../src/component/jc.custom-component.interop.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAC1B,OAAO,EACL,KAAK,SAAS,EAEd,KAAK,UAAU,EACf,KAAK,UAAU,EAEhB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC/D,OAAO,EAAkB,KAAK,aAAa,EAAE,MAAM,eAAe,CAAA;AAGlE,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,YAAY,EAAE,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAAA;CAAE,CAAA;AA0CvF,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;mBAAmE,CAAA;AAE9F,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,GAAG,MAAM,CAAA;AASrF,MAAM,MAAM,6BAA6B,GACrC;IACE,IAAI,EAAE,wBAAwB,CAAA;CAC/B,GACD;IACE,IAAI,EAAE,MAAM,CAAA;CACb,GACD;IACE,IAAI,EAAE,MAAM,GAAG,GAAG,CAAA;IAClB,UAAU,CAAC,EAAE,MAAM,GAAG,GAAG,CAAA;CAC1B,CAAA;AAuFL,qBAAa,+BAAgC,YAAW,UAAU,CAAC,wBAAwB,CAAC;IAC1F,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,wBAAwB,CAAA;IAErD,YAAY,KAAK,EAAE,6BAA6B,EAE/C;IAED,IAAI,IAAI,IAAI,aAAa,CAExB;IAED,IAAI,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI,CAG9B;IAED,SAAS,IAAI,IAAI,CAEhB;IAED,KAAK,IAAI,wBAAwB,CAEhC;IAOD,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,6BAA6B,GAAG,+BAA+B,CAEjF;IAOD,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE;QAClB,WAAW,EAAE,MAAM,CAAA;QACnB,UAAU,CAAC,EAAE,UAAU,CAAA;QACvB,aAAa,CAAC,EAAE,UAAU,GAAG,KAAK,CAAA;QAClC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;QACvB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAChC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAClC,GAAG,+BAA+B,CAOlC;CACF","sourcesContent":["import fs from 'node:fs'\nimport path from 'node:path'\nimport { fileURLToPath, pathToFileURL } from 'node:url'\nimport { parse as parseYaml } from 'yaml'\nimport { z } from 'zod/v4'\nimport {\n  type Primitive,\n  PrimitiveSchema,\n  type InstanceId,\n  type Expression,\n  toExpression,\n} from '../abstract/index.js'\nimport { type JcBase, type JcAddToJig } from './jc.abstract.js'\nimport { COMPONENT_TYPE, type ComponentType } from './jc.types.js'\n\n/** Recursive value type for custom component inputs/actions (primitives, arrays, objects). */\nexport type InteropValue = Primitive | InteropValue[] | { [key: string]: InteropValue }\n\nconst InteropValueSchema: z.ZodType<InteropValue> = z.union([\n  PrimitiveSchema,\n  z.array(z.lazy(() => InteropValueSchema)),\n  z.record(\n    z.string(),\n    z.lazy(() => InteropValueSchema),\n  ),\n])\n\n// Reference form: componentId + optional inputs/actions.\n// Most common pattern — references a separately-defined custom component by ID.\nconst CustomComponentRefSchema = z\n  .object({\n    type: z.literal(COMPONENT_TYPE.CUSTOM_COMPONENT),\n    componentId: z.string().min(1),\n    instanceId: z.string().optional(),\n    instanceScope: z.enum(['solution', 'jig']).optional(),\n    when: z.union([z.string(), z.boolean()]).optional(),\n    inputs: z.record(z.string(), InteropValueSchema).optional(),\n    actions: z.record(z.string(), InteropValueSchema).optional(),\n  })\n  .loose()\n\n// Inline form: options.children array instead of componentId.\n// Less common — embeds child components directly.\nconst CustomComponentInlineSchema = z\n  .object({\n    type: z.literal(COMPONENT_TYPE.CUSTOM_COMPONENT),\n    instanceId: z.string().optional(),\n    instanceScope: z.enum(['solution', 'jig']).optional(),\n    when: z.union([z.string(), z.boolean()]).optional(),\n    options: z\n      .object({\n        children: z.array(z.record(z.string(), InteropValueSchema)).min(1),\n      })\n      .loose(),\n  })\n  .loose()\n\n// Discriminated union: ref form (has componentId) or inline form (has options.children).\nconst CustomComponentSchema = z.union([CustomComponentRefSchema, CustomComponentInlineSchema])\n\nexport type JcCustomComponentInterop = z.infer<typeof CustomComponentSchema> & JcBase\n\n/**\n * Accepted input forms for loading a custom component definition.\n * - `json`: Already-parsed object (validated immediately).\n * - `yaml`: Raw YAML string (parsed then validated).\n * - `file` + optional `relativeTo`: Path to a YAML/JSON file on disk.\n *   Pass `import.meta.url` as `relativeTo` for reliable resolution.\n */\nexport type JcCustomComponentInteropInput =\n  | {\n      json: JcCustomComponentInterop\n    }\n  | {\n      yaml: string\n    }\n  | {\n      file: string | URL\n      relativeTo?: string | URL\n    }\n\n/**\n * Resolve a file path (string or URL) into a file:// URL.\n * Handles absolute paths, relative paths, URL objects, and string URLs.\n * When `relativeTo` is a file path (not a directory), strips the filename\n * before resolving so callers can pass `__filename` or `import.meta.url`.\n */\nfunction toFileUrl(input: string | URL, relativeTo?: string | URL): URL {\n  if (input instanceof URL) {\n    return input\n  }\n\n  if (path.isAbsolute(input)) {\n    return pathToFileURL(input)\n  }\n\n  // Relative path requires a base to resolve against.\n  if (!relativeTo) {\n    throw new Error(\n      `Relative file path \"${input}\" requires \"relativeTo\" (pass import.meta.url for reliable resolution).`,\n    )\n  }\n\n  // URL base — let the URL constructor handle relative resolution.\n  if (relativeTo instanceof URL) {\n    return new URL(input, relativeTo)\n  }\n\n  // Callers may pass a file path (e.g. __filename) — detect and strip to dirname.\n  if (path.isAbsolute(relativeTo)) {\n    // Check if relativeTo points to a directory (returns undefined for non-existent paths).\n    const stat = fs.statSync(relativeTo, { throwIfNoEntry: false })\n\n    // If it's a directory, resolve directly against it.\n    // Otherwise treat it as a file path and strip to its parent directory.\n    const basePath = stat?.isDirectory() ? relativeTo : path.dirname(relativeTo)\n\n    // Join base + relative input, then convert to a file:// URL.\n    return pathToFileURL(path.resolve(basePath, input))\n  }\n\n  // String URL (e.g. \"file:///...\") — delegate to URL constructor.\n  return new URL(input, relativeTo)\n}\n\n/**\n * Load and validate a custom component definition from any input form.\n * Returns a Zod-validated config object ready to pass through as-is.\n */\nfunction loadInteropConfig(input: JcCustomComponentInteropInput): JcCustomComponentInterop {\n  let raw: unknown\n\n  if ('json' in input) {\n    raw = input.json\n  } else if ('yaml' in input) {\n    raw = parseYaml(input.yaml)\n  } else {\n    const url: URL = toFileUrl(input.file, input.relativeTo)\n    const filePath: string = fileURLToPath(url)\n\n    const ext: string = path.extname(filePath).toLowerCase()\n    if (ext !== '.json' && ext !== '.yaml' && ext !== '.jigx') {\n      throw new Error(`Unsupported custom component file extension \"${ext}\": ${filePath}`)\n    }\n\n    try {\n      const content: string = fs.readFileSync(filePath, 'utf8')\n      raw =\n        ext === '.json'\n          ? JSON.parse(content) // .json\n          : parseYaml(content) // .yaml or .jigx\n    } catch (cause) {\n      throw new Error(`Failed to parse custom component file: ${filePath}`, { cause })\n    }\n  }\n\n  return CustomComponentSchema.parse(raw)\n}\n\n/**\n * Compatibility-only bridge for deprecated custom components.\n *\n * Loads YAML/JSON, validates shape, then emits the payload unchanged.\n *\n * @deprecated Custom components are deprecated. Prefer native SDK components.\n */\nexport class JcCustomComponentInteropBuilder implements JcAddToJig<JcCustomComponentInterop> {\n  protected readonly _draftJc: JcCustomComponentInterop\n\n  constructor(input: JcCustomComponentInteropInput) {\n    this._draftJc = loadInteropConfig(input)\n  }\n\n  get type(): ComponentType {\n    return this._draftJc.type\n  }\n\n  when(jsonata: Expression): this {\n    this._draftJc.when = toExpression(jsonata)\n    return this\n  }\n\n  _validate(): void {\n    // No-op — kept for consistency with other builders\n  }\n\n  build(): JcCustomComponentInterop {\n    return this._draftJc\n  }\n\n  /**\n   * Build from a validated JSON/YAML source.\n   *\n   * @deprecated Custom components are deprecated. Prefer native SDK components.\n   */\n  static from(input: JcCustomComponentInteropInput): JcCustomComponentInteropBuilder {\n    return new JcCustomComponentInteropBuilder(input)\n  }\n\n  /**\n   * Build a reference-form custom component directly in code.\n   *\n   * @deprecated Custom components are deprecated. Prefer native SDK components.\n   */\n  static ref(options: {\n    componentId: string\n    instanceId?: InstanceId\n    instanceScope?: 'solution' | 'jig'\n    when?: string | boolean\n    inputs?: Record<string, unknown>\n    actions?: Record<string, unknown>\n  }): JcCustomComponentInteropBuilder {\n    return new JcCustomComponentInteropBuilder({\n      json: CustomComponentSchema.parse({\n        type: COMPONENT_TYPE.CUSTOM_COMPONENT,\n        ...options,\n      }),\n    })\n  }\n}\n"]}

package/dist/component/jc.custom-component.interop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jc.custom-component.interop.d.ts","sourceRoot":"","sources":["../../src/component/jc.custom-component.interop.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAC1B,OAAO,EACL,KAAK,SAAS,EAEd,KAAK,UAAU,EACf,KAAK,UAAU,EAEhB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC/D,OAAO,EAAkB,KAAK,aAAa,EAAE,MAAM,eAAe,CAAA;AAGlE,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,YAAY,EAAE,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAAA;CAAE,CAAA;AA0CvF,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;mBAAmE,CAAA;AAE9F,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,GAAG,MAAM,CAAA;AASrF,MAAM,MAAM,6BAA6B,GACrC;IACE,IAAI,EAAE,wBAAwB,CAAA;CAC/B,GACD;IACE,IAAI,EAAE,MAAM,CAAA;CACb,GACD;IACE,IAAI,EAAE,MAAM,GAAG,GAAG,CAAA;IAClB,UAAU,CAAC,EAAE,MAAM,GAAG,GAAG,CAAA;CAC1B,CAAA;AAuFL,qBAAa,+BAAgC,YAAW,UAAU,CAAC,wBAAwB,CAAC;IAC1F,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,wBAAwB,CAAA;IAErD,YAAY,KAAK,EAAE,6BAA6B,EAE/C;IAED,IAAI,IAAI,IAAI,aAAa,CAExB;IAED,IAAI,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI,CAG9B;IAED,SAAS,IAAI,IAAI,CAEhB;IAED,KAAK,IAAI,wBAAwB,CAEhC;IAOD,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,6BAA6B,GAAG,+BAA+B,CAEjF;IAOD,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE;QAClB,WAAW,EAAE,MAAM,CAAA;QACnB,UAAU,CAAC,EAAE,UAAU,CAAA;QACvB,aAAa,CAAC,EAAE,UAAU,GAAG,KAAK,CAAA;QAClC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;QACvB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAChC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAClC,GAAG,+BAA+B,CAOlC;CACF","sourcesContent":["import fs from 'node:fs'\nimport path from 'node:path'\nimport { fileURLToPath, pathToFileURL } from 'node:url'\nimport { parse as parseYaml } from 'yaml'\nimport { z } from 'zod/v4'\nimport {\n  type Primitive,\n  PrimitiveSchema,\n  type InstanceId,\n  type Expression,\n  toExpression,\n} from '../abstract/index.js'\nimport { type JcBase, type JcAddToJig } from './jc.abstract.js'\nimport { COMPONENT_TYPE, type ComponentType } from './jc.types.js'\n\n/** Recursive value type for custom component inputs/actions (primitives, arrays, objects). */\nexport type InteropValue = Primitive | InteropValue[] | { [key: string]: InteropValue }\n\nconst InteropValueSchema: z.ZodType<InteropValue> = z.union([\n  PrimitiveSchema,\n  z.array(z.lazy(() => InteropValueSchema)),\n  z.record(\n    z.string(),\n    z.lazy(() => InteropValueSchema),\n  ),\n])\n\n// Reference form: componentId + optional inputs/actions.\n// Most common pattern — references a separately-defined custom component by ID.\nconst CustomComponentRefSchema = z\n  .object({\n    type: z.literal(COMPONENT_TYPE.CUSTOM_COMPONENT),\n    componentId: z.string().min(1),\n    instanceId: z.string().optional(),\n    instanceScope: z.enum(['solution', 'jig']).optional(),\n    when: z.union([z.string(), z.boolean()]).optional(),\n    inputs: z.record(z.string(), InteropValueSchema).optional(),\n    actions: z.record(z.string(), InteropValueSchema).optional(),\n  })\n  .loose()\n\n// Inline form: options.children array instead of componentId.\n// Less common — embeds child components directly.\nconst CustomComponentInlineSchema = z\n  .object({\n    type: z.literal(COMPONENT_TYPE.CUSTOM_COMPONENT),\n    instanceId: z.string().optional(),\n    instanceScope: z.enum(['solution', 'jig']).optional(),\n    when: z.union([z.string(), z.boolean()]).optional(),\n    options: z\n      .object({\n        children: z.array(z.record(z.string(), InteropValueSchema)).min(1),\n      })\n      .loose(),\n  })\n  .loose()\n\n// Discriminated union: ref form (has componentId) or inline form (has options.children).\nconst CustomComponentSchema = z.union([CustomComponentRefSchema, CustomComponentInlineSchema])\n\nexport type JcCustomComponentInterop = z.infer<typeof CustomComponentSchema> & JcBase\n\n/**\n * Accepted input forms for loading a custom component definition.\n * - `json`: Already-parsed object (validated immediately).\n * - `yaml`: Raw YAML string (parsed then validated).\n * - `file` + optional `relativeTo`: Path to a YAML/JSON file on disk.\n *   Pass `import.meta.url` as `relativeTo` for reliable resolution.\n */\nexport type JcCustomComponentInteropInput =\n  | {\n      json: JcCustomComponentInterop\n    }\n  | {\n      yaml: string\n    }\n  | {\n      file: string | URL\n      relativeTo?: string | URL\n    }\n\n/**\n * Resolve a file path (string or URL) into a file:// URL.\n * Handles absolute paths, relative paths, URL objects, and string URLs.\n * When `relativeTo` is a file path (not a directory), strips the filename\n * before resolving so callers can pass `__filename` or `import.meta.url`.\n */\nfunction toFileUrl(input: string | URL, relativeTo?: string | URL): URL {\n  if (input instanceof URL) {\n    return input\n  }\n\n  if (path.isAbsolute(input)) {\n    return pathToFileURL(input)\n  }\n\n  // Relative path requires a base to resolve against.\n  if (!relativeTo) {\n    throw new Error(\n      `Relative file path \"${input}\" requires \"relativeTo\" (pass import.meta.url for reliable resolution).`,\n    )\n  }\n\n  // URL base — let the URL constructor handle relative resolution.\n  if (relativeTo instanceof URL) {\n    return new URL(input, relativeTo)\n  }\n\n  // Callers may pass a file path (e.g. __filename) — detect and strip to dirname.\n  if (path.isAbsolute(relativeTo)) {\n    // Check if relativeTo points to a directory (returns undefined for non-existent paths).\n    const stat = fs.statSync(relativeTo, { throwIfNoEntry: false })\n\n    // If it's a directory, resolve directly against it.\n    // Otherwise treat it as a file path and strip to its parent directory.\n    const basePath = stat?.isDirectory() ? relativeTo : path.dirname(relativeTo)\n\n    // Join base + relative input, then convert to a file:// URL.\n    return pathToFileURL(path.resolve(basePath, input))\n  }\n\n  // String URL (e.g. \"file:///...\") — delegate to URL constructor.\n  return new URL(input, relativeTo)\n}\n\n/**\n * Load and validate a custom component definition from any input form.\n * Returns a Zod-validated config object ready to pass through as-is.\n */\nfunction loadInteropConfig(input: JcCustomComponentInteropInput): JcCustomComponentInterop {\n  let raw: unknown\n\n  if ('json' in input) {\n    raw = input.json\n  } else if ('yaml' in input) {\n    raw = parseYaml(input.yaml)\n  } else {\n    const url: URL = toFileUrl(input.file, input.relativeTo)\n    const filePath: string = fileURLToPath(url)\n\n    const ext: string = path.extname(filePath).toLowerCase()\n    if (ext !== '.json' && ext !== '.yaml' && ext !== '.jigx') {\n      throw new Error(`Unsupported custom component file extension \"${ext}\": ${filePath}`)\n    }\n\n    try {\n      const content: string = fs.readFileSync(filePath, 'utf8')\n      raw =\n        ext === '.json'\n          ? JSON.parse(content) // .json\n          : parseYaml(content) // .yaml or .jigx\n    } catch (cause) {\n      throw new Error(`Failed to parse custom component file: ${filePath}`, { cause })\n    }\n  }\n\n  return CustomComponentSchema.parse(raw)\n}\n\n/**\n * Compatibility-only bridge for deprecated custom components.\n *\n * Loads YAML/JSON, validates shape, then emits the payload unchanged.\n *\n * @deprecated Custom components are deprecated. Prefer native SDK components.\n */\nexport class JcCustomComponentInteropBuilder implements JcAddToJig<JcCustomComponentInterop> {\n  protected readonly _draftJc: JcCustomComponentInterop\n\n  constructor(input: JcCustomComponentInteropInput) {\n    this._draftJc = loadInteropConfig(input)\n  }\n\n  get type(): ComponentType {\n    return this._draftJc.type\n  }\n\n  when(jsonata: Expression): this {\n    this._draftJc.when = toExpression(jsonata)\n    return this\n  }\n\n  _validate(): void {\n    // No-op — kept for consistency with other builders\n  }\n\n  build(): JcCustomComponentInterop {\n    return this._draftJc\n  }\n\n  /**\n   * Build from a validated JSON/YAML source.\n   *\n   * @deprecated Custom components are deprecated. Prefer native SDK components.\n   */\n  static from(input: JcCustomComponentInteropInput): JcCustomComponentInteropBuilder {\n    return new JcCustomComponentInteropBuilder(input)\n  }\n\n  /**\n   * Build a reference-form custom component directly in code.\n   *\n   * @deprecated Custom components are deprecated. Prefer native SDK components.\n   */\n  static ref(options: {\n    componentId: string\n    instanceId?: InstanceId\n    instanceScope?: 'solution' | 'jig'\n    when?: string | boolean\n    inputs?: Record<string, unknown>\n    actions?: Record<string, unknown>\n  }): JcCustomComponentInteropBuilder {\n    return new JcCustomComponentInteropBuilder({\n      json: CustomComponentSchema.parse({\n        type: COMPONENT_TYPE.CUSTOM_COMPONENT,\n        ...options,\n      }),\n    })\n  }\n}\n"]}

package/dist/component/jc.custom-component.interop.js

@@ -0,0 +1,115 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { parse as parseYaml } from 'yaml';
+import { z } from 'zod/v4';
+import { PrimitiveSchema, toExpression, } from '../abstract/index.js';
+import { COMPONENT_TYPE } from './jc.types.js';
+const InteropValueSchema = z.union([
+    PrimitiveSchema,
+    z.array(z.lazy(() => InteropValueSchema)),
+    z.record(z.string(), z.lazy(() => InteropValueSchema)),
+]);
+const CustomComponentRefSchema = z
+    .object({
+    type: z.literal(COMPONENT_TYPE.CUSTOM_COMPONENT),
+    componentId: z.string().min(1),
+    instanceId: z.string().optional(),
+    instanceScope: z.enum(['solution', 'jig']).optional(),
+    when: z.union([z.string(), z.boolean()]).optional(),
+    inputs: z.record(z.string(), InteropValueSchema).optional(),
+    actions: z.record(z.string(), InteropValueSchema).optional(),
+})
+    .loose();
+const CustomComponentInlineSchema = z
+    .object({
+    type: z.literal(COMPONENT_TYPE.CUSTOM_COMPONENT),
+    instanceId: z.string().optional(),
+    instanceScope: z.enum(['solution', 'jig']).optional(),
+    when: z.union([z.string(), z.boolean()]).optional(),
+    options: z
+        .object({
+        children: z.array(z.record(z.string(), InteropValueSchema)).min(1),
+    })
+        .loose(),
+})
+    .loose();
+const CustomComponentSchema = z.union([CustomComponentRefSchema, CustomComponentInlineSchema]);
+function toFileUrl(input, relativeTo) {
+    if (input instanceof URL) {
+        return input;
+    }
+    if (path.isAbsolute(input)) {
+        return pathToFileURL(input);
+    }
+    if (!relativeTo) {
+        throw new Error(`Relative file path "${input}" requires "relativeTo" (pass import.meta.url for reliable resolution).`);
+    }
+    if (relativeTo instanceof URL) {
+        return new URL(input, relativeTo);
+    }
+    if (path.isAbsolute(relativeTo)) {
+        const stat = fs.statSync(relativeTo, { throwIfNoEntry: false });
+        const basePath = stat?.isDirectory() ? relativeTo : path.dirname(relativeTo);
+        return pathToFileURL(path.resolve(basePath, input));
+    }
+    return new URL(input, relativeTo);
+}
+function loadInteropConfig(input) {
+    let raw;
+    if ('json' in input) {
+        raw = input.json;
+    }
+    else if ('yaml' in input) {
+        raw = parseYaml(input.yaml);
+    }
+    else {
+        const url = toFileUrl(input.file, input.relativeTo);
+        const filePath = fileURLToPath(url);
+        const ext = path.extname(filePath).toLowerCase();
+        if (ext !== '.json' && ext !== '.yaml' && ext !== '.jigx') {
+            throw new Error(`Unsupported custom component file extension "${ext}": ${filePath}`);
+        }
+        try {
+            const content = fs.readFileSync(filePath, 'utf8');
+            raw =
+                ext === '.json'
+                    ? JSON.parse(content)
+                    : parseYaml(content);
+        }
+        catch (cause) {
+            throw new Error(`Failed to parse custom component file: ${filePath}`, { cause });
+        }
+    }
+    return CustomComponentSchema.parse(raw);
+}
+export class JcCustomComponentInteropBuilder {
+    _draftJc;
+    constructor(input) {
+        this._draftJc = loadInteropConfig(input);
+    }
+    get type() {
+        return this._draftJc.type;
+    }
+    when(jsonata) {
+        this._draftJc.when = toExpression(jsonata);
+        return this;
+    }
+    _validate() {
+    }
+    build() {
+        return this._draftJc;
+    }
+    static from(input) {
+        return new JcCustomComponentInteropBuilder(input);
+    }
+    static ref(options) {
+        return new JcCustomComponentInteropBuilder({
+            json: CustomComponentSchema.parse({
+                type: COMPONENT_TYPE.CUSTOM_COMPONENT,
+                ...options,
+            }),
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jc.custom-component.interop.js","sourceRoot":"","sources":["../../src/component/jc.custom-component.interop.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from 'node:fs'\nimport path from 'node:path'\nimport { fileURLToPath, pathToFileURL } from 'node:url'\nimport { parse as parseYaml } from 'yaml'\nimport { z } from 'zod/v4'\nimport {\n  type Primitive,\n  PrimitiveSchema,\n  type InstanceId,\n  type Expression,\n  toExpression,\n} from '../abstract/index.js'\nimport { type JcBase, type JcAddToJig } from './jc.abstract.js'\nimport { COMPONENT_TYPE, type ComponentType } from './jc.types.js'\n\n/** Recursive value type for custom component inputs/actions (primitives, arrays, objects). */\nexport type InteropValue = Primitive | InteropValue[] | { [key: string]: InteropValue }\n\nconst InteropValueSchema: z.ZodType<InteropValue> = z.union([\n  PrimitiveSchema,\n  z.array(z.lazy(() => InteropValueSchema)),\n  z.record(\n    z.string(),\n    z.lazy(() => InteropValueSchema),\n  ),\n])\n\n// Reference form: componentId + optional inputs/actions.\n// Most common pattern — references a separately-defined custom component by ID.\nconst CustomComponentRefSchema = z\n  .object({\n    type: z.literal(COMPONENT_TYPE.CUSTOM_COMPONENT),\n    componentId: z.string().min(1),\n    instanceId: z.string().optional(),\n    instanceScope: z.enum(['solution', 'jig']).optional(),\n    when: z.union([z.string(), z.boolean()]).optional(),\n    inputs: z.record(z.string(), InteropValueSchema).optional(),\n    actions: z.record(z.string(), InteropValueSchema).optional(),\n  })\n  .loose()\n\n// Inline form: options.children array instead of componentId.\n// Less common — embeds child components directly.\nconst CustomComponentInlineSchema = z\n  .object({\n    type: z.literal(COMPONENT_TYPE.CUSTOM_COMPONENT),\n    instanceId: z.string().optional(),\n    instanceScope: z.enum(['solution', 'jig']).optional(),\n    when: z.union([z.string(), z.boolean()]).optional(),\n    options: z\n      .object({\n        children: z.array(z.record(z.string(), InteropValueSchema)).min(1),\n      })\n      .loose(),\n  })\n  .loose()\n\n// Discriminated union: ref form (has componentId) or inline form (has options.children).\nconst CustomComponentSchema = z.union([CustomComponentRefSchema, CustomComponentInlineSchema])\n\nexport type JcCustomComponentInterop = z.infer<typeof CustomComponentSchema> & JcBase\n\n/**\n * Accepted input forms for loading a custom component definition.\n * - `json`: Already-parsed object (validated immediately).\n * - `yaml`: Raw YAML string (parsed then validated).\n * - `file` + optional `relativeTo`: Path to a YAML/JSON file on disk.\n *   Pass `import.meta.url` as `relativeTo` for reliable resolution.\n */\nexport type JcCustomComponentInteropInput =\n  | {\n      json: JcCustomComponentInterop\n    }\n  | {\n      yaml: string\n    }\n  | {\n      file: string | URL\n      relativeTo?: string | URL\n    }\n\n/**\n * Resolve a file path (string or URL) into a file:// URL.\n * Handles absolute paths, relative paths, URL objects, and string URLs.\n * When `relativeTo` is a file path (not a directory), strips the filename\n * before resolving so callers can pass `__filename` or `import.meta.url`.\n */\nfunction toFileUrl(input: string | URL, relativeTo?: string | URL): URL {\n  if (input instanceof URL) {\n    return input\n  }\n\n  if (path.isAbsolute(input)) {\n    return pathToFileURL(input)\n  }\n\n  // Relative path requires a base to resolve against.\n  if (!relativeTo) {\n    throw new Error(\n      `Relative file path \"${input}\" requires \"relativeTo\" (pass import.meta.url for reliable resolution).`,\n    )\n  }\n\n  // URL base — let the URL constructor handle relative resolution.\n  if (relativeTo instanceof URL) {\n    return new URL(input, relativeTo)\n  }\n\n  // Callers may pass a file path (e.g. __filename) — detect and strip to dirname.\n  if (path.isAbsolute(relativeTo)) {\n    // Check if relativeTo points to a directory (returns undefined for non-existent paths).\n    const stat = fs.statSync(relativeTo, { throwIfNoEntry: false })\n\n    // If it's a directory, resolve directly against it.\n    // Otherwise treat it as a file path and strip to its parent directory.\n    const basePath = stat?.isDirectory() ? relativeTo : path.dirname(relativeTo)\n\n    // Join base + relative input, then convert to a file:// URL.\n    return pathToFileURL(path.resolve(basePath, input))\n  }\n\n  // String URL (e.g. \"file:///...\") — delegate to URL constructor.\n  return new URL(input, relativeTo)\n}\n\n/**\n * Load and validate a custom component definition from any input form.\n * Returns a Zod-validated config object ready to pass through as-is.\n */\nfunction loadInteropConfig(input: JcCustomComponentInteropInput): JcCustomComponentInterop {\n  let raw: unknown\n\n  if ('json' in input) {\n    raw = input.json\n  } else if ('yaml' in input) {\n    raw = parseYaml(input.yaml)\n  } else {\n    const url: URL = toFileUrl(input.file, input.relativeTo)\n    const filePath: string = fileURLToPath(url)\n\n    const ext: string = path.extname(filePath).toLowerCase()\n    if (ext !== '.json' && ext !== '.yaml' && ext !== '.jigx') {\n      throw new Error(`Unsupported custom component file extension \"${ext}\": ${filePath}`)\n    }\n\n    try {\n      const content: string = fs.readFileSync(filePath, 'utf8')\n      raw =\n        ext === '.json'\n          ? JSON.parse(content) // .json\n          : parseYaml(content) // .yaml or .jigx\n    } catch (cause) {\n      throw new Error(`Failed to parse custom component file: ${filePath}`, { cause })\n    }\n  }\n\n  return CustomComponentSchema.parse(raw)\n}\n\n/**\n * Compatibility-only bridge for deprecated custom components.\n *\n * Loads YAML/JSON, validates shape, then emits the payload unchanged.\n *\n * @deprecated Custom components are deprecated. Prefer native SDK components.\n */\nexport class JcCustomComponentInteropBuilder implements JcAddToJig<JcCustomComponentInterop> {\n  protected readonly _draftJc: JcCustomComponentInterop\n\n  constructor(input: JcCustomComponentInteropInput) {\n    this._draftJc = loadInteropConfig(input)\n  }\n\n  get type(): ComponentType {\n    return this._draftJc.type\n  }\n\n  when(jsonata: Expression): this {\n    this._draftJc.when = toExpression(jsonata)\n    return this\n  }\n\n  _validate(): void {\n    // No-op — kept for consistency with other builders\n  }\n\n  build(): JcCustomComponentInterop {\n    return this._draftJc\n  }\n\n  /**\n   * Build from a validated JSON/YAML source.\n   *\n   * @deprecated Custom components are deprecated. Prefer native SDK components.\n   */\n  static from(input: JcCustomComponentInteropInput): JcCustomComponentInteropBuilder {\n    return new JcCustomComponentInteropBuilder(input)\n  }\n\n  /**\n   * Build a reference-form custom component directly in code.\n   *\n   * @deprecated Custom components are deprecated. Prefer native SDK components.\n   */\n  static ref(options: {\n    componentId: string\n    instanceId?: InstanceId\n    instanceScope?: 'solution' | 'jig'\n    when?: string | boolean\n    inputs?: Record<string, unknown>\n    actions?: Record<string, unknown>\n  }): JcCustomComponentInteropBuilder {\n    return new JcCustomComponentInteropBuilder({\n      json: CustomComponentSchema.parse({\n        type: COMPONENT_TYPE.CUSTOM_COMPONENT,\n        ...options,\n      }),\n    })\n  }\n}\n"]}

package/dist/component/jc.date-picker.d.ts

@@ -0,0 +1,15 @@
+import { type Expression, type TextValue } from '../abstract/index.js';
+import { type DatePickerMode, JcFieldBaseBuilder, type JcFieldBaseInput } from './common/index.js';
+export interface JcDatePickerInput extends JcFieldBaseInput {
+    readonly value?: string | TextValue | Expression;
+    readonly initialValue?: string | TextValue | Expression;
+    readonly mode?: DatePickerMode;
+    readonly format?: string;
+    readonly minimum?: string | number | Expression;
+    readonly maximum?: string | number | Expression;
+}
+export declare class JcDatePickerBuilder extends JcFieldBaseBuilder<JcDatePickerInput> {
+    constructor(options: JcDatePickerInput);
+    with(options: Partial<Omit<JcDatePickerInput, 'instanceId'>>): this;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/component/jc.date-picker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jc.date-picker.d.ts","sourceRoot":"","sources":["../../src/component/jc.date-picker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAoB,MAAM,sBAAsB,CAAA;AACxF,OAAO,EAAE,KAAK,cAAc,EAAE,kBAAkB,EAAE,KAAK,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AAMlG,MAAM,WAAW,iBAAkB,SAAQ,gBAAgB;IAEzD,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,UAAU,CAAA;IAGhD,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,UAAU,CAAA;IAGvD,QAAQ,CAAC,IAAI,CAAC,EAAE,cAAc,CAAA;IAG9B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IAGxB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,UAAU,CAAA;IAG/C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,UAAU,CAAA;CAChD;AASD,qBAAa,mBAAoB,SAAQ,kBAAkB,CAAC,iBAAiB,CAAC;IAC5E,YAAY,OAAO,EAAE,iBAAiB,EAErC;IAEQ,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,iBAAiB,EAAE,YAAY,CAAC,CAAC,GAAG,IAAI,CAuB3E;CACF","sourcesContent":["import { type Expression, type TextValue, TextValueBuilder } from '../abstract/index.js'\nimport { type DatePickerMode, JcFieldBaseBuilder, type JcFieldBaseInput } from './common/index.js'\nimport { COMPONENT_TYPE } from './jc.types.js'\n\n/**\n * Date picker specific input interface extending base field.\n */\nexport interface JcDatePickerInput extends JcFieldBaseInput {\n  /** Selected date value */\n  readonly value?: string | TextValue | Expression\n\n  /** Initial date value */\n  readonly initialValue?: string | TextValue | Expression\n\n  /** Date picker mode: 'date', 'time', or 'datetime' */\n  readonly mode?: DatePickerMode\n\n  /** Date display format (e.g. 'MM/dd/yyyy') */\n  readonly format?: string\n\n  /** Minimum selectable date */\n  readonly minimum?: string | number | Expression\n\n  /** Maximum selectable date */\n  readonly maximum?: string | number | Expression\n}\n\n/**\n * Builds date picker fields for forms, with calendar selection and validation.\n * @alias component.date-picker\n *\n * Selects dates and times with calendar interface, validation,\n * min/max constraints, and custom formatting.\n */\nexport class JcDatePickerBuilder extends JcFieldBaseBuilder<JcDatePickerInput> {\n  constructor(options: JcDatePickerInput) {\n    super(COMPONENT_TYPE.DATE_PICKER, options)\n  }\n\n  override with(options: Partial<Omit<JcDatePickerInput, 'instanceId'>>): this {\n    super.with(options)\n\n    if (options.value !== undefined) {\n      this._config.value = TextValueBuilder.from(options.value)\n    }\n    if (options.initialValue !== undefined) {\n      this._config.initialValue = TextValueBuilder.from(options.initialValue)\n    }\n    if (options.mode !== undefined) {\n      this._config.mode = options.mode\n    }\n    if (options.format !== undefined) {\n      this._config.format = options.format\n    }\n    if (options.minimum !== undefined) {\n      this._config.minimum = options.minimum\n    }\n    if (options.maximum !== undefined) {\n      this._config.maximum = options.maximum\n    }\n\n    return this\n  }\n}\n"]}

package/dist/component/jc.date-picker.js

@@ -0,0 +1,31 @@
+import { TextValueBuilder } from '../abstract/index.js';
+import { JcFieldBaseBuilder } from './common/index.js';
+import { COMPONENT_TYPE } from './jc.types.js';
+export class JcDatePickerBuilder extends JcFieldBaseBuilder {
+    constructor(options) {
+        super(COMPONENT_TYPE.DATE_PICKER, options);
+    }
+    with(options) {
+        super.with(options);
+        if (options.value !== undefined) {
+            this._config.value = TextValueBuilder.from(options.value);
+        }
+        if (options.initialValue !== undefined) {
+            this._config.initialValue = TextValueBuilder.from(options.initialValue);
+        }
+        if (options.mode !== undefined) {
+            this._config.mode = options.mode;
+        }
+        if (options.format !== undefined) {
+            this._config.format = options.format;
+        }
+        if (options.minimum !== undefined) {
+            this._config.minimum = options.minimum;
+        }
+        if (options.maximum !== undefined) {
+            this._config.maximum = options.maximum;
+        }
+        return this;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/component/jc.divider.d.ts

@@ -0,0 +1,7 @@
+import { type JcBaseInput, ComponentBaseBuilder } from './jc.abstract.js';
+export interface JcDividerInput extends JcBaseInput {
+}
+export declare class JcDividerBuilder extends ComponentBaseBuilder<JcDividerInput> {
+    constructor(options?: JcDividerInput);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiamMuZGl2aWRlci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbXBvbmVudC9qYy5kaXZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLFdBQVcsRUFBRSxvQkFBb0IsRUFBRSxNQUFNLGtCQUFrQixDQUFBO0FBT3pFLE1BQU0sV0FBVyxjQUFlLFNBQVEsV0FBVztDQUVsRDtBQVNELHFCQUFhLGdCQUFpQixTQUFRLG9CQUFvQixDQUFDLGNBQWMsQ0FBQztJQUN4RSxZQUFZLE9BQU8sR0FBRSxjQUFtQixFQUV2QztDQUdGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgdHlwZSBKY0Jhc2VJbnB1dCwgQ29tcG9uZW50QmFzZUJ1aWxkZXIgfSBmcm9tICcuL2pjLmFic3RyYWN0LmpzJ1xuaW1wb3J0IHsgQ09NUE9ORU5UX1RZUEUgfSBmcm9tICcuL2pjLnR5cGVzLmpzJ1xuXG4vKipcbiAqIElucHV0IG9wdGlvbnMgZm9yIGRpdmlkZXIgY29tcG9uZW50LlxuICogRGl2aWRlciBpcyBhIHZpc3VhbCBzZXBhcmF0b3Igd2l0aCBubyBjb25maWd1cmF0aW9uIG9wdGlvbnMuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgSmNEaXZpZGVySW5wdXQgZXh0ZW5kcyBKY0Jhc2VJbnB1dCB7XG4gIC8vIERpdmlkZXIgaGFzIG5vIGFkZGl0aW9uYWwgb3B0aW9uc1xufVxuXG4vKipcbiAqIEJ1aWxkIGRpdmlkZXIgY29tcG9uZW50cy5cbiAqIEBhbGlhcyBjb21wb25lbnQuZGl2aWRlclxuICpcbiAqIFZpc3VhbCBicmVha3MgYmV0d2VlbiBzZWN0aW9ucy5cbiAqIFVzZSBiZXR3ZWVuIGZvcm0gc2VjdGlvbnMsIGxpc3QgZ3JvdXBzLCBjYXJkIGNvbnRlbnQuXG4gKi9cbmV4cG9ydCBjbGFzcyBKY0RpdmlkZXJCdWlsZGVyIGV4dGVuZHMgQ29tcG9uZW50QmFzZUJ1aWxkZXI8SmNEaXZpZGVySW5wdXQ+IHtcbiAgY29uc3RydWN0b3Iob3B0aW9uczogSmNEaXZpZGVySW5wdXQgPSB7fSkge1xuICAgIHN1cGVyKENPTVBPTkVOVF9UWVBFLkRJVklERVIsIG9wdGlvbnMpXG4gIH1cblxuICAvLyBObyBidWlsZCgpIG92ZXJyaWRlIC0gdXNlcyBwYXJlbnQncyBidWlsZFRyZWUoKVxufVxuIl19

package/dist/component/jc.divider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jc.divider.d.ts","sourceRoot":"","sources":["../../src/component/jc.divider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAOzE,MAAM,WAAW,cAAe,SAAQ,WAAW;CAElD;AASD,qBAAa,gBAAiB,SAAQ,oBAAoB,CAAC,cAAc,CAAC;IACxE,YAAY,OAAO,GAAE,cAAmB,EAEvC;CAGF","sourcesContent":["import { type JcBaseInput, ComponentBaseBuilder } from './jc.abstract.js'\nimport { COMPONENT_TYPE } from './jc.types.js'\n\n/**\n * Input options for divider component.\n * Divider is a visual separator with no configuration options.\n */\nexport interface JcDividerInput extends JcBaseInput {\n  // Divider has no additional options\n}\n\n/**\n * Build divider components.\n * @alias component.divider\n *\n * Visual breaks between sections.\n * Use between form sections, list groups, card content.\n */\nexport class JcDividerBuilder extends ComponentBaseBuilder<JcDividerInput> {\n  constructor(options: JcDividerInput = {}) {\n    super(COMPONENT_TYPE.DIVIDER, options)\n  }\n\n  // No build() override - uses parent's buildTree()\n}\n"]}

package/dist/component/jc.divider.js

@@ -0,0 +1,8 @@
+import { ComponentBaseBuilder } from './jc.abstract.js';
+import { COMPONENT_TYPE } from './jc.types.js';
+export class JcDividerBuilder extends ComponentBaseBuilder {
+    constructor(options = {}) {
+        super(COMPONENT_TYPE.DIVIDER, options);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiamMuZGl2aWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb21wb25lbnQvamMuZGl2aWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQW9CLG9CQUFvQixFQUFFLE1BQU0sa0JBQWtCLENBQUE7QUFDekUsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQTtBQWlCOUMsTUFBTSxPQUFPLGdCQUFpQixTQUFRLG9CQUFvQztJQUN4RSxZQUFZLE9BQU8sR0FBbUIsRUFBRSxFQUFFO1FBQ3hDLEtBQUssQ0FBQyxjQUFjLENBQUMsT0FBTyxFQUFFLE9BQU8sQ0FBQyxDQUFBO0lBQUEsQ0FDdkM7Q0FHRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHR5cGUgSmNCYXNlSW5wdXQsIENvbXBvbmVudEJhc2VCdWlsZGVyIH0gZnJvbSAnLi9qYy5hYnN0cmFjdC5qcydcbmltcG9ydCB7IENPTVBPTkVOVF9UWVBFIH0gZnJvbSAnLi9qYy50eXBlcy5qcydcblxuLyoqXG4gKiBJbnB1dCBvcHRpb25zIGZvciBkaXZpZGVyIGNvbXBvbmVudC5cbiAqIERpdmlkZXIgaXMgYSB2aXN1YWwgc2VwYXJhdG9yIHdpdGggbm8gY29uZmlndXJhdGlvbiBvcHRpb25zLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIEpjRGl2aWRlcklucHV0IGV4dGVuZHMgSmNCYXNlSW5wdXQge1xuICAvLyBEaXZpZGVyIGhhcyBubyBhZGRpdGlvbmFsIG9wdGlvbnNcbn1cblxuLyoqXG4gKiBCdWlsZCBkaXZpZGVyIGNvbXBvbmVudHMuXG4gKiBAYWxpYXMgY29tcG9uZW50LmRpdmlkZXJcbiAqXG4gKiBWaXN1YWwgYnJlYWtzIGJldHdlZW4gc2VjdGlvbnMuXG4gKiBVc2UgYmV0d2VlbiBmb3JtIHNlY3Rpb25zLCBsaXN0IGdyb3VwcywgY2FyZCBjb250ZW50LlxuICovXG5leHBvcnQgY2xhc3MgSmNEaXZpZGVyQnVpbGRlciBleHRlbmRzIENvbXBvbmVudEJhc2VCdWlsZGVyPEpjRGl2aWRlcklucHV0PiB7XG4gIGNvbnN0cnVjdG9yKG9wdGlvbnM6IEpjRGl2aWRlcklucHV0ID0ge30pIHtcbiAgICBzdXBlcihDT01QT05FTlRfVFlQRS5ESVZJREVSLCBvcHRpb25zKVxuICB9XG5cbiAgLy8gTm8gYnVpbGQoKSBvdmVycmlkZSAtIHVzZXMgcGFyZW50J3MgYnVpbGRUcmVlKClcbn1cbiJdfQ==

package/dist/component/jc.dropdown.d.ts

@@ -0,0 +1,20 @@
+import { type DatasourceId, type Expression } from '../abstract/index.js';
+import { JcFieldBaseBuilder, type JcFieldBaseInput } from './common/index.js';
+import { JcDropdownItemBuilder } from './jc.dropdown.item.js';
+export interface JcDropdownInput extends JcFieldBaseInput {
+    readonly data?: DatasourceId | Expression | {
+        datasourceId: string;
+    };
+    readonly initialValue?: string | number | boolean | Expression;
+    readonly value?: string | number | boolean | Expression;
+    readonly isMultiple?: boolean | Expression;
+    readonly isSearchable?: boolean | Expression;
+}
+export declare class JcDropdownBuilder extends JcFieldBaseBuilder<JcDropdownInput> {
+    constructor(options: JcDropdownInput);
+    with(options: Partial<Omit<JcDropdownInput, 'instanceId'>>): this;
+    readonly addControl: {
+        item: (options?: import("./jc.dropdown.item.js").JcDropdownItemInput | undefined) => JcDropdownItemBuilder;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/component/jc.dropdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jc.dropdown.d.ts","sourceRoot":"","sources":["../../src/component/jc.dropdown.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,UAAU,EAEhB,MAAM,sBAAsB,CAAA;AAE7B,OAAO,EAAE,kBAAkB,EAAE,KAAK,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AAC7E,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAA;AAI7D,MAAM,WAAW,eAAgB,SAAQ,gBAAgB;IAEvD,QAAQ,CAAC,IAAI,CAAC,EAAE,YAAY,GAAG,UAAU,GAAG;QAAE,YAAY,EAAE,MAAM,CAAA;KAAE,CAAA;IAGpE,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,UAAU,CAAA;IAG9D,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,UAAU,CAAA;IAGvD,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,GAAG,UAAU,CAAA;IAE1C,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,GAAG,UAAU,CAAA;CAC7C;AAMD,qBAAa,iBAAkB,SAAQ,kBAAkB,CAAC,eAAe,CAAC;IACxE,YAAY,OAAO,EAAE,eAAe,EAEnC;IAEQ,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,eAAe,EAAE,YAAY,CAAC,CAAC,GAAG,IAAI,CAoBzE;IAGD,QAAQ,CAAC,UAAU;;MAElB;CACF","sourcesContent":["import {\n  assignBuilderFactory,\n  type DatasourceId,\n  type Expression,\n  toBooleanOrExpression,\n} from '../abstract/index.js'\nimport { normalizeDatasource } from '../application/index.js'\nimport { JcFieldBaseBuilder, type JcFieldBaseInput } from './common/index.js'\nimport { JcDropdownItemBuilder } from './jc.dropdown.item.js'\nimport { COMPONENT_TYPE } from './jc.types.js'\n\n// Options include isDisabled for convenience (more intuitive as an option than style)\nexport interface JcDropdownInput extends JcFieldBaseInput {\n  /** Data source for choice items */\n  readonly data?: DatasourceId | Expression | { datasourceId: string }\n\n  /** Initial selected value(s) */\n  readonly initialValue?: string | number | boolean | Expression\n\n  /** Current selected value(s) */\n  readonly value?: string | number | boolean | Expression\n\n  /** Whether multiple selection is allowed */\n  readonly isMultiple?: boolean | Expression\n\n  readonly isSearchable?: boolean | Expression\n}\n\n/**\n * Builds dropdown fields for forms, with options, search, and validation.\n * @alias component.dropdown\n */\nexport class JcDropdownBuilder extends JcFieldBaseBuilder<JcDropdownInput> {\n  constructor(options: JcDropdownInput) {\n    super(COMPONENT_TYPE.DROPDOWN, options)\n  }\n\n  override with(options: Partial<Omit<JcDropdownInput, 'instanceId'>>): this {\n    super.with(options)\n\n    if (options.data !== undefined) {\n      this._config.data = normalizeDatasource(options.data)\n    }\n    if (options.initialValue !== undefined) {\n      this._config.initialValue = options.initialValue\n    }\n    if (options.value !== undefined) {\n      this._config.value = options.value\n    }\n    if (options.isMultiple !== undefined) {\n      this._config.isMultiple = toBooleanOrExpression(options.isMultiple)\n    }\n    if (options.isSearchable !== undefined) {\n      this._config.isSearchable = toBooleanOrExpression(options.isSearchable)\n    }\n\n    return this\n  }\n\n  /** Factory for adding dropdown field item */\n  readonly addControl = {\n    item: assignBuilderFactory(JcDropdownItemBuilder, this._config, 'item'),\n  }\n}\n"]}

package/dist/component/jc.dropdown.item.d.ts

@@ -0,0 +1,22 @@
+import { type Expression, type InstanceId, type TextValue, TextValueBuilder } from '../abstract/index.js';
+import { type LeftElementFactory } from './common/index.js';
+import { type JcBase, type JcBaseInput, ComponentBaseBuilder } from './jc.abstract.js';
+export interface JcDropdownItemInput extends JcBaseInput {
+    readonly instanceId?: InstanceId | Expression;
+    readonly title?: string | TextValue | TextValueBuilder;
+    readonly value?: string | Expression;
+    readonly subtitle?: string | TextValue | TextValueBuilder;
+    readonly description?: string | TextValue | TextValueBuilder;
+}
+export declare class JcDropdownItemBuilder extends ComponentBaseBuilder<JcDropdownItemInput> {
+    private _leftElement?;
+    readonly leftElement: Pick<LeftElementFactory, 'icon' | 'avatar' | 'image'>;
+    constructor(options?: JcDropdownItemInput);
+    with(options?: Partial<Omit<JcDropdownItemInput, 'instanceId'>>): this;
+    title(text: string | TextValue | TextValueBuilder): this;
+    value(value: string | Expression): this;
+    subtitle(text: string | TextValue | TextValueBuilder): this;
+    description(text: string | TextValue | TextValueBuilder): this;
+    build(): JcBase;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/component/jc.dropdown.item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jc.dropdown.item.d.ts","sourceRoot":"","sources":["../../src/component/jc.dropdown.item.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,SAAS,EACd,gBAAgB,EAEjB,MAAM,sBAAsB,CAAA;AAE7B,OAAO,EAOL,KAAK,kBAAkB,EACxB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,WAAW,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAMtF,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IAEtD,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,GAAG,UAAU,CAAA;IAE7C,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,gBAAgB,CAAA;IAEtD,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IAEpC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,gBAAgB,CAAA;IAEzD,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,gBAAgB,CAAA;CAC7D;AAMD,qBAAa,qBAAsB,SAAQ,oBAAoB,CAAC,mBAAmB,CAAC;IAClF,OAAO,CAAC,YAAY,CAAC,CAAiE;IAGtF,QAAQ,CAAC,WAAW,EAAE,IAAI,CAAC,kBAAkB,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC,CAmB1E;IAED,YAAY,OAAO,GAAE,mBAAwB,EAS5C;IAEQ,IAAI,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,mBAAmB,EAAE,YAAY,CAAC,CAAC,GAAG,IAAI,CAiC9E;IAGD,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,gBAAgB,GAAG,IAAI,CAEvD;IAGD,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAEtC;IAGD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,gBAAgB,GAAG,IAAI,CAE1D;IAGD,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,gBAAgB,GAAG,IAAI,CAE7D;IAEQ,KAAK,IAAI,MAAM,CASvB;CACF","sourcesContent":["import {\n  type Expression,\n  type InstanceId,\n  type TextValue,\n  TextValueBuilder,\n  toExpression,\n} from '../abstract/index.js'\nimport { type IconName } from '../icon/index.js'\nimport {\n  AvatarElementBuilder,\n  type AvatarElementInput,\n  IconElementBuilder,\n  type ImageElementInput,\n  ImageElementBuilder,\n  type JcIconElementOptions,\n  type LeftElementFactory,\n} from './common/index.js'\nimport { type JcBase, type JcBaseInput, ComponentBaseBuilder } from './jc.abstract.js'\nimport { COMPONENT_TYPE } from './jc.types.js'\n\n/**\n * Input options for dropdown item.\n */\nexport interface JcDropdownItemInput extends JcBaseInput {\n  /** Unique component identifier */\n  readonly instanceId?: InstanceId | Expression\n  /** Display title */\n  readonly title?: string | TextValue | TextValueBuilder\n  /** Unique value (expression or static string) */\n  readonly value?: string | Expression\n  /** Secondary text below title */\n  readonly subtitle?: string | TextValue | TextValueBuilder\n  /** Additional description text */\n  readonly description?: string | TextValue | TextValueBuilder\n}\n\n/**\n * Builds dropdown items with title, value, and optional left elements.\n * @alias component.dropdown-item\n */\nexport class JcDropdownItemBuilder extends ComponentBaseBuilder<JcDropdownItemInput> {\n  private _leftElement?: IconElementBuilder | AvatarElementBuilder | ImageElementBuilder\n\n  /** Create left element (icon, avatar, image). */\n  readonly leftElement: Pick<LeftElementFactory, 'icon' | 'avatar' | 'image'> = {\n    /** Create icon. */\n    icon: (name: IconName | Expression, options?: JcIconElementOptions) => {\n      const builder = new IconElementBuilder(name, options)\n      this._leftElement = builder\n      return builder\n    },\n    /** Create avatar. */\n    avatar: (options?: AvatarElementInput) => {\n      const builder = new AvatarElementBuilder(options)\n      this._leftElement = builder\n      return builder\n    },\n    /** Create image. */\n    image: (options?: ImageElementInput) => {\n      const builder = new ImageElementBuilder(options)\n      this._leftElement = builder\n      return builder\n    },\n  }\n\n  constructor(options: JcDropdownItemInput = {}) {\n    super(COMPONENT_TYPE.DROPDOWN_ITEM, options)\n\n    // Set defaults\n    this._config.title = ''\n    this._config.value = toExpression('=\"\"')\n\n    // Apply options\n    this.with(options)\n  }\n\n  override with(options?: Partial<Omit<JcDropdownItemInput, 'instanceId'>>): this {\n    super.with(options)\n\n    if (options?.title !== undefined) {\n      let title = options.title\n      if (typeof title === 'string' && title.startsWith('=')) {\n        title = toExpression(title)\n      }\n      this._config.title = TextValueBuilder.from(title)\n    }\n    if (options?.value !== undefined) {\n      const value = options.value\n      this._config.value =\n        typeof value === 'string' && value.startsWith('=')\n          ? toExpression(value)\n          : toExpression(`=\"${value}\"`)\n    }\n    if (options?.subtitle !== undefined) {\n      let subtitle = options.subtitle\n      if (typeof subtitle === 'string' && subtitle.startsWith('=')) {\n        subtitle = toExpression(subtitle)\n      }\n      this._config.subtitle = TextValueBuilder.from(subtitle)\n    }\n    if (options?.description !== undefined) {\n      let description = options.description\n      if (typeof description === 'string' && description.startsWith('=')) {\n        description = toExpression(description)\n      }\n      this._config.description = TextValueBuilder.from(description)\n    }\n\n    return this\n  }\n\n  /** Sets dropdown item title. */\n  title(text: string | TextValue | TextValueBuilder): this {\n    return this.with({ title: text })\n  }\n\n  /** Sets dropdown item value. */\n  value(value: string | Expression): this {\n    return this.with({ value })\n  }\n\n  /** Sets dropdown item subtitle. */\n  subtitle(text: string | TextValue | TextValueBuilder): this {\n    return this.with({ subtitle: text })\n  }\n\n  /** Sets dropdown item description. */\n  description(text: string | TextValue | TextValueBuilder): this {\n    return this.with({ description: text })\n  }\n\n  override build(): JcBase {\n    const base = super.build()\n    return {\n      ...base,\n      options: {\n        ...base.options,\n        leftElement: this._leftElement?.build(),\n      },\n    }\n  }\n}\n"]}

package/dist/component/jc.dropdown.item.js

@@ -0,0 +1,85 @@
+import { TextValueBuilder, toExpression, } from '../abstract/index.js';
+import { AvatarElementBuilder, IconElementBuilder, ImageElementBuilder, } from './common/index.js';
+import { ComponentBaseBuilder } from './jc.abstract.js';
+import { COMPONENT_TYPE } from './jc.types.js';
+export class JcDropdownItemBuilder extends ComponentBaseBuilder {
+    _leftElement;
+    leftElement = {
+        icon: (name, options) => {
+            const builder = new IconElementBuilder(name, options);
+            this._leftElement = builder;
+            return builder;
+        },
+        avatar: (options) => {
+            const builder = new AvatarElementBuilder(options);
+            this._leftElement = builder;
+            return builder;
+        },
+        image: (options) => {
+            const builder = new ImageElementBuilder(options);
+            this._leftElement = builder;
+            return builder;
+        },
+    };
+    constructor(options = {}) {
+        super(COMPONENT_TYPE.DROPDOWN_ITEM, options);
+        this._config.title = '';
+        this._config.value = toExpression('=""');
+        this.with(options);
+    }
+    with(options) {
+        super.with(options);
+        if (options?.title !== undefined) {
+            let title = options.title;
+            if (typeof title === 'string' && title.startsWith('=')) {
+                title = toExpression(title);
+            }
+            this._config.title = TextValueBuilder.from(title);
+        }
+        if (options?.value !== undefined) {
+            const value = options.value;
+            this._config.value =
+                typeof value === 'string' && value.startsWith('=')
+                    ? toExpression(value)
+                    : toExpression(`="${value}"`);
+        }
+        if (options?.subtitle !== undefined) {
+            let subtitle = options.subtitle;
+            if (typeof subtitle === 'string' && subtitle.startsWith('=')) {
+                subtitle = toExpression(subtitle);
+            }
+            this._config.subtitle = TextValueBuilder.from(subtitle);
+        }
+        if (options?.description !== undefined) {
+            let description = options.description;
+            if (typeof description === 'string' && description.startsWith('=')) {
+                description = toExpression(description);
+            }
+            this._config.description = TextValueBuilder.from(description);
+        }
+        return this;
+    }
+    title(text) {
+        return this.with({ title: text });
+    }
+    value(value) {
+        return this.with({ value });
+    }
+    subtitle(text) {
+        return this.with({ subtitle: text });
+    }
+    description(text) {
+        return this.with({ description: text });
+    }
+    build() {
+        const base = super.build();
+        return {
+            ...base,
+            options: {
+                ...base.options,
+                leftElement: this._leftElement?.build(),
+            },
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jc.dropdown.item.js","sourceRoot":"","sources":["../../src/component/jc.dropdown.item.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  type Expression,\n  type InstanceId,\n  type TextValue,\n  TextValueBuilder,\n  toExpression,\n} from '../abstract/index.js'\nimport { type IconName } from '../icon/index.js'\nimport {\n  AvatarElementBuilder,\n  type AvatarElementInput,\n  IconElementBuilder,\n  type ImageElementInput,\n  ImageElementBuilder,\n  type JcIconElementOptions,\n  type LeftElementFactory,\n} from './common/index.js'\nimport { type JcBase, type JcBaseInput, ComponentBaseBuilder } from './jc.abstract.js'\nimport { COMPONENT_TYPE } from './jc.types.js'\n\n/**\n * Input options for dropdown item.\n */\nexport interface JcDropdownItemInput extends JcBaseInput {\n  /** Unique component identifier */\n  readonly instanceId?: InstanceId | Expression\n  /** Display title */\n  readonly title?: string | TextValue | TextValueBuilder\n  /** Unique value (expression or static string) */\n  readonly value?: string | Expression\n  /** Secondary text below title */\n  readonly subtitle?: string | TextValue | TextValueBuilder\n  /** Additional description text */\n  readonly description?: string | TextValue | TextValueBuilder\n}\n\n/**\n * Builds dropdown items with title, value, and optional left elements.\n * @alias component.dropdown-item\n */\nexport class JcDropdownItemBuilder extends ComponentBaseBuilder<JcDropdownItemInput> {\n  private _leftElement?: IconElementBuilder | AvatarElementBuilder | ImageElementBuilder\n\n  /** Create left element (icon, avatar, image). */\n  readonly leftElement: Pick<LeftElementFactory, 'icon' | 'avatar' | 'image'> = {\n    /** Create icon. */\n    icon: (name: IconName | Expression, options?: JcIconElementOptions) => {\n      const builder = new IconElementBuilder(name, options)\n      this._leftElement = builder\n      return builder\n    },\n    /** Create avatar. */\n    avatar: (options?: AvatarElementInput) => {\n      const builder = new AvatarElementBuilder(options)\n      this._leftElement = builder\n      return builder\n    },\n    /** Create image. */\n    image: (options?: ImageElementInput) => {\n      const builder = new ImageElementBuilder(options)\n      this._leftElement = builder\n      return builder\n    },\n  }\n\n  constructor(options: JcDropdownItemInput = {}) {\n    super(COMPONENT_TYPE.DROPDOWN_ITEM, options)\n\n    // Set defaults\n    this._config.title = ''\n    this._config.value = toExpression('=\"\"')\n\n    // Apply options\n    this.with(options)\n  }\n\n  override with(options?: Partial<Omit<JcDropdownItemInput, 'instanceId'>>): this {\n    super.with(options)\n\n    if (options?.title !== undefined) {\n      let title = options.title\n      if (typeof title === 'string' && title.startsWith('=')) {\n        title = toExpression(title)\n      }\n      this._config.title = TextValueBuilder.from(title)\n    }\n    if (options?.value !== undefined) {\n      const value = options.value\n      this._config.value =\n        typeof value === 'string' && value.startsWith('=')\n          ? toExpression(value)\n          : toExpression(`=\"${value}\"`)\n    }\n    if (options?.subtitle !== undefined) {\n      let subtitle = options.subtitle\n      if (typeof subtitle === 'string' && subtitle.startsWith('=')) {\n        subtitle = toExpression(subtitle)\n      }\n      this._config.subtitle = TextValueBuilder.from(subtitle)\n    }\n    if (options?.description !== undefined) {\n      let description = options.description\n      if (typeof description === 'string' && description.startsWith('=')) {\n        description = toExpression(description)\n      }\n      this._config.description = TextValueBuilder.from(description)\n    }\n\n    return this\n  }\n\n  /** Sets dropdown item title. */\n  title(text: string | TextValue | TextValueBuilder): this {\n    return this.with({ title: text })\n  }\n\n  /** Sets dropdown item value. */\n  value(value: string | Expression): this {\n    return this.with({ value })\n  }\n\n  /** Sets dropdown item subtitle. */\n  subtitle(text: string | TextValue | TextValueBuilder): this {\n    return this.with({ subtitle: text })\n  }\n\n  /** Sets dropdown item description. */\n  description(text: string | TextValue | TextValueBuilder): this {\n    return this.with({ description: text })\n  }\n\n  override build(): JcBase {\n    const base = super.build()\n    return {\n      ...base,\n      options: {\n        ...base.options,\n        leftElement: this._leftElement?.build(),\n      },\n    }\n  }\n}\n"]}