@jigx/core-sdk 1.0.0

package/dist/component/jc.list-item.js

@@ -0,0 +1,274 @@
+import { TextValueBuilder, TextValueWithStyleBuilder, toBooleanOrExpression, toColorValue, toColorValueOrConditions, toExpression, toInstanceId, toNumberOrExpression, toTextValue, } from '../abstract/index.js';
+import { JaInBackgroundFactoryOne, SwipeableActionBuilder, } from '../action/index.js';
+import { AvatarElementBuilder, BadgeElementBuilder, ButtonElementBuilder, CheckboxElementBuilder, IconElementBuilder, ImageElementBuilder, ProgressElementBuilder, SwitchElementBuilder, ValueElementBuilder, } from './common/index.js';
+import { ComponentBaseBuilder } from './jc.abstract.js';
+import { AmountControlBuilder } from './jc.product-item.amount.js';
+import { COMPONENT_TYPE } from './jc.types.js';
+import { z } from 'zod/v4';
+export const JcListItemDividerSchema = z.enum(['none', 'solid', 'transparent']);
+export class JcListItemBuilder extends ComponentBaseBuilder {
+    _leftElement;
+    _rightElement;
+    state;
+    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;
+        },
+        progress: (options) => {
+            const builder = new ProgressElementBuilder(options);
+            this._leftElement = builder;
+            return builder;
+        },
+        checkbox: (options) => {
+            const builder = new CheckboxElementBuilder(options);
+            this._leftElement = builder;
+            return builder;
+        },
+    };
+    rightElement = {
+        amount: (options) => {
+            const builder = new AmountControlBuilder(options);
+            this._rightElement = builder;
+            return builder;
+        },
+        badge: (options) => {
+            const builder = new BadgeElementBuilder(options);
+            this._rightElement = builder;
+            return builder;
+        },
+        button: (options) => {
+            const builder = new ButtonElementBuilder(options);
+            this._rightElement = builder;
+            return builder;
+        },
+        icon: (name, options) => {
+            const builder = new IconElementBuilder(name, options);
+            this._rightElement = builder;
+            return builder;
+        },
+        switch: (options) => {
+            const builder = new SwitchElementBuilder(options);
+            this._rightElement = builder;
+            return builder;
+        },
+        value: (options) => {
+            const builder = new ValueElementBuilder(options);
+            this._rightElement = builder;
+            return builder;
+        },
+        checkbox: (options) => {
+            const builder = new CheckboxElementBuilder(options);
+            this._rightElement = builder;
+            return builder;
+        },
+    };
+    onPress = JaInBackgroundFactoryOne.one();
+    swipeLeft = () => {
+        const builder = new SwipeableActionBuilder();
+        if (!this._swipeableActions) {
+            this._swipeableActions = { left: [], right: [] };
+        }
+        this._swipeableActions.left.push(builder);
+        return builder;
+    };
+    swipeRight = () => {
+        const builder = new SwipeableActionBuilder();
+        if (!this._swipeableActions) {
+            this._swipeableActions = { left: [], right: [] };
+        }
+        this._swipeableActions.right.push(builder);
+        return builder;
+    };
+    _swipeableActions;
+    constructor(options = {}) {
+        super(COMPONENT_TYPE.LIST_ITEM, options);
+        const instanceId = options.instanceId ? toInstanceId(options.instanceId) : undefined;
+        this.state = {
+            amountControl: instanceId ? `@ctx.components.${instanceId}.state.amount` : '',
+            checked: instanceId ? `@ctx.components.${instanceId}.state.checked` : '',
+        };
+        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 = TextValueWithStyleBuilder.from(title);
+        }
+        if (options?.subtitle !== undefined) {
+            let subtitle = options.subtitle;
+            if (typeof subtitle === 'string' && subtitle.startsWith('=')) {
+                subtitle = toExpression(subtitle);
+            }
+            this._config.subtitle = TextValueWithStyleBuilder.from(subtitle);
+        }
+        if (options?.description !== undefined) {
+            let description = options.description;
+            if (typeof description === 'string' && description.startsWith('=')) {
+                description = toExpression(description);
+            }
+            this._config.description = TextValueWithStyleBuilder.from(description);
+        }
+        if (options?.divider !== undefined) {
+            this._config.divider = options.divider;
+        }
+        if (options?.value !== undefined) {
+            this._config.value = toExpression(options.value);
+        }
+        if (options?.numberOfLines !== undefined) {
+            const lines = options.numberOfLines;
+            if (typeof lines === 'number' && lines < 1) {
+                this._config.numberOfLines = 'dynamic';
+            }
+            else if (lines === 'dynamic') {
+                this._config.numberOfLines = 'dynamic';
+            }
+            else {
+                this._config.numberOfLines = toNumberOrExpression(lines);
+            }
+        }
+        if (options?.isContained !== undefined) {
+            this._config.isContained = options.isContained;
+        }
+        if (options?.isDisabled !== undefined) {
+            const style = this._config.style ?? {};
+            style.isDisabled = toBooleanOrExpression(options.isDisabled);
+            this._config.style = style;
+        }
+        if (options?.isStrikeThrough !== undefined) {
+            const style = this._config.style ?? {};
+            style.isStrikeThrough = toBooleanOrExpression(options.isStrikeThrough);
+            this._config.style = style;
+        }
+        if (options?.color !== undefined) {
+            this._config.color = options.color;
+        }
+        if (options?.progress !== undefined) {
+            this._config.progress = toNumberOrExpression(options.progress);
+        }
+        if (options?.rating !== undefined) {
+            this._config.rating = toNumberOrExpression(options.rating);
+        }
+        if (options?.avatars !== undefined) {
+            this._config.avatars = options.avatars;
+        }
+        if (options?.horizontalItemSize !== undefined) {
+            this._config.horizontalItemSize = toNumberOrExpression(options.horizontalItemSize);
+        }
+        return this;
+    }
+    title(text) {
+        return this.with({ title: text });
+    }
+    subtitle(text) {
+        return this.with({ subtitle: text });
+    }
+    description(text) {
+        return this.with({ description: text });
+    }
+    divider(opt) {
+        return this.with({ divider: opt });
+    }
+    value(value) {
+        return this.with({ value });
+    }
+    label(title, options) {
+        this._config.label = {
+            title: TextValueBuilder.from(title),
+            color: options?.color ? toColorValueOrConditions(options.color) : undefined,
+            isHidden: options?.isHidden !== undefined ? toBooleanOrExpression(options.isHidden) : undefined,
+        };
+        return this;
+    }
+    numberOfLines(lines) {
+        return this.with({ numberOfLines: lines });
+    }
+    isContained(isContained = true) {
+        return this.with({ isContained });
+    }
+    isDisabled(isDisabled) {
+        return this.with({ isDisabled });
+    }
+    style(style) {
+        const existing = this._config.style ?? {};
+        this._config.style = { ...existing, ...style };
+        return this;
+    }
+    isStrikeThrough(isStrikeThrough) {
+        const style = this._config.style ?? {};
+        style.isStrikeThrough = toBooleanOrExpression(isStrikeThrough);
+        this._config.style = style;
+        return this;
+    }
+    color(color) {
+        return this.with({ color });
+    }
+    progress(progress) {
+        return this.with({ progress });
+    }
+    rating(rating) {
+        return this.with({ rating });
+    }
+    avatars(avatars) {
+        return this.with({ avatars });
+    }
+    tags(tags) {
+        this._config.tags = toExpression(tags);
+        return this;
+    }
+    addTag(tag) {
+        const tags = this._config.tags ?? [];
+        tags.push({
+            text: toTextValue(tag.text),
+            color: tag.color ? toColorValue(tag.color) : undefined,
+        });
+        this._config.tags = tags;
+        return this;
+    }
+    horizontalItemSize(size) {
+        return this.with({ horizontalItemSize: size });
+    }
+    build() {
+        const base = super.build();
+        const onPress = this.onPress.build();
+        const left = this._swipeableActions?.left.length
+            ? this._swipeableActions.left.map((x) => x.build())
+            : undefined;
+        const right = this._swipeableActions?.right.length
+            ? this._swipeableActions.right.map((x) => x.build())
+            : undefined;
+        let swipeable;
+        if (left || right) {
+            swipeable = {
+                left: left,
+                right: right,
+            };
+        }
+        return {
+            ...base,
+            options: {
+                ...base.options,
+                leftElement: this._leftElement?.build(),
+                rightElement: this._rightElement?.build(),
+                onPress,
+                swipeable,
+            },
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jc.list-item.js","sourceRoot":"","sources":["../../src/component/jc.list-item.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  type BooleanOrExpression,\n  type ColorValue,\n  type ColorValueOrConditions,\n  type Expression,\n  type InstanceId,\n  type TextValue,\n  TextValueBuilder,\n  type TextValueWithStyle,\n  TextValueWithStyleBuilder,\n  toBooleanOrExpression,\n  toColorValue,\n  toColorValueOrConditions,\n  toExpression,\n  toInstanceId,\n  toNumberOrExpression,\n  toTextValue,\n} from '../abstract/index.js'\nimport {\n  type JaInBackground,\n  JaInBackgroundFactoryOne,\n  type JaSwipeableAction,\n  SwipeableActionBuilder,\n} from '../action/index.js'\nimport {\n  AvatarElementBuilder,\n  type AvatarElementInput,\n  BadgeElementBuilder,\n  type BadgeElementInput,\n  type ButtonElementInput,\n  ButtonElementBuilder,\n  CheckboxElementBuilder,\n  type CheckboxElementInput,\n  IconElementBuilder,\n  type ImageElementInput,\n  ImageElementBuilder,\n  type JcIconElementOptions,\n  type LeftElementBuilders,\n  ProgressElementBuilder,\n  type ProgressElementInput,\n  type RightElementBuilders,\n  type SwitchElementInput,\n  SwitchElementBuilder,\n  ValueElementBuilder,\n  type ValueElementInput,\n} from './common/index.js'\nimport { type JcBase, type JcBaseInput, ComponentBaseBuilder } from './jc.abstract.js'\nimport { type AmountControlInput, AmountControlBuilder } from './jc.product-item.amount.js'\nimport { COMPONENT_TYPE } from './jc.types.js'\nimport { z } from 'zod/v4'\n\n/**\n * Avatar configuration for list item avatars array.\n * @see #/definitions/AvatarItemConfig\n */\ninterface AvatarItemConfig {\n  /** Avatar text/initials */\n  readonly text?: TextValue\n  /** Avatar image URL */\n  readonly uri?: string | Expression\n}\n\ninterface TagBadge {\n  readonly text: TextValue\n  readonly color?: ColorValue\n}\n\nexport const JcListItemDividerSchema = z.enum(['none', 'solid', 'transparent'])\nexport type JcListItemDividerValue = z.infer<typeof JcListItemDividerSchema>\n\n/** Visual state modifiers for list items. */\nexport interface JcListItemStyle {\n  /** Grays out item */\n  isDisabled?: BooleanOrExpression\n  /** Red error state */\n  isError?: BooleanOrExpression\n  /** Orange warning state */\n  isWarning?: BooleanOrExpression\n  /** Green success state */\n  isPositive?: BooleanOrExpression\n  /** Strikethrough text */\n  isStrikeThrough?: BooleanOrExpression\n  /** Highlight background */\n  isHighlighted?: BooleanOrExpression\n  /** Sync pending indicator */\n  isWaitingSync?: BooleanOrExpression\n  /** Loading state */\n  isWaiting?: BooleanOrExpression\n}\n\n/** Swipe gesture actions for list items. */\nexport interface JcListItemSwipeable {\n  /** Left swipe actions */\n  left?: JaSwipeableAction[]\n  /** Right swipe actions */\n  right?: JaSwipeableAction[]\n}\n\n/**\n * Input options for list item builder.\n */\nexport interface JcListItemInput extends JcBaseInput {\n  /** Unique component identifier */\n  readonly instanceId?: InstanceId\n  /** Primary text line */\n  readonly title?: string | TextValueWithStyle | TextValueWithStyleBuilder\n  /** Secondary text below title */\n  readonly subtitle?: string | TextValueWithStyle | TextValueWithStyleBuilder\n  /** Additional text below subtitle */\n  readonly description?: string | TextValueWithStyle | TextValueWithStyleBuilder\n  /** Bottom separator line */\n  readonly divider?: JcListItemDividerValue\n  /** Item data value */\n  readonly value?: Expression\n  /** Text line limit */\n  readonly numberOfLines?: number | 'dynamic' | Expression\n  /** Card-style background */\n  readonly isContained?: boolean\n  /** Disables item interaction */\n  readonly isDisabled?: BooleanOrExpression\n  /** Theme color */\n  readonly color?: ColorValueOrConditions\n  /** Progress bar 0-1 */\n  readonly progress?: number | Expression\n  /** Star rating 0-5 */\n  readonly rating?: number | Expression\n  /** Avatar group display */\n  readonly avatars?: AvatarItemConfig[] | Expression\n  /** Strikethrough text */\n  readonly isStrikeThrough?: BooleanOrExpression\n  /** Width for horizontal lists */\n  readonly horizontalItemSize?: number | Expression\n}\n\nexport type JcListItemOptions = JcListItemInput\n\n/**\n * Builds rich list item templates.\n */\nexport class JcListItemBuilder extends ComponentBaseBuilder<JcListItemInput> {\n  private _leftElement?: LeftElementBuilders\n  private _rightElement?: RightElementBuilders\n\n  /** List item state expressions. */\n  readonly state: {\n    /** Amount control value for product items */\n    readonly amountControl: string\n    /** Checkbox checked state */\n    readonly checked: string\n  }\n\n  /** Factory for left-side elements. */\n  readonly leftElement = {\n    /** Icon element */\n    icon: (name: string | Expression, options?: JcIconElementOptions): IconElementBuilder => {\n      const builder = new IconElementBuilder(name, options)\n      this._leftElement = builder\n      return builder\n    },\n    /** Avatar with image/text */\n    avatar: (options?: AvatarElementInput): AvatarElementBuilder => {\n      const builder = new AvatarElementBuilder(options)\n      this._leftElement = builder\n      return builder\n    },\n    /** Image thumbnail */\n    image: (options?: ImageElementInput): ImageElementBuilder => {\n      const builder = new ImageElementBuilder(options)\n      this._leftElement = builder\n      return builder\n    },\n    /** Progress indicator */\n    progress: (options: ProgressElementInput): ProgressElementBuilder => {\n      const builder = new ProgressElementBuilder(options)\n      this._leftElement = builder\n      return builder\n    },\n    /** Checkbox for selection */\n    checkbox: (options?: CheckboxElementInput): CheckboxElementBuilder => {\n      const builder = new CheckboxElementBuilder(options)\n      this._leftElement = builder\n      return builder\n    },\n  }\n\n  /** Factory for right-side elements. */\n  readonly rightElement = {\n    /** Quantity selector +/- */\n    amount: (options?: AmountControlInput): AmountControlBuilder => {\n      const builder = new AmountControlBuilder(options)\n      this._rightElement = builder\n      return builder\n    },\n    /** Notification badge */\n    badge: (options?: BadgeElementInput): BadgeElementBuilder => {\n      const builder = new BadgeElementBuilder(options)\n      this._rightElement = builder\n      return builder\n    },\n    /** Action button */\n    button: (options: ButtonElementInput): ButtonElementBuilder => {\n      const builder = new ButtonElementBuilder(options)\n      this._rightElement = builder\n      return builder\n    },\n    /** Chevron or status icon */\n    icon: (name: string | Expression, options?: JcIconElementOptions): IconElementBuilder => {\n      const builder = new IconElementBuilder(name, options)\n      this._rightElement = builder\n      return builder\n    },\n    /** Toggle switch */\n    switch: (options?: SwitchElementInput): SwitchElementBuilder => {\n      const builder = new SwitchElementBuilder(options)\n      this._rightElement = builder\n      return builder\n    },\n    /** Text value (price, status) */\n    value: (options: ValueElementInput): ValueElementBuilder => {\n      const builder = new ValueElementBuilder(options)\n      this._rightElement = builder\n      return builder\n    },\n    /** Selection checkbox */\n    checkbox: (options?: CheckboxElementInput): CheckboxElementBuilder => {\n      const builder = new CheckboxElementBuilder(options)\n      this._rightElement = builder\n      return builder\n    },\n  }\n\n  /** Factory for tap action. */\n  readonly onPress: JaInBackgroundFactoryOne = JaInBackgroundFactoryOne.one()\n\n  /** Creates left swipe action (delete, archive). */\n  readonly swipeLeft = (): SwipeableActionBuilder => {\n    const builder = new SwipeableActionBuilder()\n    if (!this._swipeableActions) {\n      this._swipeableActions = { left: [], right: [] }\n    }\n    this._swipeableActions.left.push(builder)\n    return builder\n  }\n\n  /** Creates right swipe action (edit, share). */\n  readonly swipeRight = (): SwipeableActionBuilder => {\n    const builder = new SwipeableActionBuilder()\n    if (!this._swipeableActions) {\n      this._swipeableActions = { left: [], right: [] }\n    }\n    this._swipeableActions.right.push(builder)\n    return builder\n  }\n\n  private _swipeableActions?: { left: SwipeableActionBuilder[]; right: SwipeableActionBuilder[] }\n\n  constructor(options: JcListItemInput = {}) {\n    super(COMPONENT_TYPE.LIST_ITEM, options)\n\n    const instanceId = options.instanceId ? toInstanceId(options.instanceId) : undefined\n    this.state = {\n      amountControl: instanceId ? `@ctx.components.${instanceId}.state.amount` : '',\n      checked: instanceId ? `@ctx.components.${instanceId}.state.checked` : '',\n    }\n\n    // Apply options\n    this.with(options)\n  }\n\n  override with(options?: Partial<Omit<JcListItemInput, '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 = TextValueWithStyleBuilder.from(title)\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 = TextValueWithStyleBuilder.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 = TextValueWithStyleBuilder.from(description)\n    }\n    if (options?.divider !== undefined) {\n      this._config.divider = options.divider\n    }\n    if (options?.value !== undefined) {\n      this._config.value = toExpression(options.value)\n    }\n    if (options?.numberOfLines !== undefined) {\n      const lines = options.numberOfLines\n      if (typeof lines === 'number' && lines < 1) {\n        this._config.numberOfLines = 'dynamic'\n      } else if (lines === 'dynamic') {\n        this._config.numberOfLines = 'dynamic'\n      } else {\n        this._config.numberOfLines = toNumberOrExpression(lines)\n      }\n    }\n    if (options?.isContained !== undefined) {\n      this._config.isContained = options.isContained\n    }\n    if (options?.isDisabled !== undefined) {\n      const style = (this._config.style as JcListItemStyle) ?? {}\n      style.isDisabled = toBooleanOrExpression(options.isDisabled)\n      this._config.style = style\n    }\n    if (options?.isStrikeThrough !== undefined) {\n      const style = (this._config.style as JcListItemStyle) ?? {}\n      style.isStrikeThrough = toBooleanOrExpression(options.isStrikeThrough)\n      this._config.style = style\n    }\n    if (options?.color !== undefined) {\n      this._config.color = options.color\n    }\n    if (options?.progress !== undefined) {\n      this._config.progress = toNumberOrExpression(options.progress)\n    }\n    if (options?.rating !== undefined) {\n      this._config.rating = toNumberOrExpression(options.rating)\n    }\n    if (options?.avatars !== undefined) {\n      this._config.avatars = options.avatars\n    }\n    if (options?.horizontalItemSize !== undefined) {\n      this._config.horizontalItemSize = toNumberOrExpression(options.horizontalItemSize)\n    }\n\n    return this\n  }\n\n  /** Sets primary text displayed on item. */\n  title(text: string | TextValueWithStyle | TextValueWithStyleBuilder): this {\n    return this.with({ title: text })\n  }\n\n  /** Sets secondary text below title. */\n  subtitle(text: string | TextValueWithStyle | TextValueWithStyleBuilder): this {\n    return this.with({ subtitle: text })\n  }\n\n  /** Sets additional text below subtitle. */\n  description(text: string | TextValueWithStyle | TextValueWithStyleBuilder): this {\n    return this.with({ description: text })\n  }\n\n  /** Configures divider line below item. */\n  divider(opt: JcListItemDividerValue): this {\n    return this.with({ divider: opt })\n  }\n\n  /** Sets item data value. */\n  value(value: Expression): this {\n    return this.with({ value })\n  }\n\n  /** Sets accessibility label. */\n  label(\n    title: string | TextValue | TextValueBuilder,\n    options?: { color?: ColorValueOrConditions; isHidden?: BooleanOrExpression },\n  ): this {\n    this._config.label = {\n      title: TextValueBuilder.from(title),\n      color: options?.color ? toColorValueOrConditions(options.color) : undefined,\n      isHidden:\n        options?.isHidden !== undefined ? toBooleanOrExpression(options.isHidden) : undefined,\n    }\n    return this\n  }\n\n  /** Limits text lines displayed. */\n  numberOfLines(lines: number | 'dynamic' | Expression): this {\n    return this.with({ numberOfLines: lines })\n  }\n\n  /** Enables contained styling. */\n  isContained(isContained = true): this {\n    return this.with({ isContained })\n  }\n\n  /** Disables item interaction. */\n  isDisabled(isDisabled: BooleanOrExpression): this {\n    return this.with({ isDisabled })\n  }\n\n  /** Sets visual state modifiers (disabled, error, warning, strikethrough, etc.). */\n  style(style: JcListItemStyle): this {\n    const existing = (this._config.style as JcListItemStyle) ?? {}\n    this._config.style = { ...existing, ...style }\n    return this\n  }\n\n  /** Applies strikethrough text decoration. */\n  isStrikeThrough(isStrikeThrough: BooleanOrExpression): this {\n    const style = (this._config.style as JcListItemStyle) ?? {}\n    style.isStrikeThrough = toBooleanOrExpression(isStrikeThrough)\n    this._config.style = style\n    return this\n  }\n\n  /** Sets item color theme. */\n  color(color: ColorValueOrConditions): this {\n    return this.with({ color })\n  }\n\n  /** Sets progress indicator value. */\n  progress(progress: number | Expression): this {\n    return this.with({ progress })\n  }\n\n  /** Sets star rating value. */\n  rating(rating: number | Expression): this {\n    return this.with({ rating })\n  }\n\n  /** Sets multiple avatar display. */\n  avatars(avatars: AvatarItemConfig[] | Expression): this {\n    return this.with({ avatars })\n  }\n\n  /** Sets tag badges as an Expression. */\n  tags(tags: Expression): this {\n    this._config.tags = toExpression(tags)\n    return this\n  }\n\n  /** Add tag badge on item. */\n  addTag(tag: TagBadge): this {\n    const tags = (this._config.tags as TagBadge[] | undefined) ?? []\n    tags.push({\n      text: toTextValue(tag.text),\n      color: tag.color ? toColorValue(tag.color) : undefined,\n    })\n    this._config.tags = tags\n    return this\n  }\n\n  /** Sets width for horizontal lists. */\n  horizontalItemSize(size: number | Expression): this {\n    return this.with({ horizontalItemSize: size })\n  }\n\n  override build(): JcBase {\n    const base = super.build()\n    const onPress: JaInBackground | undefined = this.onPress.build()\n\n    const left = this._swipeableActions?.left.length\n      ? this._swipeableActions.left.map((x) => x.build())\n      : undefined\n    const right = this._swipeableActions?.right.length\n      ? this._swipeableActions.right.map((x) => x.build())\n      : undefined\n    let swipeable: JcListItemSwipeable | undefined\n    if (left || right) {\n      swipeable = {\n        left: left,\n        right: right,\n      }\n    }\n\n    return {\n      ...base,\n      options: {\n        ...base.options,\n        leftElement: this._leftElement?.build(),\n        rightElement: this._rightElement?.build(),\n        onPress,\n        swipeable,\n      },\n    }\n  }\n}\n"]}

package/dist/component/jc.list-item.standalone.d.ts

@@ -0,0 +1,13 @@
+import { type InstanceId } from '../abstract/index.js';
+import { type JcBase } from './jc.abstract.js';
+import { JcListItemBuilder } from './jc.list-item.js';
+export interface JcListItemStandalone extends JcBase {
+}
+export interface JcListItemStandaloneOptions extends Record<string, unknown> {
+}
+export declare class JcListItemStandaloneBuilder extends JcListItemBuilder {
+    constructor(options?: JcListItemStandaloneOptions & {
+        instanceId?: InstanceId;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiamMubGlzdC1pdGVtLnN0YW5kYWxvbmUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb21wb25lbnQvamMubGlzdC1pdGVtLnN0YW5kYWxvbmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssVUFBVSxFQUFFLE1BQU0sc0JBQXNCLENBQUE7QUFDdEQsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFFLE1BQU0sa0JBQWtCLENBQUE7QUFDOUMsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sbUJBQW1CLENBQUE7QUFNckQsTUFBTSxXQUFXLG9CQUFxQixTQUFRLE1BQU07Q0FBRztBQUd2RCxNQUFNLFdBQVcsMkJBQTRCLFNBQVEsTUFBTSxDQUFDLE1BQU0sRUFBRSxPQUFPLENBQUM7Q0FBRztBQUsvRSxxQkFBYSwyQkFBNEIsU0FBUSxpQkFBaUI7SUFDaEUsWUFBWSxPQUFPLENBQUMsRUFBRSwyQkFBMkIsR0FBRztRQUFFLFVBQVUsQ0FBQyxFQUFFLFVBQVUsQ0FBQTtLQUFFLEVBTzlFO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyB0eXBlIEluc3RhbmNlSWQgfSBmcm9tICcuLi9hYnN0cmFjdC9pbmRleC5qcydcbmltcG9ydCB7IHR5cGUgSmNCYXNlIH0gZnJvbSAnLi9qYy5hYnN0cmFjdC5qcydcbmltcG9ydCB7IEpjTGlzdEl0ZW1CdWlsZGVyIH0gZnJvbSAnLi9qYy5saXN0LWl0ZW0uanMnXG5cbi8qKlxuICogU3RhbmRhbG9uZSBsaXN0IGl0ZW0gZm9yIGRpcmVjdCBwbGFjZW1lbnQgaW4gamlncy9zZWN0aW9ucy5cbiAqIEBzZWUgIy9kZWZpbml0aW9ucy9KQ0xpc3RJdGVtU3RhbmRBbG9uZUNvbmZpZ1xuICovXG5leHBvcnQgaW50ZXJmYWNlIEpjTGlzdEl0ZW1TdGFuZGFsb25lIGV4dGVuZHMgSmNCYXNlIHt9XG5cbi8vIFRPRE86IEZpbGwgaW4gb3B0aW9uc1xuZXhwb3J0IGludGVyZmFjZSBKY0xpc3RJdGVtU3RhbmRhbG9uZU9wdGlvbnMgZXh0ZW5kcyBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPiB7fVxuXG4vKipcbiAqIEJ1aWxkcyBzdGFuZGFsb25lIGxpc3QgaXRlbXMgd2l0aCB0aXRsZSwgc3VidGl0bGUsIGxlZnQvcmlnaHQgZWxlbWVudHMuXG4gKi9cbmV4cG9ydCBjbGFzcyBKY0xpc3RJdGVtU3RhbmRhbG9uZUJ1aWxkZXIgZXh0ZW5kcyBKY0xpc3RJdGVtQnVpbGRlciB7XG4gIGNvbnN0cnVjdG9yKG9wdGlvbnM/OiBKY0xpc3RJdGVtU3RhbmRhbG9uZU9wdGlvbnMgJiB7IGluc3RhbmNlSWQ/OiBJbnN0YW5jZUlkIH0pIHtcbiAgICBzdXBlcihvcHRpb25zKVxuXG4gICAgLy8gVE9ETzogVmFsaWRhdGUgb3B0aW9uc1xuICAgIGlmIChvcHRpb25zKSB7XG4gICAgICAvLyB0aGlzLm9wdGlvbnMob3B0aW9ucylcbiAgICB9XG4gIH1cbn1cbiJdfQ==

package/dist/component/jc.list-item.standalone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jc.list-item.standalone.d.ts","sourceRoot":"","sources":["../../src/component/jc.list-item.standalone.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACtD,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAMrD,MAAM,WAAW,oBAAqB,SAAQ,MAAM;CAAG;AAGvD,MAAM,WAAW,2BAA4B,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAAG;AAK/E,qBAAa,2BAA4B,SAAQ,iBAAiB;IAChE,YAAY,OAAO,CAAC,EAAE,2BAA2B,GAAG;QAAE,UAAU,CAAC,EAAE,UAAU,CAAA;KAAE,EAO9E;CACF","sourcesContent":["import { type InstanceId } from '../abstract/index.js'\nimport { type JcBase } from './jc.abstract.js'\nimport { JcListItemBuilder } from './jc.list-item.js'\n\n/**\n * Standalone list item for direct placement in jigs/sections.\n * @see #/definitions/JCListItemStandAloneConfig\n */\nexport interface JcListItemStandalone extends JcBase {}\n\n// TODO: Fill in options\nexport interface JcListItemStandaloneOptions extends Record<string, unknown> {}\n\n/**\n * Builds standalone list items with title, subtitle, left/right elements.\n */\nexport class JcListItemStandaloneBuilder extends JcListItemBuilder {\n  constructor(options?: JcListItemStandaloneOptions & { instanceId?: InstanceId }) {\n    super(options)\n\n    // TODO: Validate options\n    if (options) {\n      // this.options(options)\n    }\n  }\n}\n"]}

package/dist/component/jc.list-item.standalone.js

@@ -0,0 +1,10 @@
+import { JcListItemBuilder } from './jc.list-item.js';
+export class JcListItemStandaloneBuilder extends JcListItemBuilder {
+    constructor(options) {
+        super(options);
+        if (options) {
+            // this.options(options)
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiamMubGlzdC1pdGVtLnN0YW5kYWxvbmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29tcG9uZW50L2pjLmxpc3QtaXRlbS5zdGFuZGFsb25lLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLG1CQUFtQixDQUFBO0FBY3JELE1BQU0sT0FBTywyQkFBNEIsU0FBUSxpQkFBaUI7SUFDaEUsWUFBWSxPQUFtRSxFQUFFO1FBQy9FLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQTtRQUdkLElBQUksT0FBTyxFQUFFLENBQUM7WUFDWix3QkFBd0I7UUFDMUIsQ0FBQztJQUFBLENBQ0Y7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHR5cGUgSW5zdGFuY2VJZCB9IGZyb20gJy4uL2Fic3RyYWN0L2luZGV4LmpzJ1xuaW1wb3J0IHsgdHlwZSBKY0Jhc2UgfSBmcm9tICcuL2pjLmFic3RyYWN0LmpzJ1xuaW1wb3J0IHsgSmNMaXN0SXRlbUJ1aWxkZXIgfSBmcm9tICcuL2pjLmxpc3QtaXRlbS5qcydcblxuLyoqXG4gKiBTdGFuZGFsb25lIGxpc3QgaXRlbSBmb3IgZGlyZWN0IHBsYWNlbWVudCBpbiBqaWdzL3NlY3Rpb25zLlxuICogQHNlZSAjL2RlZmluaXRpb25zL0pDTGlzdEl0ZW1TdGFuZEFsb25lQ29uZmlnXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgSmNMaXN0SXRlbVN0YW5kYWxvbmUgZXh0ZW5kcyBKY0Jhc2Uge31cblxuLy8gVE9ETzogRmlsbCBpbiBvcHRpb25zXG5leHBvcnQgaW50ZXJmYWNlIEpjTGlzdEl0ZW1TdGFuZGFsb25lT3B0aW9ucyBleHRlbmRzIFJlY29yZDxzdHJpbmcsIHVua25vd24+IHt9XG5cbi8qKlxuICogQnVpbGRzIHN0YW5kYWxvbmUgbGlzdCBpdGVtcyB3aXRoIHRpdGxlLCBzdWJ0aXRsZSwgbGVmdC9yaWdodCBlbGVtZW50cy5cbiAqL1xuZXhwb3J0IGNsYXNzIEpjTGlzdEl0ZW1TdGFuZGFsb25lQnVpbGRlciBleHRlbmRzIEpjTGlzdEl0ZW1CdWlsZGVyIHtcbiAgY29uc3RydWN0b3Iob3B0aW9ucz86IEpjTGlzdEl0ZW1TdGFuZGFsb25lT3B0aW9ucyAmIHsgaW5zdGFuY2VJZD86IEluc3RhbmNlSWQgfSkge1xuICAgIHN1cGVyKG9wdGlvbnMpXG5cbiAgICAvLyBUT0RPOiBWYWxpZGF0ZSBvcHRpb25zXG4gICAgaWYgKG9wdGlvbnMpIHtcbiAgICAgIC8vIHRoaXMub3B0aW9ucyhvcHRpb25zKVxuICAgIH1cbiAgfVxufVxuIl19

package/dist/component/jc.list.abstract.d.ts

@@ -0,0 +1,36 @@
+import { type DatasourceId, type Expression, type TextValue } from '../abstract/index.js';
+import { type JaBase } from '../action/index.js';
+import type { InlineData } from '../datasource/index.js';
+import { type JcBase } from './jc.abstract.js';
+import { type COMPONENT_TYPE } from './jc.types.js';
+export interface ListFilterItem {
+    readonly title: TextValue;
+    readonly value: string | number | boolean | Expression;
+}
+export interface ListFilter {
+    data: ListFilterItem[] | Expression;
+    initialValue?: string | number | boolean | Expression;
+}
+export type Filter = ListFilter | Expression;
+export interface SectionBase {
+    title: TextValue;
+    data: Expression;
+}
+export type JcListBaseOptions = Record<string, unknown>;
+export interface JcListBase extends JcBase {
+    readonly type: typeof COMPONENT_TYPE.LIST;
+    options: {
+        item: JcBase;
+        isSearchable?: boolean;
+        isHorizontal?: boolean;
+        isHorizontalScrollIndicatorHidden?: boolean;
+        isVerticalScrollIndicatorHidden?: boolean;
+        hasActiveItem?: boolean;
+        filter?: Filter;
+        data?: InlineData | DatasourceId | Expression;
+        sections?: SectionBase[];
+        maximumItemsToRender?: number | string;
+        onShowMorePress?: JaBase;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/component/jc.list.abstract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jc.list.abstract.d.ts","sourceRoot":"","sources":["../../src/component/jc.list.abstract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAA;AACzF,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAChD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AACxD,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAA;AAMnD,MAAM,WAAW,cAAc;IAE7B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;IAEzB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,UAAU,CAAA;CACvD;AAMD,MAAM,WAAW,UAAU;IAEzB,IAAI,EAAE,cAAc,EAAE,GAAG,UAAU,CAAA;IAEnC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,UAAU,CAAA;CACtD;AAGD,MAAM,MAAM,MAAM,GAAG,UAAU,GAAG,UAAU,CAAA;AAM5C,MAAM,WAAW,WAAW;IAE1B,KAAK,EAAE,SAAS,CAAA;IAEhB,IAAI,EAAE,UAAU,CAAA;CACjB;AAMD,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAOvD,MAAM,WAAW,UAAW,SAAQ,MAAM;IACxC,QAAQ,CAAC,IAAI,EAAE,OAAO,cAAc,CAAC,IAAI,CAAA;IACzC,OAAO,EAAE;QAEP,IAAI,EAAE,MAAM,CAAA;QAEZ,YAAY,CAAC,EAAE,OAAO,CAAA;QAEtB,YAAY,CAAC,EAAE,OAAO,CAAA;QAEtB,iCAAiC,CAAC,EAAE,OAAO,CAAA;QAE3C,+BAA+B,CAAC,EAAE,OAAO,CAAA;QAEzC,aAAa,CAAC,EAAE,OAAO,CAAA;QAEvB,MAAM,CAAC,EAAE,MAAM,CAAA;QAEf,IAAI,CAAC,EAAE,UAAU,GAAG,YAAY,GAAG,UAAU,CAAA;QAE7C,QAAQ,CAAC,EAAE,WAAW,EAAE,CAAA;QAExB,oBAAoB,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;QAEtC,eAAe,CAAC,EAAE,MAAM,CAAA;KACzB,CAAA;CACF","sourcesContent":["import { type DatasourceId, type Expression, type TextValue } from '../abstract/index.js'\nimport { type JaBase } from '../action/index.js'\nimport type { InlineData } from '../datasource/index.js'\nimport { type JcBase } from './jc.abstract.js'\nimport { type COMPONENT_TYPE } from './jc.types.js'\n\n/**\n * Filter option in list filter dropdown.\n * @see #/definitions/ListFilterItem\n */\nexport interface ListFilterItem {\n  /** Display text for filter option */\n  readonly title: TextValue\n  /** Filter value when selected */\n  readonly value: string | number | boolean | Expression\n}\n\n/**\n * List filtering configuration.\n * @see #/definitions/ListFilter\n */\nexport interface ListFilter {\n  /** Filter options array or expression */\n  data: ListFilterItem[] | Expression\n  /** Pre-selected filter value */\n  initialValue?: string | number | boolean | Expression\n}\n\n/** Filter can be config object or expression evaluating to filter. */\nexport type Filter = ListFilter | Expression\n\n/**\n * Grouped list section configuration.\n * @see #/definitions/SectionBase\n */\nexport interface SectionBase {\n  /** Section header text */\n  title: TextValue\n  /** Items data for this section */\n  data: Expression\n}\n\n/**\n * Input options for list base configuration.\n * Reserved for future list configuration options.\n */\nexport type JcListBaseOptions = Record<string, unknown>\n\n/**\n * Base interface for all List variants.\n *\n * Core list properties shared by JcList and JcListOnCustomComponent.\n */\nexport interface JcListBase extends JcBase {\n  readonly type: typeof COMPONENT_TYPE.LIST\n  options: {\n    /** Item template component (list-item, card, chart, etc.) */\n    item: JcBase\n    /** Enables search bar. State: @ctx.components.[id].state.searchText */\n    isSearchable?: boolean\n    /** Horizontal scrolling mode */\n    isHorizontal?: boolean\n    /** Hides horizontal scroll indicator */\n    isHorizontalScrollIndicatorHidden?: boolean\n    /** Hides vertical scroll indicator */\n    isVerticalScrollIndicatorHidden?: boolean\n    /** Tracks active item. State: activeItemId, activeItem */\n    hasActiveItem?: boolean\n    /** Filter dropdown config or expression */\n    filter?: Filter\n    /** Items data source expression or inline data */\n    data?: InlineData | DatasourceId | Expression\n    /** Grouped sections with titles */\n    sections?: SectionBase[]\n    /** Performance limit for large lists */\n    maximumItemsToRender?: number | string\n    /** Show more button action */\n    onShowMorePress?: JaBase\n  }\n}\n"]}

package/dist/component/jc.list.abstract.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,39 @@
+import { type DatasourceId, type Expression, type TextValue, TextValueBuilder } from '../abstract/index.js';
+import { type DatasourceBase, type InlineData } from '../datasource/index.js';
+import { ListFilterBuilder } from '../screen/index.js';
+import { ComponentBaseBuilder, type JcBaseInput } from './jc.abstract.js';
+import { JcCustomComponentInteropBuilder } from './jc.custom-component.interop.js';
+import { JcExpanderBuilder } from './jc.expander.js';
+import { JcListItemBuilder } from './jc.list-item.js';
+import { JcProductItemBuilder } from './jc.product-item.js';
+export interface JcListInput extends JcBaseInput {
+    maximumItemsToRender?: number | Expression;
+    isHorizontal?: boolean;
+    isHorizontalScrollIndicatorHidden?: boolean;
+    isVerticalScrollIndicatorHidden?: boolean;
+    isSearchable?: boolean;
+    isSelectable?: boolean;
+    hasActiveItem?: boolean;
+    numberOfColumns?: number | Expression;
+    initialItemCount?: number | Expression;
+    scrollRenderBuffer?: number | Expression;
+}
+export declare class JcListBuilder extends ComponentBaseBuilder<JcListInput> {
+    constructor(options?: JcListInput);
+    setItem: {
+        customComponent: (input: import("./jc.custom-component.interop.js").JcCustomComponentInteropInput) => JcCustomComponentInteropBuilder;
+        expander: (options: import("./jc.expander.js").JcExpanderInput) => JcExpanderBuilder;
+        listItem: (options?: import("./jc.list-item.js").JcListItemInput | undefined) => JcListItemBuilder;
+        product: (options?: import("./jc.product-item.js").JcProductItemInput | undefined) => JcProductItemBuilder;
+    };
+    onShowMorePress: import("../action/ja.in-background.factory.js").ActionInBackgroundBuilders;
+    data(datasource: DatasourceId | DatasourceBase | Expression | InlineData): this;
+    getCurrentItemRef(key?: string): string;
+    filter: (options: import("../screen/screen.list.ts").ListFilterBuilderInput) => ListFilterBuilder;
+    section(options: {
+        title: string | TextValue | TextValueBuilder;
+        data: string | Expression;
+    }): this;
+    with(options: JcListInput): this;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jc.list.d.ts","sourceRoot":"","sources":["../../src/component/jc.list.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,SAAS,EACd,gBAAgB,EAEjB,MAAM,sBAAsB,CAAA;AAG7B,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,UAAU,EAAE,MAAM,wBAAwB,CAAA;AAC7E,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AACtD,OAAO,EAAE,oBAAoB,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACzE,OAAO,EAAE,+BAA+B,EAAE,MAAM,kCAAkC,CAAA;AAClF,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAErD,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAA;AAG3D,MAAM,WAAW,WAAY,SAAQ,WAAW;IAC9C,oBAAoB,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IAC1C,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,iCAAiC,CAAC,EAAE,OAAO,CAAA;IAC3C,+BAA+B,CAAC,EAAE,OAAO,CAAA;IACzC,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,eAAe,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IACrC,gBAAgB,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IACtC,kBAAkB,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;CACzC;AAKD,qBAAa,aAAc,SAAQ,oBAAoB,CAAC,WAAW,CAAC;IAClE,YAAY,OAAO,GAAE,WAAgB,EAGpC;IAED,OAAO;;;;;MAKN;IAED,eAAe,6EAEb;IAMF,IAAI,CAAC,UAAU,EAAE,YAAY,GAAG,cAAc,GAAG,UAAU,GAAG,UAAU,GAAG,IAAI,CAe9E;IAED,iBAAiB,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAOtC;IAED,MAAM,4FAAkE;IAQxE,OAAO,CAAC,OAAO,EAAE;QACf,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,gBAAgB,CAAA;QAC5C,IAAI,EAAE,MAAM,GAAG,UAAU,CAAA;KAC1B,GAAG,IAAI,CAQP;IAQQ,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,CA0CxC;CACF","sourcesContent":["import {\n  assignBuilderFactory,\n  type DatasourceId,\n  type Expression,\n  type TextValue,\n  TextValueBuilder,\n  toExpression,\n} from '../abstract/index.js'\nimport { createActionInBackgroundBuildersFactory } from '../action/ja.in-background.factory.js'\nimport { CTX } from '../application/index.js'\nimport { type DatasourceBase, type InlineData } from '../datasource/index.js'\nimport { ListFilterBuilder } from '../screen/index.js'\nimport { ComponentBaseBuilder, type JcBaseInput } from './jc.abstract.js'\nimport { JcCustomComponentInteropBuilder } from './jc.custom-component.interop.js'\nimport { JcExpanderBuilder } from './jc.expander.js'\nimport { JcListItemBuilder } from './jc.list-item.js'\nimport { type SectionBase } from './jc.list.abstract.js'\nimport { JcProductItemBuilder } from './jc.product-item.js'\nimport { COMPONENT_TYPE } from './jc.types.js'\n\nexport interface JcListInput extends JcBaseInput {\n  maximumItemsToRender?: number | Expression\n  isHorizontal?: boolean\n  isHorizontalScrollIndicatorHidden?: boolean\n  isVerticalScrollIndicatorHidden?: boolean\n  isSearchable?: boolean\n  isSelectable?: boolean\n  hasActiveItem?: boolean\n  numberOfColumns?: number | Expression\n  initialItemCount?: number | Expression\n  scrollRenderBuffer?: number | Expression\n}\n\n/**\n * Builds scrollable lists with dynamic item rendering.\n */\nexport class JcListBuilder extends ComponentBaseBuilder<JcListInput> {\n  constructor(options: JcListInput = {}) {\n    super(COMPONENT_TYPE.LIST, options)\n    this.with(options)\n  }\n\n  setItem = {\n    customComponent: assignBuilderFactory(JcCustomComponentInteropBuilder, this._config, 'item'),\n    expander: assignBuilderFactory(JcExpanderBuilder, this._config, 'item'),\n    listItem: assignBuilderFactory(JcListItemBuilder, this._config, 'item'),\n    product: assignBuilderFactory(JcProductItemBuilder, this._config, 'item'),\n  }\n\n  onShowMorePress = createActionInBackgroundBuildersFactory((action) => {\n    this._setToConfig('onShowMorePress', action)\n  })\n\n  /**\n   * Sets data source for list items.\n   * @param datasource Datasource, ID or expression\n   */\n  data(datasource: DatasourceId | DatasourceBase | Expression | InlineData): this {\n    if (Array.isArray(datasource)) {\n      this._config.data = datasource\n    } else if (typeof datasource === 'object') {\n      this._config.data = CTX.datasources.expr(datasource.datasourceId)\n    } else if (typeof datasource === 'string') {\n      if (datasource.startsWith('=')) {\n        this._config.data = toExpression(datasource)\n      } else {\n        this._config.data = CTX.datasources.expr(datasource)\n      }\n    } else {\n      this._config.data = []\n    }\n    return this\n  }\n\n  getCurrentItemRef(key?: string): string {\n    // TODO: validate key, how?\n    if (key === undefined) {\n      return `@ctx.current.item`\n    }\n\n    return `@ctx.current.item.${key}`\n  }\n\n  filter = assignBuilderFactory(ListFilterBuilder, this._config, 'filter')\n\n  /**\n   * Adds section to group list items.\n   * @param options Required section options\n   * @param options.title Section header\n   * @param options.data Expression for section data\n   */\n  section(options: {\n    title: string | TextValue | TextValueBuilder\n    data: string | Expression\n  }): this {\n    const sections = Array.isArray(this._config.sections) ? this._config.sections : []\n    const section: SectionBase = {\n      title: TextValueBuilder.from(options.title),\n      data: toExpression(options.data),\n    }\n    sections.push(section)\n    return this\n  }\n\n  /**\n   * Configures list display and behavior.\n   * @param options.horizontal Enable horizontal scrolling\n   * @param options.isSearchable Enable search bar\n   * @param options.isSelectable Enable item selection\n   */\n  override with(options: JcListInput): this {\n    if (options.maximumItemsToRender !== undefined) {\n      this._config.maximumItemsToRender = options.maximumItemsToRender\n    }\n\n    if (options.isHorizontal !== undefined) {\n      this._config.isHorizontal = options.isHorizontal\n    }\n\n    if (options.isHorizontalScrollIndicatorHidden !== undefined) {\n      this._config.isHorizontalScrollIndicatorHidden = options.isHorizontalScrollIndicatorHidden\n    }\n\n    if (options.isVerticalScrollIndicatorHidden !== undefined) {\n      this._config.isVerticalScrollIndicatorHidden = options.isVerticalScrollIndicatorHidden\n    }\n\n    if (options.isSearchable !== undefined) {\n      this._config.isSearchable = options.isSearchable\n    }\n\n    if (options.isSelectable !== undefined) {\n      this._config.isSelectable = options.isSelectable\n    }\n\n    if (options.hasActiveItem !== undefined) {\n      this._config.hasActiveItem = options.hasActiveItem\n    }\n\n    if (options.numberOfColumns !== undefined) {\n      this._config.numberOfColumns = options.numberOfColumns\n    }\n\n    if (options.initialItemCount !== undefined) {\n      this._config.initialItemCount = options.initialItemCount\n    }\n\n    if (options.scrollRenderBuffer !== undefined) {\n      this._config.scrollRenderBuffer = options.scrollRenderBuffer\n    }\n\n    return this\n  }\n}\n"]}

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

@@ -0,0 +1 @@
+{"version":3,"file":"jc.list.d.ts","sourceRoot":"","sources":["../../src/component/jc.list.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,SAAS,EACd,gBAAgB,EAEjB,MAAM,sBAAsB,CAAA;AAG7B,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,UAAU,EAAE,MAAM,wBAAwB,CAAA;AAC7E,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AACtD,OAAO,EAAE,oBAAoB,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACzE,OAAO,EAAE,+BAA+B,EAAE,MAAM,kCAAkC,CAAA;AAClF,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAErD,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAA;AAG3D,MAAM,WAAW,WAAY,SAAQ,WAAW;IAC9C,oBAAoB,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IAC1C,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,iCAAiC,CAAC,EAAE,OAAO,CAAA;IAC3C,+BAA+B,CAAC,EAAE,OAAO,CAAA;IACzC,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,eAAe,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IACrC,gBAAgB,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IACtC,kBAAkB,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;CACzC;AAKD,qBAAa,aAAc,SAAQ,oBAAoB,CAAC,WAAW,CAAC;IAClE,YAAY,OAAO,GAAE,WAAgB,EAGpC;IAED,OAAO;;;;;MAKN;IAED,eAAe,6EAEb;IAMF,IAAI,CAAC,UAAU,EAAE,YAAY,GAAG,cAAc,GAAG,UAAU,GAAG,UAAU,GAAG,IAAI,CAe9E;IAED,iBAAiB,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAOtC;IAED,MAAM,4FAAkE;IAQxE,OAAO,CAAC,OAAO,EAAE;QACf,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,gBAAgB,CAAA;QAC5C,IAAI,EAAE,MAAM,GAAG,UAAU,CAAA;KAC1B,GAAG,IAAI,CAQP;IAQQ,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,CA0CxC;CACF","sourcesContent":["import {\n  assignBuilderFactory,\n  type DatasourceId,\n  type Expression,\n  type TextValue,\n  TextValueBuilder,\n  toExpression,\n} from '../abstract/index.js'\nimport { createActionInBackgroundBuildersFactory } from '../action/ja.in-background.factory.js'\nimport { CTX } from '../application/index.js'\nimport { type DatasourceBase, type InlineData } from '../datasource/index.js'\nimport { ListFilterBuilder } from '../screen/index.js'\nimport { ComponentBaseBuilder, type JcBaseInput } from './jc.abstract.js'\nimport { JcCustomComponentInteropBuilder } from './jc.custom-component.interop.js'\nimport { JcExpanderBuilder } from './jc.expander.js'\nimport { JcListItemBuilder } from './jc.list-item.js'\nimport { type SectionBase } from './jc.list.abstract.js'\nimport { JcProductItemBuilder } from './jc.product-item.js'\nimport { COMPONENT_TYPE } from './jc.types.js'\n\nexport interface JcListInput extends JcBaseInput {\n  maximumItemsToRender?: number | Expression\n  isHorizontal?: boolean\n  isHorizontalScrollIndicatorHidden?: boolean\n  isVerticalScrollIndicatorHidden?: boolean\n  isSearchable?: boolean\n  isSelectable?: boolean\n  hasActiveItem?: boolean\n  numberOfColumns?: number | Expression\n  initialItemCount?: number | Expression\n  scrollRenderBuffer?: number | Expression\n}\n\n/**\n * Builds scrollable lists with dynamic item rendering.\n */\nexport class JcListBuilder extends ComponentBaseBuilder<JcListInput> {\n  constructor(options: JcListInput = {}) {\n    super(COMPONENT_TYPE.LIST, options)\n    this.with(options)\n  }\n\n  setItem = {\n    customComponent: assignBuilderFactory(JcCustomComponentInteropBuilder, this._config, 'item'),\n    expander: assignBuilderFactory(JcExpanderBuilder, this._config, 'item'),\n    listItem: assignBuilderFactory(JcListItemBuilder, this._config, 'item'),\n    product: assignBuilderFactory(JcProductItemBuilder, this._config, 'item'),\n  }\n\n  onShowMorePress = createActionInBackgroundBuildersFactory((action) => {\n    this._setToConfig('onShowMorePress', action)\n  })\n\n  /**\n   * Sets data source for list items.\n   * @param datasource Datasource, ID or expression\n   */\n  data(datasource: DatasourceId | DatasourceBase | Expression | InlineData): this {\n    if (Array.isArray(datasource)) {\n      this._config.data = datasource\n    } else if (typeof datasource === 'object') {\n      this._config.data = CTX.datasources.expr(datasource.datasourceId)\n    } else if (typeof datasource === 'string') {\n      if (datasource.startsWith('=')) {\n        this._config.data = toExpression(datasource)\n      } else {\n        this._config.data = CTX.datasources.expr(datasource)\n      }\n    } else {\n      this._config.data = []\n    }\n    return this\n  }\n\n  getCurrentItemRef(key?: string): string {\n    // TODO: validate key, how?\n    if (key === undefined) {\n      return `@ctx.current.item`\n    }\n\n    return `@ctx.current.item.${key}`\n  }\n\n  filter = assignBuilderFactory(ListFilterBuilder, this._config, 'filter')\n\n  /**\n   * Adds section to group list items.\n   * @param options Required section options\n   * @param options.title Section header\n   * @param options.data Expression for section data\n   */\n  section(options: {\n    title: string | TextValue | TextValueBuilder\n    data: string | Expression\n  }): this {\n    const sections = Array.isArray(this._config.sections) ? this._config.sections : []\n    const section: SectionBase = {\n      title: TextValueBuilder.from(options.title),\n      data: toExpression(options.data),\n    }\n    sections.push(section)\n    return this\n  }\n\n  /**\n   * Configures list display and behavior.\n   * @param options.horizontal Enable horizontal scrolling\n   * @param options.isSearchable Enable search bar\n   * @param options.isSelectable Enable item selection\n   */\n  override with(options: JcListInput): this {\n    if (options.maximumItemsToRender !== undefined) {\n      this._config.maximumItemsToRender = options.maximumItemsToRender\n    }\n\n    if (options.isHorizontal !== undefined) {\n      this._config.isHorizontal = options.isHorizontal\n    }\n\n    if (options.isHorizontalScrollIndicatorHidden !== undefined) {\n      this._config.isHorizontalScrollIndicatorHidden = options.isHorizontalScrollIndicatorHidden\n    }\n\n    if (options.isVerticalScrollIndicatorHidden !== undefined) {\n      this._config.isVerticalScrollIndicatorHidden = options.isVerticalScrollIndicatorHidden\n    }\n\n    if (options.isSearchable !== undefined) {\n      this._config.isSearchable = options.isSearchable\n    }\n\n    if (options.isSelectable !== undefined) {\n      this._config.isSelectable = options.isSelectable\n    }\n\n    if (options.hasActiveItem !== undefined) {\n      this._config.hasActiveItem = options.hasActiveItem\n    }\n\n    if (options.numberOfColumns !== undefined) {\n      this._config.numberOfColumns = options.numberOfColumns\n    }\n\n    if (options.initialItemCount !== undefined) {\n      this._config.initialItemCount = options.initialItemCount\n    }\n\n    if (options.scrollRenderBuffer !== undefined) {\n      this._config.scrollRenderBuffer = options.scrollRenderBuffer\n    }\n\n    return this\n  }\n}\n"]}