@jigx/core-sdk 1.0.0

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

@@ -0,0 +1,757 @@
+import { JcAmountControlBuilder } from './jc.amount-control.js';
+import { JcAvatarBuilder } from './jc.avatar.js';
+import { JcAvatarFieldBuilder } from './jc.avatar-field.js';
+import { JcBannerBuilder } from './jc.banner.js';
+import { JcBarChartBuilder } from './jc.bar-chart.js';
+import { JcButtonBuilder } from './jc.button.js';
+import { JcCardOnDefaultBuilder } from './jc.card.on-default.js';
+import { JcCarouselBuilder } from './jc.carousel.js';
+import { JcChatBuilder } from './jc.chat.js';
+import { JcChatMessageBuilder } from './jc.chat-message.js';
+import { JcCheckboxBuilder } from './jc.checkbox.js';
+import { JcChoiceFieldBuilder } from './jc.choice-field.js';
+import { JcChoiceFieldItemBuilder } from './jc.choice-field-item.js';
+import { JcCountDownBuilder } from './jc.count-down.js';
+import { JcCountUpBuilder } from './jc.count-up.js';
+import { JcCustomComponentInteropBuilder, } from './jc.custom-component.interop.js';
+import { JcDatePickerBuilder } from './jc.date-picker.js';
+import { JcDividerBuilder } from './jc.divider.js';
+import { JcDropdownBuilder } from './jc.dropdown.js';
+import { JcDurationPickerBuilder } from './jc.duration-picker.js';
+import { JcEmailFieldBuilder } from './jc.email-field.js';
+import { JcEntityBuilder } from './jc.entity.js';
+import { JcEntityFieldBuilder } from './jc.entity-field.js';
+import { JcEventBuilder } from './jc.event.js';
+import { JcExpanderBuilder } from './jc.expander.js';
+import { JcFieldRowBuilder } from './jc.field-row.js';
+import { JcEntityFieldRowBuilder } from './jc.field-row.entity.js';
+import { JcFormBuilder } from './jc.form.js';
+import { JcGalleryItemBuilder } from './jc.gallery-item.js';
+import { JcGridBuilder } from './jc.grid.js';
+import { JcGridItemBuilder } from './jc.grid-item.js';
+import { JcIconBuilder } from './jc.icon.js';
+import { JcImageOnCarouselBuilder } from './jc.image.on-carousel.js';
+import { JcJigBuilder } from './jc.jig.js';
+import { JcImageOnDefaultBuilder } from './jc.image.on-default.js';
+import { JcInteractiveImageBuilder } from './jc.interactive-image.js';
+import { JcInteractiveImageItemBuilder, } from './jc.interactive-image.item.js';
+import { JcJigHeaderBuilder } from './jc.jig-header.js';
+import { JcJigWidgetBuilder } from './jc.jig-widget.js';
+import { JcLineChartBuilder } from './jc.line-chart.js';
+import { JcListBuilder } from './jc.list.js';
+import { JcListItemBuilder } from './jc.list-item.js';
+import { JcListItemStandaloneBuilder, } from './jc.list-item.standalone.js';
+import { JcLocationBuilder } from './jc.location.js';
+import { JcMarkerItemBuilder } from './jc.marker-item.js';
+import { JcMediaFieldBuilder } from './jc.media-field.js';
+import { JcMenuItemBuilder } from './jc.menu-item.js';
+import { JcNumberFieldBuilder } from './jc.number-field.js';
+import { JcPieChartBuilder } from './jc.pie-chart.js';
+import { JcProgressBarBuilder } from './jc.progress-bar.js';
+import { JcRatingBuilder } from './jc.rating.js';
+import { JcSectionOnDefaultBuilder } from './jc.section.on-default.js';
+import { JcSegmentedControlBuilder } from './jc.segmented-control.js';
+import { JcSignatureFieldBuilder } from './jc.signature-field.js';
+import { JcSliderBuilder } from './jc.slider.js';
+import { JcStageBuilder } from './jc.stage.js';
+import { JcStepperBuilder } from './jc.stepper.js';
+import { JcStoryGroupBuilder } from './jc.story-group.js';
+import { JcSummaryCardBuilder } from './jc.summary.card.js';
+import { JcSummaryCounterBuilder } from './jc.summary.counter.js';
+import { JcSummaryDefaultBuilder } from './jc.summary.default.js';
+import { JcSummaryProgressBuilder, } from './jc.summary.progress.js';
+import { JcTextBuilder } from './jc.text.js';
+import { JcTextFieldBuilder } from './jc.text-field.js';
+import { JcTitlesBuilder } from './jc.titles.js';
+import { JcTrendBuilder } from './jc.trend.js';
+import { COMPONENT_TYPE } from './jc.types.js';
+import { JcViewBuilder } from './jc.view.js';
+import { JcVideoPlayerOnJigBuilder, } from './jc.video-player.on-jig.js';
+import { JcWebViewOnDefaultBuilder, } from './jc.web-view.on-default.js';
+import { JcWebViewOnFullBuilder } from './jc.web-view.on-full.js';
+export const COMPONENT_TO_FACTORY_METHOD = {
+    [COMPONENT_TYPE.AMOUNT_CONTROL]: 'amountControl',
+    [COMPONENT_TYPE.AVATAR]: 'avatar',
+    [COMPONENT_TYPE.AVATAR_FIELD]: 'avatarField',
+    [COMPONENT_TYPE.BANNER]: 'banner',
+    [COMPONENT_TYPE.BAR_CHART]: 'barChart',
+    [COMPONENT_TYPE.BUTTON]: 'button',
+    [COMPONENT_TYPE.CARD]: 'cardOnDefault',
+    [COMPONENT_TYPE.CAROUSEL]: 'carousel',
+    [COMPONENT_TYPE.CHAT]: 'chat',
+    [COMPONENT_TYPE.CHAT_MESSAGE]: 'chatMessage',
+    [COMPONENT_TYPE.CHECKBOX]: 'checkbox',
+    [COMPONENT_TYPE.CHOICE_FIELD]: 'choiceField',
+    [COMPONENT_TYPE.CHOICE_FIELD_ITEM]: 'choiceFieldItem',
+    [COMPONENT_TYPE.COUNTDOWN]: 'countDown',
+    [COMPONENT_TYPE.COUNT_UP]: 'countUp',
+    [COMPONENT_TYPE.CUSTOM_COMPONENT]: 'customComponent',
+    [COMPONENT_TYPE.DATE_PICKER]: 'datePicker',
+    [COMPONENT_TYPE.DIVIDER]: 'divider',
+    [COMPONENT_TYPE.DROPDOWN]: 'dropdown',
+    [COMPONENT_TYPE.DURATION_PICKER]: 'durationPicker',
+    [COMPONENT_TYPE.EMAIL_FIELD]: 'emailField',
+    [COMPONENT_TYPE.ENTITY]: 'entity',
+    [COMPONENT_TYPE.ENTITY_FIELD]: 'entityField',
+    [COMPONENT_TYPE.EVENT]: 'event',
+    [COMPONENT_TYPE.EXPANDER]: 'expander',
+    [COMPONENT_TYPE.FIELD_ROW]: 'fieldRow',
+    [COMPONENT_TYPE.FORM]: 'form',
+    [COMPONENT_TYPE.GALLERY_ITEM]: 'galleryItem',
+    [COMPONENT_TYPE.GRID]: 'grid',
+    [COMPONENT_TYPE.GRID_ITEM]: 'gridItem',
+    [COMPONENT_TYPE.ICON]: 'icon',
+    [COMPONENT_TYPE.IMAGE]: 'imageOnDefault',
+    [COMPONENT_TYPE.INTERACTIVE_IMAGE]: 'interactiveImage',
+    [COMPONENT_TYPE.INTERACTIVE_IMAGE_ITEM]: 'interactiveImageItem',
+    [COMPONENT_TYPE.JIG]: 'jig',
+    [COMPONENT_TYPE.JIG_HEADER]: 'jigHeader',
+    [COMPONENT_TYPE.JIG_WIDGET]: 'widget',
+    [COMPONENT_TYPE.LINE_CHART]: 'lineChart',
+    [COMPONENT_TYPE.LIST]: 'list',
+    [COMPONENT_TYPE.LIST_ITEM]: 'listItem',
+    [COMPONENT_TYPE.LOCATION]: 'location',
+    [COMPONENT_TYPE.MARKER_ITEM]: 'markerItem',
+    [COMPONENT_TYPE.MEDIA_FIELD]: 'mediaField',
+    [COMPONENT_TYPE.MENU_ITEM]: 'menuItem',
+    [COMPONENT_TYPE.NUMBER_FIELD]: 'numberField',
+    [COMPONENT_TYPE.PIE_CHART]: 'pieChart',
+    [COMPONENT_TYPE.PROGRESS_BAR]: 'progressBar',
+    [COMPONENT_TYPE.RATING]: 'rating',
+    [COMPONENT_TYPE.SECTION]: 'sectionOnDefault',
+    [COMPONENT_TYPE.SEGMENTED_CONTROL]: 'segmentedControl',
+    [COMPONENT_TYPE.SIGNATURE_FIELD]: 'signatureField',
+    [COMPONENT_TYPE.SLIDER]: 'slider',
+    [COMPONENT_TYPE.STAGE]: 'stage',
+    [COMPONENT_TYPE.STEPPER]: 'stepper',
+    [COMPONENT_TYPE.STORY_GROUP]: 'storyGroup',
+    [COMPONENT_TYPE.SUMMARY]: 'summaryDefault', // Output-only type; not directly constructable
+    [COMPONENT_TYPE.SUMMARY_DEFAULT]: 'summaryDefault',
+    [COMPONENT_TYPE.SUMMARY_CARD]: 'summaryCard',
+    [COMPONENT_TYPE.SUMMARY_COUNTER]: 'summaryCounter',
+    [COMPONENT_TYPE.SUMMARY_PROGRESS]: 'summaryProgress',
+    [COMPONENT_TYPE.TEXT]: 'text',
+    [COMPONENT_TYPE.TEXT_FIELD]: 'textField',
+    [COMPONENT_TYPE.TITLES]: 'titles',
+    [COMPONENT_TYPE.TREND]: 'trend',
+    [COMPONENT_TYPE.VIDEO_PLAYER]: 'videoPlayerOnJig',
+    [COMPONENT_TYPE.VIEW]: 'view',
+    [COMPONENT_TYPE.WEB_VIEW]: 'webViewOnDefault',
+    [COMPONENT_TYPE.DROPDOWN_ITEM]: 'choiceFieldItem',
+    [COMPONENT_TYPE.PRODUCT_ITEM]: 'gridItem',
+    [COMPONENT_TYPE.STEP]: 'stage',
+    [COMPONENT_TYPE.TAB_BUTTON]: 'segmentedControl',
+};
+export class JcBuilderFactory {
+    _allowed;
+    _onComponentCreated;
+    constructor(allowed, onComponentCreated) {
+        this._allowed = allowed;
+        this._onComponentCreated = onComponentCreated;
+    }
+    amountControl(options) {
+        if (!this._allowed.includes('component.amount-control')) {
+            throw new Error(`Component type 'amount-control' is not allowed in this context.`);
+        }
+        const builder = new JcAmountControlBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    avatar(options) {
+        if (!this._allowed.includes('component.avatar')) {
+            throw new Error(`Component type 'avatar' is not allowed in this context.`);
+        }
+        const builder = new JcAvatarBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    banner(options) {
+        if (!this._allowed.includes('component.banner')) {
+            throw new Error(`Component type 'banner' is not allowed in this context.`);
+        }
+        const builder = new JcBannerBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    button(options) {
+        if (!this._allowed.includes('component.button')) {
+            throw new Error(`Component type 'button' is not allowed in this context.`);
+        }
+        const builder = new JcButtonBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    barChart(options) {
+        if (!this._allowed.includes('component.bar-chart')) {
+            throw new Error(`Component type 'bar-chart' is not allowed in this context.`);
+        }
+        const builder = new JcBarChartBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    cardOnDefault(options = {}) {
+        if (!this._allowed.includes('component.card')) {
+            throw new Error(`Component type 'cardOnDefault' is not allowed in this context.`);
+        }
+        const builder = new JcCardOnDefaultBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    carousel(options = {}) {
+        if (!this._allowed.includes('component.carousel')) {
+            throw new Error(`Component type 'carousel' is not allowed in this context.`);
+        }
+        const builder = new JcCarouselBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    chat(options) {
+        if (!this._allowed.includes('component.chat')) {
+            throw new Error(`Component type 'chat' is not allowed in this context.`);
+        }
+        const builder = new JcChatBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    choiceFieldItem(options) {
+        if (!this._allowed.includes('component.choice-field-item')) {
+            throw new Error(`Component type 'choiceFieldItem' is not allowed in this context.`);
+        }
+        const builder = new JcChoiceFieldItemBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    countDown(options) {
+        if (!this._allowed.includes('component.countdown')) {
+            throw new Error(`Component type 'countDown' is not allowed in this context.`);
+        }
+        const builder = new JcCountDownBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    countUp(options) {
+        if (!this._allowed.includes('component.count-up')) {
+            throw new Error(`Component type 'countUp' is not allowed in this context.`);
+        }
+        const builder = new JcCountUpBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    customComponent(options) {
+        if (!this._allowed.includes('component.custom-component')) {
+            throw new Error(`Component type 'customComponent' is not allowed in this context.`);
+        }
+        const builder = JcCustomComponentInteropBuilder.from(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    entity(options = {}) {
+        if (!this._allowed.includes('component.entity')) {
+            throw new Error(`Component type 'entity' is not allowed in this context.`);
+        }
+        const builder = new JcEntityBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    entityField(options) {
+        if (!this._allowed.includes('component.entity-field')) {
+            throw new Error(`Component type 'entityField' is not allowed in this context.`);
+        }
+        const builder = new JcEntityFieldBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    entityFieldRow(options) {
+        if (!this._allowed.includes('component.field-row')) {
+            throw new Error(`Component type 'entityFieldRow' is not allowed in this context.`);
+        }
+        const builder = new JcEntityFieldRowBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    event(options = {}) {
+        if (!this._allowed.includes('component.event')) {
+            throw new Error(`Component type 'event' is not allowed in this context.`);
+        }
+        const builder = new JcEventBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    expander(options = {}) {
+        if (!this._allowed.includes('component.expander')) {
+            throw new Error(`Component type 'expander' is not allowed in this context.`);
+        }
+        const builder = new JcExpanderBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    form(options = {}) {
+        if (!this._allowed.includes('component.form')) {
+            throw new Error(`Component type 'form' is not allowed in this context.`);
+        }
+        const builder = new JcFormBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    galleryItem(options) {
+        if (!this._allowed.includes('component.gallery-item')) {
+            throw new Error(`Component type 'component.gallery-item' is not allowed in this context.`);
+        }
+        const builder = new JcGalleryItemBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    grid(options) {
+        if (!this._allowed.includes('component.grid')) {
+            throw new Error(`Component type 'grid' is not allowed in this context.`);
+        }
+        const builder = new JcGridBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    gridItem(options) {
+        if (!this._allowed.includes('component.grid-item')) {
+            throw new Error(`Component type 'gridItem' is not allowed in this context.`);
+        }
+        const builder = new JcGridItemBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    icon(options) {
+        if (!this._allowed.includes('component.icon')) {
+            throw new Error(`Component type 'icon' is not allowed in this context.`);
+        }
+        const builder = new JcIconBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    imageOnCarousel(options) {
+        if (!this._allowed.includes('component.image')) {
+            throw new Error(`Component type 'imageOnCarousel' is not allowed in this context.`);
+        }
+        const builder = new JcImageOnCarouselBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    imageOnDefault(options) {
+        if (!this._allowed.includes('component.image')) {
+            throw new Error(`Component type 'imageOnDefault' is not allowed in this context.`);
+        }
+        const builder = new JcImageOnDefaultBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    interactiveImage(options) {
+        if (!this._allowed.includes('component.interactive-image')) {
+            throw new Error(`Component type 'interactiveImage' is not allowed in this context.`);
+        }
+        const builder = new JcInteractiveImageBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    jig(options) {
+        if (!this._allowed.includes('component.jig')) {
+            throw new Error(`Component type 'jig' is not allowed in this context.`);
+        }
+        const builder = new JcJigBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    jigHeader(options = {}) {
+        if (!this._allowed.includes('component.jig-header')) {
+            throw new Error(`Component type 'jigHeader' is not allowed in this context.`);
+        }
+        const builder = new JcJigHeaderBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    lineChart(options) {
+        if (!this._allowed.includes('component.line-chart')) {
+            throw new Error(`Component type 'lineChart' is not allowed in this context.`);
+        }
+        const builder = new JcLineChartBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    list(options) {
+        if (!this._allowed.includes('component.list')) {
+            throw new Error(`Component type 'list' is not allowed in this context.`);
+        }
+        const builder = new JcListBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    listItemStandalone(options) {
+        if (!this._allowed.includes('component.list-item')) {
+            throw new Error(`Component type 'listItemStandalone' is not allowed in this context.`);
+        }
+        const builder = new JcListItemStandaloneBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    location(options) {
+        if (!this._allowed.includes('component.location')) {
+            throw new Error(`Component type 'location' is not allowed in this context.`);
+        }
+        const builder = new JcLocationBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    markerItem(options) {
+        if (!this._allowed.includes('component.marker-item')) {
+            throw new Error(`Component type 'markerItem' is not allowed in this context.`);
+        }
+        const builder = new JcMarkerItemBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    pieChart(options) {
+        if (!this._allowed.includes('component.pie-chart')) {
+            throw new Error(`Component type 'pieChart' is not allowed in this context.`);
+        }
+        const builder = new JcPieChartBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    progressBar(options) {
+        if (!this._allowed.includes('component.progress-bar')) {
+            throw new Error(`Component type 'progressBar' is not allowed in this context.`);
+        }
+        const builder = new JcProgressBarBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    rating(options) {
+        if (!this._allowed.includes('component.rating')) {
+            throw new Error(`Component type 'rating' is not allowed in this context.`);
+        }
+        const builder = new JcRatingBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    stage(options) {
+        if (!this._allowed.includes('component.stage')) {
+            throw new Error(`Component type 'stage' is not allowed in this context.`);
+        }
+        const builder = new JcStageBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    stepper(options = {}) {
+        if (!this._allowed.includes('component.stepper')) {
+            throw new Error(`Component type 'stepper' is not allowed in this context.`);
+        }
+        const builder = new JcStepperBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    storyGroup(options) {
+        if (!this._allowed.includes('component.story-group')) {
+            throw new Error(`Component type 'story-group' is not allowed in this context.`);
+        }
+        const builder = new JcStoryGroupBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    summaryDefault(options) {
+        if (!this._allowed.includes('component.summary-default')) {
+            throw new Error(`Component type 'summary-default' is not allowed in this context.`);
+        }
+        const builder = new JcSummaryDefaultBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    summaryCard(options) {
+        if (!this._allowed.includes('component.summary-card')) {
+            throw new Error(`Component type 'summary-card' is not allowed in this context.`);
+        }
+        const builder = new JcSummaryCardBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    summaryCounter(options) {
+        if (!this._allowed.includes('component.summary-counter')) {
+            throw new Error(`Component type 'summary-counter' is not allowed in this context.`);
+        }
+        const builder = new JcSummaryCounterBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    summaryProgress(options) {
+        if (!this._allowed.includes('component.summary-progress')) {
+            throw new Error(`Component type 'summary-progress' is not allowed in this context.`);
+        }
+        const builder = new JcSummaryProgressBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    text(options) {
+        if (!this._allowed.includes('component.text')) {
+            throw new Error(`Component type 'text' is not allowed in this context.`);
+        }
+        const builder = new JcTextBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    titles(options) {
+        if (!this._allowed.includes('component.titles')) {
+            throw new Error(`Component type 'titles' is not allowed in this context.`);
+        }
+        const builder = new JcTitlesBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    trend(options = {}) {
+        if (!this._allowed.includes('component.trend')) {
+            throw new Error(`Component type 'trend' is not allowed in this context.`);
+        }
+        const builder = new JcTrendBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    videoPlayerOnJig(options) {
+        if (!this._allowed.includes('component.video-player')) {
+            throw new Error(`Component type 'videoPlayerOnJig' is not allowed in this context.`);
+        }
+        const builder = new JcVideoPlayerOnJigBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    view(options) {
+        if (!this._allowed.includes('component.view')) {
+            throw new Error(`Component type 'view' is not allowed in this context.`);
+        }
+        const builder = new JcViewBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    webViewOnDefault(options = {}) {
+        if (!this._allowed.includes('component.web-view')) {
+            throw new Error(`Component type 'webViewOnDefault' is not allowed in this context.`);
+        }
+        const builder = new JcWebViewOnDefaultBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    webViewOnFull(options = {}) {
+        if (!this._allowed.includes('component.web-view')) {
+            throw new Error(`Component type 'webViewOnFull' is not allowed in this context.`);
+        }
+        const builder = new JcWebViewOnFullBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    widget(options) {
+        if (!this._allowed.includes('component.jig-widget')) {
+            throw new Error(`Component type 'widget' is not allowed in this context.`);
+        }
+        const builder = new JcJigWidgetBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    avatarField(options) {
+        if (!this._allowed.includes('component.avatar-field')) {
+            throw new Error(`Component type 'avatarField' is not allowed in this context.`);
+        }
+        const builder = new JcAvatarFieldBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    checkbox(options) {
+        if (!this._allowed.includes('component.checkbox')) {
+            throw new Error(`Component type 'checkbox' is not allowed in this context.`);
+        }
+        const builder = new JcCheckboxBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    choiceField(options) {
+        if (!this._allowed.includes('component.choice-field')) {
+            throw new Error(`Component type 'choiceField' is not allowed in this context.`);
+        }
+        const builder = new JcChoiceFieldBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    datePicker(options) {
+        if (!this._allowed.includes('component.date-picker')) {
+            throw new Error(`Component type 'datePicker' is not allowed in this context.`);
+        }
+        const builder = new JcDatePickerBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    divider(options) {
+        if (!this._allowed.includes('component.divider')) {
+            throw new Error(`Component type 'divider' is not allowed in this context.`);
+        }
+        const builder = new JcDividerBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    dropdown(options) {
+        const builder = new JcDropdownBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    durationPicker(options) {
+        const builder = new JcDurationPickerBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    emailField(options) {
+        const builder = new JcEmailFieldBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    fieldRow(options = {}) {
+        const builder = new JcFieldRowBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    mediaField(options) {
+        const builder = new JcMediaFieldBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    menuItem(options) {
+        if (!this._allowed.includes('component.menu-item')) {
+            throw new Error(`Component type 'menu-item' is not allowed in this context.`);
+        }
+        const builder = new JcMenuItemBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    numberField(options) {
+        const builder = new JcNumberFieldBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    sectionOnDefault(options = {}) {
+        const builder = new JcSectionOnDefaultBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    segmentedControl(options) {
+        const builder = new JcSegmentedControlBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    signatureField(options) {
+        const builder = new JcSignatureFieldBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    slider(options) {
+        if (!this._allowed.includes('component.slider')) {
+            throw new Error(`Component type 'slider' is not allowed in this context.`);
+        }
+        const builder = new JcSliderBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    textField(options) {
+        const builder = new JcTextFieldBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    chatMessage(options) {
+        const builder = new JcChatMessageBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    interactiveImageItem(options) {
+        const builder = new JcInteractiveImageItemBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+    listItem(options) {
+        const builder = new JcListItemBuilder(options);
+        this._onComponentCreated(builder);
+        return builder;
+    }
+}
+export const CAROUSEL_FACTORY_METHODS = {
+    ...COMPONENT_TO_FACTORY_METHOD,
+    [COMPONENT_TYPE.CARD]: 'card',
+    [COMPONENT_TYPE.IMAGE]: 'image',
+};
+export class JcCarouselFactory extends JcBuilderFactory {
+    constructor(allowed, onComponentCreated) {
+        super(allowed, onComponentCreated);
+    }
+    card(options) {
+        return super.cardOnDefault(options);
+    }
+    image(options) {
+        return super.imageOnCarousel(options);
+    }
+}
+export const FULL_SCREEN_FACTORY_METHODS = {
+    ...COMPONENT_TO_FACTORY_METHOD,
+    [COMPONENT_TYPE.WEB_VIEW]: 'webView',
+};
+export class JcFullScreenFactory extends JcBuilderFactory {
+    constructor(allowed, onComponentCreated) {
+        super(allowed, onComponentCreated);
+    }
+    webView(options) {
+        return super.webViewOnFull(options);
+    }
+}
+export const DEFAULT_SCREEN_FACTORY_METHODS = {
+    ...COMPONENT_TO_FACTORY_METHOD,
+    [COMPONENT_TYPE.CARD]: 'card',
+    [COMPONENT_TYPE.IMAGE]: 'image',
+    [COMPONENT_TYPE.LIST_ITEM]: 'listItem',
+    [COMPONENT_TYPE.SECTION]: 'section',
+    [COMPONENT_TYPE.SEGMENTED_CONTROL]: 'segmented',
+    [COMPONENT_TYPE.VIDEO_PLAYER]: 'videoPlayer',
+    [COMPONENT_TYPE.WEB_VIEW]: 'webView',
+};
+export class JcDefaultScreenFactory extends JcBuilderFactory {
+    constructor(allowed, onComponentCreated) {
+        super(allowed, onComponentCreated);
+    }
+    card(options) {
+        return super.cardOnDefault(options);
+    }
+    image(options) {
+        return super.imageOnDefault(options);
+    }
+    webView(options) {
+        return super.webViewOnDefault(options);
+    }
+    videoPlayer(options) {
+        return super.videoPlayerOnJig(options);
+    }
+    section(options) {
+        return super.sectionOnDefault(options);
+    }
+    listItem(options) {
+        return super.listItemStandalone(options);
+    }
+    segmented(options) {
+        return super.segmentedControl(options);
+    }
+}
+export const SUMMARY_FACTORY_METHODS = {
+    [COMPONENT_TYPE.SUMMARY_DEFAULT]: 'default',
+    [COMPONENT_TYPE.SUMMARY_CARD]: 'card',
+    [COMPONENT_TYPE.SUMMARY_COUNTER]: 'counter',
+};
+export class JcSummaryFactory extends JcBuilderFactory {
+    constructor(allowed, onComponentCreated) {
+        super(allowed, onComponentCreated);
+    }
+    default(options) {
+        return super.summaryDefault(options);
+    }
+    card(options) {
+        return super.summaryCard(options);
+    }
+    counter(options) {
+        return super.summaryCounter(options);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jc.abstract.factory.js","sourceRoot":"","sources":["../../src/component/jc.abstract.factory.ts"],"names":[],"mappings":"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","sourcesContent":["import { type InstanceId } from '../abstract/index.js'\nimport { JcAmountControlBuilder, type JcAmountControlInput } from './jc.amount-control.js'\nimport { JcAvatarBuilder, type JcAvatarInput } from './jc.avatar.js'\nimport { JcAvatarFieldBuilder, type JcAvatarFieldInput } from './jc.avatar-field.js'\nimport { JcBannerBuilder, type JcBannerInput } from './jc.banner.js'\nimport { JcBarChartBuilder, type JcBarChartInput } from './jc.bar-chart.js'\nimport { JcButtonBuilder, type JcButtonInput } from './jc.button.js'\nimport { JcCardOnDefaultBuilder, type JcCardOnDefaultInput } from './jc.card.on-default.js'\nimport { JcCarouselBuilder, type JcCarouselInput } from './jc.carousel.js'\nimport { JcChatBuilder, type JcChatInput } from './jc.chat.js'\nimport { JcChatMessageBuilder, type JcChatMessageInput } from './jc.chat-message.js'\nimport { JcCheckboxBuilder, type JcCheckboxInput } from './jc.checkbox.js'\nimport { JcChoiceFieldBuilder, type JcChoiceFieldInput } from './jc.choice-field.js'\nimport { JcChoiceFieldItemBuilder, type JcChoiceFieldItemInput } from './jc.choice-field-item.js'\nimport { JcCountDownBuilder, type JcCountDownInput } from './jc.count-down.js'\nimport { JcCountUpBuilder, type JcCountUpInput } from './jc.count-up.js'\nimport {\n  JcCustomComponentInteropBuilder,\n  type JcCustomComponentInteropInput,\n} from './jc.custom-component.interop.js'\nimport { JcDatePickerBuilder, type JcDatePickerInput } from './jc.date-picker.js'\nimport { JcDividerBuilder, type JcDividerInput } from './jc.divider.js'\nimport { JcDropdownBuilder, type JcDropdownInput } from './jc.dropdown.js'\nimport { JcDurationPickerBuilder, type JcDurationPickerInput } from './jc.duration-picker.js'\nimport { JcEmailFieldBuilder, type JcEmailFieldInput } from './jc.email-field.js'\nimport { JcEntityBuilder, type JcEntityInput } from './jc.entity.js'\nimport { JcEntityFieldBuilder, type JcEntityFieldInput } from './jc.entity-field.js'\nimport { JcEventBuilder, type JcEventInput } from './jc.event.js'\nimport { JcExpanderBuilder, type JcExpanderInput } from './jc.expander.js'\nimport { JcFieldRowBuilder, type JcFieldRowInput } from './jc.field-row.js'\nimport { JcEntityFieldRowBuilder } from './jc.field-row.entity.js'\nimport { JcFormBuilder, type JcFormInput } from './jc.form.js'\nimport { JcGalleryItemBuilder, type JcGalleryItemInput } from './jc.gallery-item.js'\nimport { JcGridBuilder, type JcGridInput } from './jc.grid.js'\nimport { JcGridItemBuilder, type JcGridItemInput } from './jc.grid-item.js'\nimport { JcIconBuilder, type JcIconInput } from './jc.icon.js'\nimport { JcImageOnCarouselBuilder, type JcImageOnCarouselInput } from './jc.image.on-carousel.js'\nimport { JcJigBuilder, type JcJigInput } from './jc.jig.js'\nimport { JcImageOnDefaultBuilder, type JcImageOnDefaultInput } from './jc.image.on-default.js'\nimport { JcInteractiveImageBuilder, type JcInteractiveImageInput } from './jc.interactive-image.js'\nimport {\n  JcInteractiveImageItemBuilder,\n  type JcInteractiveImageItemInput,\n} from './jc.interactive-image.item.js'\nimport { JcJigHeaderBuilder, type JcJigHeaderInput } from './jc.jig-header.js'\nimport { JcJigWidgetBuilder, type JcJigWidgetInput } from './jc.jig-widget.js'\nimport { JcLineChartBuilder, type JcLineChartInput } from './jc.line-chart.js'\nimport { JcListBuilder, type JcListInput } from './jc.list.js'\nimport { JcListItemBuilder, type JcListItemOptions } from './jc.list-item.js'\nimport {\n  JcListItemStandaloneBuilder,\n  type JcListItemStandaloneOptions,\n} from './jc.list-item.standalone.js'\nimport { JcLocationBuilder, type JcLocationInput } from './jc.location.js'\nimport { JcMarkerItemBuilder, type JcMarkerItemInput } from './jc.marker-item.js'\nimport { JcMediaFieldBuilder, type JcMediaFieldInput } from './jc.media-field.js'\nimport { JcMenuItemBuilder, type JcMenuItemInput } from './jc.menu-item.js'\nimport { JcNumberFieldBuilder, type JcNumberFieldInput } from './jc.number-field.js'\nimport { JcPieChartBuilder, type JcPieChartInput } from './jc.pie-chart.js'\nimport { JcProgressBarBuilder, type JcProgressBarInput } from './jc.progress-bar.js'\nimport { JcRatingBuilder, type JcRatingInput } from './jc.rating.js'\nimport { JcSectionOnDefaultBuilder, type JcSectionOnDefaultInput } from './jc.section.on-default.js'\nimport { JcSegmentedControlBuilder, type JcSegmentedControlInput } from './jc.segmented-control.js'\nimport { JcSignatureFieldBuilder, type JcSignatureFieldInput } from './jc.signature-field.js'\nimport { JcSliderBuilder, type JcSliderInput } from './jc.slider.js'\nimport { JcStageBuilder, type JcStageInput } from './jc.stage.js'\nimport { JcStepperBuilder, type JcStepperInput } from './jc.stepper.js'\nimport { JcStoryGroupBuilder, type JcStoryGroupInput } from './jc.story-group.js'\nimport { JcSummaryCardBuilder, type JcSummaryCardInputOptions } from './jc.summary.card.js'\nimport { JcSummaryCounterBuilder, type JcSummaryCounterInputOptions } from './jc.summary.counter.js'\nimport { JcSummaryDefaultBuilder, type JcSummaryDefaultInputOptions } from './jc.summary.default.js'\nimport {\n  JcSummaryProgressBuilder,\n  type JcSummaryProgressInputOptions,\n} from './jc.summary.progress.js'\nimport { JcTextBuilder, type JcTextInput } from './jc.text.js'\nimport { JcTextFieldBuilder, type JcTextFieldInput } from './jc.text-field.js'\nimport { JcTitlesBuilder, type JcTitlesInput } from './jc.titles.js'\nimport { JcTrendBuilder, type JcTrendInput } from './jc.trend.js'\nimport { COMPONENT_TYPE, type ComponentType } from './jc.types.js'\nimport { JcViewBuilder, type JcViewInput } from './jc.view.js'\nimport {\n  JcVideoPlayerOnJigBuilder,\n  type JcVideoPlayerOnJigInput,\n} from './jc.video-player.on-jig.js'\nimport {\n  JcWebViewOnDefaultBuilder,\n  type JcWebViewOnDefaultInput,\n} from './jc.web-view.on-default.js'\nimport { JcWebViewOnFullBuilder, type JcWebViewOnFullInput } from './jc.web-view.on-full.js'\n\n/* ========================================================================\n * BASE FACTORY - Core component factory with all creation methods\n * ======================================================================== */\n\n/**\n * Maps component types to their corresponding base factory method names.\n * Used to derive Pick types from ALLOWED_TYPES arrays.\n */\nexport const COMPONENT_TO_FACTORY_METHOD = {\n  [COMPONENT_TYPE.AMOUNT_CONTROL]: 'amountControl',\n  [COMPONENT_TYPE.AVATAR]: 'avatar',\n  [COMPONENT_TYPE.AVATAR_FIELD]: 'avatarField',\n  [COMPONENT_TYPE.BANNER]: 'banner',\n  [COMPONENT_TYPE.BAR_CHART]: 'barChart',\n  [COMPONENT_TYPE.BUTTON]: 'button',\n  [COMPONENT_TYPE.CARD]: 'cardOnDefault',\n  [COMPONENT_TYPE.CAROUSEL]: 'carousel',\n  [COMPONENT_TYPE.CHAT]: 'chat',\n  [COMPONENT_TYPE.CHAT_MESSAGE]: 'chatMessage',\n  [COMPONENT_TYPE.CHECKBOX]: 'checkbox',\n  [COMPONENT_TYPE.CHOICE_FIELD]: 'choiceField',\n  [COMPONENT_TYPE.CHOICE_FIELD_ITEM]: 'choiceFieldItem',\n  [COMPONENT_TYPE.COUNTDOWN]: 'countDown',\n  [COMPONENT_TYPE.COUNT_UP]: 'countUp',\n  [COMPONENT_TYPE.CUSTOM_COMPONENT]: 'customComponent',\n  [COMPONENT_TYPE.DATE_PICKER]: 'datePicker',\n  [COMPONENT_TYPE.DIVIDER]: 'divider',\n  [COMPONENT_TYPE.DROPDOWN]: 'dropdown',\n  [COMPONENT_TYPE.DURATION_PICKER]: 'durationPicker',\n  [COMPONENT_TYPE.EMAIL_FIELD]: 'emailField',\n  [COMPONENT_TYPE.ENTITY]: 'entity',\n  [COMPONENT_TYPE.ENTITY_FIELD]: 'entityField',\n  [COMPONENT_TYPE.EVENT]: 'event',\n  [COMPONENT_TYPE.EXPANDER]: 'expander',\n  [COMPONENT_TYPE.FIELD_ROW]: 'fieldRow',\n  [COMPONENT_TYPE.FORM]: 'form',\n  [COMPONENT_TYPE.GALLERY_ITEM]: 'galleryItem',\n  [COMPONENT_TYPE.GRID]: 'grid',\n  [COMPONENT_TYPE.GRID_ITEM]: 'gridItem',\n  [COMPONENT_TYPE.ICON]: 'icon',\n  [COMPONENT_TYPE.IMAGE]: 'imageOnDefault',\n  [COMPONENT_TYPE.INTERACTIVE_IMAGE]: 'interactiveImage',\n  [COMPONENT_TYPE.INTERACTIVE_IMAGE_ITEM]: 'interactiveImageItem',\n  [COMPONENT_TYPE.JIG]: 'jig',\n  [COMPONENT_TYPE.JIG_HEADER]: 'jigHeader',\n  [COMPONENT_TYPE.JIG_WIDGET]: 'widget',\n  [COMPONENT_TYPE.LINE_CHART]: 'lineChart',\n  [COMPONENT_TYPE.LIST]: 'list',\n  [COMPONENT_TYPE.LIST_ITEM]: 'listItem',\n  [COMPONENT_TYPE.LOCATION]: 'location',\n  [COMPONENT_TYPE.MARKER_ITEM]: 'markerItem',\n  [COMPONENT_TYPE.MEDIA_FIELD]: 'mediaField',\n  [COMPONENT_TYPE.MENU_ITEM]: 'menuItem',\n  [COMPONENT_TYPE.NUMBER_FIELD]: 'numberField',\n  [COMPONENT_TYPE.PIE_CHART]: 'pieChart',\n  [COMPONENT_TYPE.PROGRESS_BAR]: 'progressBar',\n  [COMPONENT_TYPE.RATING]: 'rating',\n  [COMPONENT_TYPE.SECTION]: 'sectionOnDefault',\n  [COMPONENT_TYPE.SEGMENTED_CONTROL]: 'segmentedControl',\n  [COMPONENT_TYPE.SIGNATURE_FIELD]: 'signatureField',\n  [COMPONENT_TYPE.SLIDER]: 'slider',\n  [COMPONENT_TYPE.STAGE]: 'stage',\n  [COMPONENT_TYPE.STEPPER]: 'stepper',\n  [COMPONENT_TYPE.STORY_GROUP]: 'storyGroup',\n  [COMPONENT_TYPE.SUMMARY]: 'summaryDefault', // Output-only type; not directly constructable\n  [COMPONENT_TYPE.SUMMARY_DEFAULT]: 'summaryDefault',\n  [COMPONENT_TYPE.SUMMARY_CARD]: 'summaryCard',\n  [COMPONENT_TYPE.SUMMARY_COUNTER]: 'summaryCounter',\n  [COMPONENT_TYPE.SUMMARY_PROGRESS]: 'summaryProgress',\n  [COMPONENT_TYPE.TEXT]: 'text',\n  [COMPONENT_TYPE.TEXT_FIELD]: 'textField',\n  [COMPONENT_TYPE.TITLES]: 'titles',\n  [COMPONENT_TYPE.TREND]: 'trend',\n  [COMPONENT_TYPE.VIDEO_PLAYER]: 'videoPlayerOnJig',\n  [COMPONENT_TYPE.VIEW]: 'view',\n  [COMPONENT_TYPE.WEB_VIEW]: 'webViewOnDefault',\n  [COMPONENT_TYPE.DROPDOWN_ITEM]: 'choiceFieldItem',\n  [COMPONENT_TYPE.PRODUCT_ITEM]: 'gridItem',\n  [COMPONENT_TYPE.STEP]: 'stage',\n  [COMPONENT_TYPE.TAB_BUTTON]: 'segmentedControl',\n} as const satisfies Record<ComponentType, keyof JcBuilderFactory>\n\n/**\n * Derives factory methods from component types array.\n * Usage: FactoryMethodsFor<typeof ALLOWED_TYPES>\n */\nexport type FactoryMethodsFor<T extends readonly ComponentType[]> =\n  T[number] extends keyof typeof COMPONENT_TO_FACTORY_METHOD\n    ? Pick<JcBuilderFactory, (typeof COMPONENT_TO_FACTORY_METHOD)[T[number]]>\n    : never\n\n/**\n * Derives union of builder types from allowed component types for base factory context.\n * Used by components that use JcBuilderFactory directly without a specialized factory.\n *\n * This type helper eliminates manual maintenance of builder union types\n * by automatically extracting return types from factory methods.\n *\n * Why we need this:\n * - Components need to store child builders with correct types\n * - Manually maintaining unions (e.g., JcImageBuilder | JcTextBuilder)\n *   is error-prone and violates DRY principle\n * - When ALLOWED_TYPES changes, the union type updates automatically\n *\n * How it works:\n * 1. Takes ALLOWED_TYPES array (e.g., [COMPONENT_TYPE.IMAGE, COMPONENT_TYPE.TEXT, ...])\n * 2. FactoryMethodsFor<T> maps to factory methods (e.g., { imageOnDefault: ..., widget: ... })\n * 3. [keyof ...] accesses all method signatures in the Pick type\n * 4. Conditional type with 'infer R' extracts the return type of each method\n * 5. Result is a union of all builder types that can be created\n */\nexport type BaseBuilderUnionFromAllowedTypes<T extends readonly ComponentType[]> =\n  FactoryMethodsFor<T>[keyof FactoryMethodsFor<T>] extends (...args: any[]) => infer R ? R : never\n\n/**\n * Internal factory class containing all JC component creation methods.\n * Components should use Pick<JCFactoryClass, ...> to select only the methods they need.\n * This avoids circular dependencies while maintaining full type safety.\n *\n * When instantiated with onComponentCreated callback, notifies parent of created components.\n * Generic type T allows automatic inference of component types from ALLOWED_TYPES.\n */\nexport class JcBuilderFactory<T extends readonly ComponentType[] = readonly ComponentType[]> {\n  protected readonly _allowed: T\n  /**\n   * Internal callback for component creation notification.\n   *\n   * Why we use 'unknown' here instead of BaseBuilderUnionFromAllowedTypes<T>:\n   * Each factory method (avatar(), button(), etc.) creates a specific builder type,\n   * but TypeScript cannot prove at compile-time that these concrete types are part\n   * of the generic union BaseBuilderUnionFromAllowedTypes<T>. Even though we have runtime\n   * guards checking _allowed.includes(), TypeScript's control flow analysis doesn't\n   * narrow generic type parameters. Using 'unknown' here is a pragmatic trade-off:\n   * - Type safety is enforced at the constructor boundary (public API)\n   * - Runtime checks ensure only allowed components are created\n   * - Internal implementation bypasses type checking for simplicity\n   * This is a common pattern when bridging generic constraints with concrete implementations.\n   */\n  protected readonly _onComponentCreated: (component: unknown) => void\n\n  constructor(\n    allowed: T,\n    onComponentCreated: (component: BaseBuilderUnionFromAllowedTypes<T>) => void,\n  ) {\n    this._allowed = allowed\n    // Type-erase for internal use while maintaining type safety at the boundary\n    this._onComponentCreated = onComponentCreated as (component: unknown) => void\n  }\n\n  /**\n   * Numeric increment/decrement control.\n   */\n  amountControl(options?: JcAmountControlInput): JcAmountControlBuilder {\n    if (!this._allowed.includes('component.amount-control')) {\n      throw new Error(`Component type 'amount-control' is not allowed in this context.`)\n    }\n    const builder = new JcAmountControlBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Circular user image with initials fallback.\n   */\n  avatar(options?: JcAvatarInput): JcAvatarBuilder {\n    if (!this._allowed.includes('component.avatar')) {\n      throw new Error(`Component type 'avatar' is not allowed in this context.`)\n    }\n    const builder = new JcAvatarBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Prominent informational message with icon, actions, and status styling.\n   */\n  banner(options: JcBannerInput): JcBannerBuilder {\n    if (!this._allowed.includes('component.banner')) {\n      throw new Error(`Component type 'banner' is not allowed in this context.`)\n    }\n    const builder = new JcBannerBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Standalone pressable button with icon and styling.\n   */\n  button(options: JcButtonInput): JcButtonBuilder {\n    if (!this._allowed.includes('component.button')) {\n      throw new Error(`Component type 'button' is not allowed in this context.`)\n    }\n    const builder = new JcButtonBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Displays categorical data as vertical/horizontal bars with multiple series support.\n   */\n  barChart(options?: JcBarChartInput): JcBarChartBuilder {\n    if (!this._allowed.includes('component.bar-chart')) {\n      throw new Error(`Component type 'bar-chart' is not allowed in this context.`)\n    }\n    const builder = new JcBarChartBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Groups content in flexible layouts with styling.\n   */\n  cardOnDefault(options: JcCardOnDefaultInput = {}): JcCardOnDefaultBuilder {\n    if (!this._allowed.includes('component.card')) {\n      throw new Error(`Component type 'cardOnDefault' is not allowed in this context.`)\n    }\n    const builder = new JcCardOnDefaultBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Horizontal swipeable gallery with pagination.\n   */\n  carousel(options: JcCarouselInput = {}): JcCarouselBuilder {\n    if (!this._allowed.includes('component.carousel')) {\n      throw new Error(`Component type 'carousel' is not allowed in this context.`)\n    }\n    const builder = new JcCarouselBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Builds chat components with message templates, send actions, data binding.\n   */\n  chat(options?: JcChatInput): JcChatBuilder {\n    if (!this._allowed.includes('component.chat')) {\n      throw new Error(`Component type 'chat' is not allowed in this context.`)\n    }\n    const builder = new JcChatBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Builds choice field items with title display and unique values.\n   */\n  choiceFieldItem(options?: JcChoiceFieldItemInput): JcChoiceFieldItemBuilder {\n    if (!this._allowed.includes('component.choice-field-item')) {\n      throw new Error(`Component type 'choiceFieldItem' is not allowed in this context.`)\n    }\n    const builder = new JcChoiceFieldItemBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Countdown timer to target date/time.\n   */\n  countDown(options?: JcCountDownInput): JcCountDownBuilder {\n    if (!this._allowed.includes('component.countdown')) {\n      throw new Error(`Component type 'countDown' is not allowed in this context.`)\n    }\n    const builder = new JcCountDownBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Animated number counter from start to end.\n   */\n  countUp(options?: JcCountUpInput): JcCountUpBuilder {\n    if (!this._allowed.includes('component.count-up')) {\n      throw new Error(`Component type 'countUp' is not allowed in this context.`)\n    }\n    const builder = new JcCountUpBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Load deprecated custom components from YAML/JSON.\n   *\n   * @deprecated Custom components are deprecated. Prefer native SDK components.\n   */\n  customComponent(options: JcCustomComponentInteropInput): JcCustomComponentInteropBuilder {\n    if (!this._allowed.includes('component.custom-component')) {\n      throw new Error(`Component type 'customComponent' is not allowed in this context.`)\n    }\n    const builder = JcCustomComponentInteropBuilder.from(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  entity(options: JcEntityInput = {}): JcEntityBuilder {\n    if (!this._allowed.includes('component.entity')) {\n      throw new Error(`Component type 'entity' is not allowed in this context.`)\n    }\n    const builder = new JcEntityBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  entityField(options?: JcEntityFieldInput): JcEntityFieldBuilder {\n    if (!this._allowed.includes('component.entity-field')) {\n      throw new Error(`Component type 'entityField' is not allowed in this context.`)\n    }\n    const builder = new JcEntityFieldBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  entityFieldRow(options?: { instanceId?: InstanceId }): JcEntityFieldRowBuilder {\n    if (!this._allowed.includes('component.field-row')) {\n      throw new Error(`Component type 'entityFieldRow' is not allowed in this context.`)\n    }\n    const builder = new JcEntityFieldRowBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  event(options: JcEventInput = {}): JcEventBuilder {\n    if (!this._allowed.includes('component.event')) {\n      throw new Error(`Component type 'event' is not allowed in this context.`)\n    }\n    const builder = new JcEventBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Builds collapsible content sections with headers and animations.\n   * @alias component.expander\n   */\n  expander(options: JcExpanderInput = {}): JcExpanderBuilder {\n    if (!this._allowed.includes('component.expander')) {\n      throw new Error(`Component type 'expander' is not allowed in this context.`)\n    }\n    const builder = new JcExpanderBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Builds input field groups with state management.\n   */\n  form(options: JcFormInput = {}): JcFormBuilder {\n    if (!this._allowed.includes('component.form')) {\n      throw new Error(`Component type 'form' is not allowed in this context.`)\n    }\n    const builder = new JcFormBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Image item for gallery screens.\n   */\n  galleryItem(options: JcGalleryItemInput): JcGalleryItemBuilder {\n    if (!this._allowed.includes('component.gallery-item')) {\n      throw new Error(`Component type 'component.gallery-item' is not allowed in this context.`)\n    }\n    const builder = new JcGalleryItemBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Multi-column layout with flexible item sizing.\n   */\n  grid(options?: JcGridInput): JcGridBuilder {\n    if (!this._allowed.includes('component.grid')) {\n      throw new Error(`Component type 'grid' is not allowed in this context.`)\n    }\n    const builder = new JcGridBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  gridItem(options?: JcGridItemInput): JcGridItemBuilder {\n    if (!this._allowed.includes('component.grid-item')) {\n      throw new Error(`Component type 'gridItem' is not allowed in this context.`)\n    }\n    const builder = new JcGridItemBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Renders system icons with color and size.\n   */\n  icon(options?: JcIconInput): JcIconBuilder {\n    if (!this._allowed.includes('component.icon')) {\n      throw new Error(`Component type 'icon' is not allowed in this context.`)\n    }\n    const builder = new JcIconBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  imageOnCarousel(options?: JcImageOnCarouselInput): JcImageOnCarouselBuilder {\n    if (!this._allowed.includes('component.image')) {\n      throw new Error(`Component type 'imageOnCarousel' is not allowed in this context.`)\n    }\n    const builder = new JcImageOnCarouselBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Builds image components with sizing.\n   */\n  imageOnDefault(options?: JcImageOnDefaultInput): JcImageOnDefaultBuilder {\n    if (!this._allowed.includes('component.image')) {\n      throw new Error(`Component type 'imageOnDefault' is not allowed in this context.`)\n    }\n    const builder = new JcImageOnDefaultBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Displays images with clickable hotspots.\n   */\n  interactiveImage(options?: JcInteractiveImageInput): JcInteractiveImageBuilder {\n    if (!this._allowed.includes('component.interactive-image')) {\n      throw new Error(`Component type 'interactiveImage' is not allowed in this context.`)\n    }\n    const builder = new JcInteractiveImageBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Embeds a jig as a component within another screen.\n   */\n  jig(options: JcJigInput): JcJigBuilder {\n    if (!this._allowed.includes('component.jig')) {\n      throw new Error(`Component type 'jig' is not allowed in this context.`)\n    }\n    const builder = new JcJigBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  jigHeader(options: JcJigHeaderInput = {}): JcJigHeaderBuilder {\n    if (!this._allowed.includes('component.jig-header')) {\n      throw new Error(`Component type 'jigHeader' is not allowed in this context.`)\n    }\n    const builder = new JcJigHeaderBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Displays time-series data as lines.\n   */\n  lineChart(options?: JcLineChartInput): JcLineChartBuilder {\n    if (!this._allowed.includes('component.line-chart')) {\n      throw new Error(`Component type 'lineChart' is not allowed in this context.`)\n    }\n    const builder = new JcLineChartBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Vertical/horizontal scrollable data list.\n   */\n  list(options?: JcListInput & { instanceId?: InstanceId }): JcListBuilder {\n    if (!this._allowed.includes('component.list')) {\n      throw new Error(`Component type 'list' is not allowed in this context.`)\n    }\n    const builder = new JcListBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  listItemStandalone(\n    options?: JcListItemStandaloneOptions & { instanceId?: InstanceId },\n  ): JcListItemStandaloneBuilder {\n    if (!this._allowed.includes('component.list-item')) {\n      throw new Error(`Component type 'listItemStandalone' is not allowed in this context.`)\n    }\n    const builder = new JcListItemStandaloneBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Interactive map with markers, paths, user location.\n   */\n  location(options?: JcLocationInput): JcLocationBuilder {\n    if (!this._allowed.includes('component.location')) {\n      throw new Error(`Component type 'location' is not allowed in this context.`)\n    }\n    const builder = new JcLocationBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  markerItem(options?: JcMarkerItemInput): JcMarkerItemBuilder {\n    if (!this._allowed.includes('component.marker-item')) {\n      throw new Error(`Component type 'markerItem' is not allowed in this context.`)\n    }\n    const builder = new JcMarkerItemBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Shows proportional data as pie slices.\n   */\n  pieChart(options?: JcPieChartInput): JcPieChartBuilder {\n    if (!this._allowed.includes('component.pie-chart')) {\n      throw new Error(`Component type 'pieChart' is not allowed in this context.`)\n    }\n    const builder = new JcPieChartBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Visual progress indicator with percentage.\n   */\n  progressBar(options?: JcProgressBarInput): JcProgressBarBuilder {\n    if (!this._allowed.includes('component.progress-bar')) {\n      throw new Error(`Component type 'progressBar' is not allowed in this context.`)\n    }\n    const builder = new JcProgressBarBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Rating input with customizable icons and maximum values.\n   */\n  rating(options: JcRatingInput): JcRatingBuilder {\n    if (!this._allowed.includes('component.rating')) {\n      throw new Error(`Component type 'rating' is not allowed in this context.`)\n    }\n    const builder = new JcRatingBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  stage(options?: JcStageInput): JcStageBuilder {\n    if (!this._allowed.includes('component.stage')) {\n      throw new Error(`Component type 'stage' is not allowed in this context.`)\n    }\n    const builder = new JcStageBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  stepper(options: JcStepperInput = {}): JcStepperBuilder {\n    if (!this._allowed.includes('component.stepper')) {\n      throw new Error(`Component type 'stepper' is not allowed in this context.`)\n    }\n    const builder = new JcStepperBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Swipeable story carousel with conditional item rendering.\n   */\n  storyGroup(options: JcStoryGroupInput): JcStoryGroupBuilder {\n    if (!this._allowed.includes('component.story-group')) {\n      throw new Error(`Component type 'story-group' is not allowed in this context.`)\n    }\n    const builder = new JcStoryGroupBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  summaryDefault(options?: JcSummaryDefaultInputOptions): JcSummaryDefaultBuilder {\n    if (!this._allowed.includes('component.summary-default')) {\n      throw new Error(`Component type 'summary-default' is not allowed in this context.`)\n    }\n    const builder = new JcSummaryDefaultBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  summaryCard(options?: JcSummaryCardInputOptions): JcSummaryCardBuilder {\n    if (!this._allowed.includes('component.summary-card')) {\n      throw new Error(`Component type 'summary-card' is not allowed in this context.`)\n    }\n    const builder = new JcSummaryCardBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  summaryCounter(options?: JcSummaryCounterInputOptions): JcSummaryCounterBuilder {\n    if (!this._allowed.includes('component.summary-counter')) {\n      throw new Error(`Component type 'summary-counter' is not allowed in this context.`)\n    }\n    const builder = new JcSummaryCounterBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  summaryProgress(options: JcSummaryProgressInputOptions): JcSummaryProgressBuilder {\n    if (!this._allowed.includes('component.summary-progress')) {\n      throw new Error(`Component type 'summary-progress' is not allowed in this context.`)\n    }\n    const builder = new JcSummaryProgressBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Displays formatted text with markdown support.\n   */\n  text(options?: JcTextInput): JcTextBuilder {\n    if (!this._allowed.includes('component.text')) {\n      throw new Error(`Component type 'text' is not allowed in this context.`)\n    }\n    const builder = new JcTextBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  titles(options?: JcTitlesInput): JcTitlesBuilder {\n    if (!this._allowed.includes('component.titles')) {\n      throw new Error(`Component type 'titles' is not allowed in this context.`)\n    }\n    const builder = new JcTitlesBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  trend(options: JcTrendInput = {}): JcTrendBuilder {\n    if (!this._allowed.includes('component.trend')) {\n      throw new Error(`Component type 'trend' is not allowed in this context.`)\n    }\n    const builder = new JcTrendBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Builds video players with playback controls.\n   */\n  videoPlayerOnJig(options?: JcVideoPlayerOnJigInput): JcVideoPlayerOnJigBuilder {\n    if (!this._allowed.includes('component.video-player')) {\n      throw new Error(`Component type 'videoPlayerOnJig' is not allowed in this context.`)\n    }\n    const builder = new JcVideoPlayerOnJigBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Container for custom layout with flex, spacing, borders, and children.\n   */\n  view(options?: JcViewInput): JcViewBuilder {\n    if (!this._allowed.includes('component.view')) {\n      throw new Error(`Component type 'view' is not allowed in this context.`)\n    }\n    const builder = new JcViewBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Builds web view components for displaying web content.\n   */\n  webViewOnDefault(options: JcWebViewOnDefaultInput = {}): JcWebViewOnDefaultBuilder {\n    if (!this._allowed.includes('component.web-view')) {\n      throw new Error(`Component type 'webViewOnDefault' is not allowed in this context.`)\n    }\n    const builder = new JcWebViewOnDefaultBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Full-screen web browser experience.\n   */\n  webViewOnFull(options: JcWebViewOnFullInput = {}): JcWebViewOnFullBuilder {\n    if (!this._allowed.includes('component.web-view')) {\n      throw new Error(`Component type 'webViewOnFull' is not allowed in this context.`)\n    }\n    const builder = new JcWebViewOnFullBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Builds screen widgets with target jig, inputs, press actions.\n   */\n  widget(options?: JcJigWidgetInput): JcJigWidgetBuilder {\n    if (!this._allowed.includes('component.jig-widget')) {\n      throw new Error(`Component type 'widget' is not allowed in this context.`)\n    }\n    const builder = new JcJigWidgetBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  // Field components\n  avatarField(options: JcAvatarFieldInput): JcAvatarFieldBuilder {\n    if (!this._allowed.includes('component.avatar-field')) {\n      throw new Error(`Component type 'avatarField' is not allowed in this context.`)\n    }\n    const builder = new JcAvatarFieldBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Binary toggle for true/false selections.\n   */\n  checkbox(options: JcCheckboxInput): JcCheckboxBuilder {\n    if (!this._allowed.includes('component.checkbox')) {\n      throw new Error(`Component type 'checkbox' is not allowed in this context.`)\n    }\n    const builder = new JcCheckboxBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  choiceField(options: JcChoiceFieldInput): JcChoiceFieldBuilder {\n    if (!this._allowed.includes('component.choice-field')) {\n      throw new Error(`Component type 'choiceField' is not allowed in this context.`)\n    }\n    const builder = new JcChoiceFieldBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Selects dates and times with calendar interface.\n   */\n  datePicker(options: JcDatePickerInput): JcDatePickerBuilder {\n    if (!this._allowed.includes('component.date-picker')) {\n      throw new Error(`Component type 'datePicker' is not allowed in this context.`)\n    }\n    const builder = new JcDatePickerBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Visual separator between content sections.\n   */\n  divider(options?: JcDividerInput): JcDividerBuilder {\n    if (!this._allowed.includes('component.divider')) {\n      throw new Error(`Component type 'divider' is not allowed in this context.`)\n    }\n    const builder = new JcDividerBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Builds dropdown fields for forms, with options, search, and validation.\n   * @alias component.dropdown\n   */\n  dropdown(options: JcDropdownInput): JcDropdownBuilder {\n    const builder = new JcDropdownBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Selects time durations (hours/minutes).\n   */\n  durationPicker(options: JcDurationPickerInput): JcDurationPickerBuilder {\n    const builder = new JcDurationPickerBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Validates email addresses with keyboard optimization.\n   */\n  emailField(options: JcEmailFieldInput): JcEmailFieldBuilder {\n    const builder = new JcEmailFieldBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  fieldRow(options: JcFieldRowInput = {}): JcFieldRowBuilder {\n    const builder = new JcFieldRowBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Captures photos/videos from device.\n   */\n  mediaField(options: JcMediaFieldInput): JcMediaFieldBuilder {\n    const builder = new JcMediaFieldBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Navigation menu entry with title, subtitle, left element, and press action.\n   */\n  menuItem(options: JcMenuItemInput): JcMenuItemBuilder {\n    if (!this._allowed.includes('component.menu-item')) {\n      throw new Error(`Component type 'menu-item' is not allowed in this context.`)\n    }\n    const builder = new JcMenuItemBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Collects numeric input with formatting and validation.\n   */\n  numberField(options: JcNumberFieldInput): JcNumberFieldBuilder {\n    const builder = new JcNumberFieldBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  sectionOnDefault(options: JcSectionOnDefaultInput = {}): JcSectionOnDefaultBuilder {\n    const builder = new JcSectionOnDefaultBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  segmentedControl(options?: JcSegmentedControlInput): JcSegmentedControlBuilder {\n    const builder = new JcSegmentedControlBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Captures hand-drawn signatures.\n   */\n  signatureField(options: JcSignatureFieldInput): JcSignatureFieldBuilder {\n    const builder = new JcSignatureFieldBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  slider(options: JcSliderInput): JcSliderBuilder {\n    if (!this._allowed.includes('component.slider')) {\n      throw new Error(`Component type 'slider' is not allowed in this context.`)\n    }\n    const builder = new JcSliderBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Collects text input with validation and formatting.\n   */\n  textField(options: JcTextFieldInput): JcTextFieldBuilder {\n    const builder = new JcTextFieldBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  // Additional components\n  chatMessage(options?: JcChatMessageInput): JcChatMessageBuilder {\n    const builder = new JcChatMessageBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  interactiveImageItem(options?: JcInteractiveImageItemInput): JcInteractiveImageItemBuilder {\n    const builder = new JcInteractiveImageItemBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n\n  /**\n   * Template for list data items with title, subtitle, elements.\n   */\n  listItem(options?: JcListItemOptions & { instanceId?: InstanceId }): JcListItemBuilder {\n    const builder = new JcListItemBuilder(options)\n    this._onComponentCreated(builder)\n    return builder\n  }\n}\n\n/* ========================================================================\n * CAROUSEL FACTORY - Context-specific factory for carousel components\n * ======================================================================== */\n\n/**\n * Maps component types to JcCarouselFactory methods.\n */\nexport const CAROUSEL_FACTORY_METHODS = {\n  ...COMPONENT_TO_FACTORY_METHOD,\n  // Override with carousel-specific aliases\n  [COMPONENT_TYPE.CARD]: 'card',\n  [COMPONENT_TYPE.IMAGE]: 'image',\n} as const\n\n/**\n * Derives factory methods for JcCarouselFactory.\n */\nexport type CarouselFactoryMethodsFor<T extends readonly ComponentType[]> =\n  T[number] extends keyof typeof CAROUSEL_FACTORY_METHODS\n    ? Pick<JcCarouselFactory, (typeof CAROUSEL_FACTORY_METHODS)[T[number]]>\n    : never\n\n/**\n * Derives union of builder types from allowed component types for carousel context.\n */\nexport type CarouselBuilderUnionFromAllowedTypes<T extends readonly ComponentType[]> =\n  CarouselFactoryMethodsFor<T>[keyof CarouselFactoryMethodsFor<T>] extends (\n    ...args: any[]\n  ) => infer R\n    ? R\n    : never\n\n/**\n * Context-specific factory for carousel components.\n */\nexport class JcCarouselFactory<\n  T extends readonly ComponentType[] = readonly ComponentType[],\n> extends JcBuilderFactory<T> {\n  constructor(\n    allowed: T,\n    onComponentCreated: (component: CarouselBuilderUnionFromAllowedTypes<T>) => void,\n  ) {\n    // Override to use carousel-specific builder union type\n    super(allowed, onComponentCreated as (component: BaseBuilderUnionFromAllowedTypes<T>) => void)\n  }\n  /**\n   * Groups content in flexible layouts with styling.\n   * @see cardOnDefault\n   */\n  card(\n    options?: Parameters<JcBuilderFactory['cardOnDefault']>[0],\n  ): ReturnType<JcBuilderFactory['cardOnDefault']> {\n    return super.cardOnDefault(options)\n  }\n\n  /**\n   * Displays images in carousel slides.\n   * @see imageOnCarousel\n   */\n  image(\n    options?: Parameters<JcBuilderFactory['imageOnCarousel']>[0],\n  ): ReturnType<JcBuilderFactory['imageOnCarousel']> {\n    return super.imageOnCarousel(options)\n  }\n}\n\n/* ========================================================================\n * FULL SCREEN FACTORY - Context-specific factory for full screen components\n * ======================================================================== */\n\n/**\n * Maps component types to JcFullScreenFactory methods.\n */\nexport const FULL_SCREEN_FACTORY_METHODS = {\n  ...COMPONENT_TO_FACTORY_METHOD,\n  // Override with full screen-specific aliases\n  [COMPONENT_TYPE.WEB_VIEW]: 'webView',\n} as const\n\n/**\n * Derives factory methods for JcFullScreenFactory.\n */\nexport type FullScreenFactoryMethodsFor<T extends readonly ComponentType[]> =\n  T[number] extends keyof typeof FULL_SCREEN_FACTORY_METHODS\n    ? Pick<JcFullScreenFactory, (typeof FULL_SCREEN_FACTORY_METHODS)[T[number]]>\n    : never\n\n/**\n * Derives union of builder types from allowed component types for full-screen context.\n */\nexport type FullScreenBuilderUnionFromAllowedTypes<T extends readonly ComponentType[]> =\n  FullScreenFactoryMethodsFor<T>[keyof FullScreenFactoryMethodsFor<T>] extends (\n    ...args: any[]\n  ) => infer R\n    ? R\n    : never\n\n/**\n * Context-specific factory for full screen components.\n */\nexport class JcFullScreenFactory<\n  T extends readonly ComponentType[] = readonly ComponentType[],\n> extends JcBuilderFactory<T> {\n  constructor(\n    allowed: T,\n    onComponentCreated: (component: FullScreenBuilderUnionFromAllowedTypes<T>) => void,\n  ) {\n    // Override to use full-screen-specific builder union type\n    super(allowed, onComponentCreated as (component: BaseBuilderUnionFromAllowedTypes<T>) => void)\n  }\n  /**\n   * Embeds web content in full screen mode.\n   * @see webViewOnFull\n   */\n  webView(\n    options?: Parameters<JcBuilderFactory['webViewOnFull']>[0],\n  ): ReturnType<JcBuilderFactory['webViewOnFull']> {\n    return super.webViewOnFull(options)\n  }\n}\n\n/* ========================================================================\n * DEFAULT SCREEN FACTORY - Context-specific factory for default screen components\n * ======================================================================== */\n\n/**\n * Maps component types to JcDefaultScreenFactory methods.\n * Extends the base factory methods with context-specific aliases.\n */\nexport const DEFAULT_SCREEN_FACTORY_METHODS = {\n  ...COMPONENT_TO_FACTORY_METHOD,\n  // Override with alias methods for cleaner names\n  [COMPONENT_TYPE.CARD]: 'card',\n  [COMPONENT_TYPE.IMAGE]: 'image',\n  [COMPONENT_TYPE.LIST_ITEM]: 'listItem',\n  [COMPONENT_TYPE.SECTION]: 'section',\n  [COMPONENT_TYPE.SEGMENTED_CONTROL]: 'segmented',\n  [COMPONENT_TYPE.VIDEO_PLAYER]: 'videoPlayer',\n  [COMPONENT_TYPE.WEB_VIEW]: 'webView',\n} as const\n\n/**\n * Derives factory methods for JcDefaultScreenFactory which includes aliases.\n * Usage: DefaultScreenFactoryMethodsFor<typeof ALLOWED_TYPES>\n */\nexport type DefaultScreenFactoryMethodsFor<T extends readonly ComponentType[]> =\n  T[number] extends keyof typeof DEFAULT_SCREEN_FACTORY_METHODS\n    ? Pick<JcDefaultScreenFactory, (typeof DEFAULT_SCREEN_FACTORY_METHODS)[T[number]]>\n    : never\n\n/**\n * Derives union of builder types from allowed component types for default screen context.\n * Maps to DefaultScreenFactory alias methods (e.g., image(), card(), webView()).\n */\nexport type DefaultScreenBuilderUnionFromAllowedTypes<T extends readonly ComponentType[]> =\n  DefaultScreenFactoryMethodsFor<T>[keyof DefaultScreenFactoryMethodsFor<T>] extends (\n    ...args: any[]\n  ) => infer R\n    ? R\n    : never\n\n/**\n * Context-specific factory for default screen components.\n * Generic type T automatically infers component types from ALLOWED_TYPES.\n */\nexport class JcDefaultScreenFactory<\n  T extends readonly ComponentType[] = readonly ComponentType[],\n> extends JcBuilderFactory<T> {\n  constructor(\n    allowed: T,\n    onComponentCreated: (component: DefaultScreenBuilderUnionFromAllowedTypes<T>) => void,\n  ) {\n    // Override to use default-screen-specific builder union type\n    super(allowed, onComponentCreated as (component: BaseBuilderUnionFromAllowedTypes<T>) => void)\n  }\n  /**\n   * Groups content in flexible layouts with styling.\n   * @see cardOnDefault\n   */\n  card(\n    options?: Parameters<JcBuilderFactory['cardOnDefault']>[0],\n  ): ReturnType<JcBuilderFactory['cardOnDefault']> {\n    return super.cardOnDefault(options)\n  }\n\n  /**\n   * Displays images with sizing and actions.\n   * @see imageOnDefault\n   */\n  image(\n    options?: Parameters<JcBuilderFactory['imageOnDefault']>[0],\n  ): ReturnType<JcBuilderFactory['imageOnDefault']> {\n    return super.imageOnDefault(options)\n  }\n\n  /**\n   * Embeds web content inline.\n   * @see webViewOnDefault\n   */\n  webView(\n    options?: Parameters<JcBuilderFactory['webViewOnDefault']>[0],\n  ): ReturnType<JcBuilderFactory['webViewOnDefault']> {\n    return super.webViewOnDefault(options)\n  }\n\n  /**\n   * Plays video content.\n   * @see videoPlayerOnJig\n   */\n  videoPlayer(\n    options?: Parameters<JcBuilderFactory['videoPlayerOnJig']>[0],\n  ): ReturnType<JcBuilderFactory['videoPlayerOnJig']> {\n    return super.videoPlayerOnJig(options)\n  }\n\n  /**\n   * Groups related form fields.\n   * @see sectionOnDefault\n   */\n  section(\n    options?: Parameters<JcBuilderFactory['sectionOnDefault']>[0],\n  ): ReturnType<JcBuilderFactory['sectionOnDefault']> {\n    return super.sectionOnDefault(options)\n  }\n\n  /**\n   * Standalone list item outside lists.\n   * @see listItemStandalone\n   */\n  override listItem(\n    options?: Parameters<JcBuilderFactory['listItemStandalone']>[0],\n  ): ReturnType<JcBuilderFactory['listItemStandalone']> {\n    return super.listItemStandalone(options)\n  }\n\n  /**\n   * Tab-like control for option selection.\n   * @see segmentedControl\n   */\n  segmented(\n    options?: Parameters<JcBuilderFactory['segmentedControl']>[0],\n  ): ReturnType<JcBuilderFactory['segmentedControl']> {\n    return super.segmentedControl(options)\n  }\n}\n\n/* ========================================================================\n * SUMMARY FACTORY - Context-specific factory for summary components\n * ======================================================================== */\n\n/**\n * Maps component types to JcSummaryFactory methods.\n * Provides aliases for summary-specific components.\n */\nexport const SUMMARY_FACTORY_METHODS = {\n  // ...COMPONENT_TO_FACTORY_METHOD,\n  // Summary-specific aliases\n  [COMPONENT_TYPE.SUMMARY_DEFAULT]: 'default',\n  [COMPONENT_TYPE.SUMMARY_CARD]: 'card',\n  [COMPONENT_TYPE.SUMMARY_COUNTER]: 'counter',\n} as const\n\n/**\n * Derives factory methods for JcSummaryFactory.\n */\nexport type SummaryFactoryMethodsFor<T extends readonly ComponentType[]> =\n  T[number] extends keyof typeof SUMMARY_FACTORY_METHODS\n    ? Pick<JcSummaryFactory, (typeof SUMMARY_FACTORY_METHODS)[T[number]]>\n    : never\n\n/**\n * Derives union of builder types from allowed component types for summary context.\n */\nexport type SummaryBuilderUnionFromAllowedTypes<T extends readonly ComponentType[]> =\n  SummaryFactoryMethodsFor<T>[keyof SummaryFactoryMethodsFor<T>] extends (...args: any[]) => infer R\n    ? R\n    : never\n\n/**\n * Context-specific factory for summary components.\n * Provides cleaner API with context-appropriate method names.\n */\nexport class JcSummaryFactory<\n  T extends readonly ComponentType[] = readonly ComponentType[],\n> extends JcBuilderFactory<T> {\n  constructor(\n    allowed: T,\n    onComponentCreated: (component: SummaryBuilderUnionFromAllowedTypes<T>) => void,\n  ) {\n    // Override to use summary-specific builder union type\n    super(allowed, onComponentCreated as (component: BaseBuilderUnionFromAllowedTypes<T>) => void)\n  }\n\n  /**\n   * Default summary with optional icon.\n   * @see summaryDefault\n   */\n  default(options?: JcSummaryDefaultInputOptions): JcSummaryDefaultBuilder {\n    return super.summaryDefault(options)\n  }\n\n  /**\n   * Cart summary with value and description.\n   * @see summaryCard\n   */\n  card(options?: JcSummaryCardInputOptions): JcSummaryCardBuilder {\n    return super.summaryCard(options)\n  }\n\n  /**\n   * Counter summary with numeric value.\n   * @see summaryCounter\n   */\n  counter(options?: JcSummaryCounterInputOptions): JcSummaryCounterBuilder {\n    return super.summaryCounter(options)\n  }\n}\n"]}