@jigx/core-sdk 1.0.0

package/dist/component/jc.form.js

@@ -0,0 +1,127 @@
+import { pushBuilderFactory, toBooleanOrExpression, } from '../abstract/index.js';
+import { ComponentBaseBuilder } from './jc.abstract.js';
+import { JcAvatarBuilder } from './jc.avatar.js';
+import { JcAmountControlBuilder } from './jc.amount-control.js';
+import { JcAvatarFieldBuilder } from './jc.avatar-field.js';
+import { JcBannerBuilder } from './jc.banner.js';
+import { JcBarChartBuilder } from './jc.bar-chart.js';
+import { JcCardOnDefaultBuilder } from './jc.card.on-default.js';
+import { JcCarouselBuilder } from './jc.carousel.js';
+import { JcCheckboxBuilder } from './jc.checkbox.js';
+import { JcChoiceFieldBuilder } from './jc.choice-field.js';
+import { JcCountDownBuilder } from './jc.count-down.js';
+import { JcCountUpBuilder } from './jc.count-up.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 { JcExpanderBuilder } from './jc.expander.js';
+import { JcFieldRowBuilder } from './jc.field-row.js';
+import { JcGridBuilder } from './jc.grid.js';
+import { JcImageOnDefaultBuilder } from './jc.image.on-default.js';
+import { JcInteractiveImageBuilder } from './jc.interactive-image.js';
+import { JcLineChartBuilder } from './jc.line-chart.js';
+import { JcListBuilder } from './jc.list.js';
+import { JcListItemStandaloneBuilder } from './jc.list-item.standalone.js';
+import { JcLocationBuilder } from './jc.location.js';
+import { JcMediaFieldBuilder } from './jc.media-field.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 { JcStepperBuilder } from './jc.stepper.js';
+import { JcTextFieldBuilder } from './jc.text-field.js';
+import { COMPONENT_TYPE } from './jc.types.js';
+import { JcVideoPlayerOnJigBuilder } from './jc.video-player.on-jig.js';
+import { JcWebViewOnDefaultBuilder } from './jc.web-view.on-default.js';
+export class JcFormBuilder extends ComponentBaseBuilder {
+    addControl = {
+        amountControl: pushBuilderFactory(JcAmountControlBuilder, this._config, 'children'),
+        carousel: pushBuilderFactory(JcCarouselBuilder, this._config, 'children'),
+        section: pushBuilderFactory(JcSectionOnDefaultBuilder, this._config, 'children'),
+        card: pushBuilderFactory(JcCardOnDefaultBuilder, this._config, 'children'),
+        image: pushBuilderFactory(JcImageOnDefaultBuilder, this._config, 'children'),
+        expander: pushBuilderFactory(JcExpanderBuilder, this._config, 'children'),
+        list: pushBuilderFactory(JcListBuilder, this._config, 'children'),
+        listItem: pushBuilderFactory(JcListItemStandaloneBuilder, this._config, 'children'),
+        location: pushBuilderFactory(JcLocationBuilder, this._config, 'children'),
+        progressBar: pushBuilderFactory(JcProgressBarBuilder, this._config, 'children'),
+        stepper: pushBuilderFactory(JcStepperBuilder, this._config, 'children'),
+        videoPlayer: pushBuilderFactory(JcVideoPlayerOnJigBuilder, this._config, 'children'),
+        webView: pushBuilderFactory(JcWebViewOnDefaultBuilder, this._config, 'children'),
+        interactiveImage: pushBuilderFactory(JcInteractiveImageBuilder, this._config, 'children'),
+        grid: pushBuilderFactory(JcGridBuilder, this._config, 'children'),
+        countDown: pushBuilderFactory(JcCountDownBuilder, this._config, 'children'),
+        countUp: pushBuilderFactory(JcCountUpBuilder, this._config, 'children'),
+        avatar: pushBuilderFactory(JcAvatarBuilder, this._config, 'children'),
+        banner: pushBuilderFactory(JcBannerBuilder, this._config, 'children'),
+        barChart: pushBuilderFactory(JcBarChartBuilder, this._config, 'children'),
+        entity: pushBuilderFactory(JcEntityBuilder, this._config, 'children'),
+        lineChart: pushBuilderFactory(JcLineChartBuilder, this._config, 'children'),
+        pieChart: pushBuilderFactory(JcPieChartBuilder, this._config, 'children'),
+        divider: pushBuilderFactory(JcDividerBuilder, this._config, 'children'),
+        segmented: pushBuilderFactory(JcSegmentedControlBuilder, this._config, 'children'),
+        textField: pushBuilderFactory(JcTextFieldBuilder, this._config, 'children'),
+        checkbox: pushBuilderFactory(JcCheckboxBuilder, this._config, 'children'),
+        choiceField: pushBuilderFactory(JcChoiceFieldBuilder, this._config, 'children'),
+        emailField: pushBuilderFactory(JcEmailFieldBuilder, this._config, 'children'),
+        numberField: pushBuilderFactory(JcNumberFieldBuilder, this._config, 'children'),
+        rating: pushBuilderFactory(JcRatingBuilder, this._config, 'children'),
+        dropdown: pushBuilderFactory(JcDropdownBuilder, this._config, 'children'),
+        datePicker: pushBuilderFactory(JcDatePickerBuilder, this._config, 'children'),
+        signatureField: pushBuilderFactory(JcSignatureFieldBuilder, this._config, 'children'),
+        slider: pushBuilderFactory(JcSliderBuilder, this._config, 'children'),
+        mediaField: pushBuilderFactory(JcMediaFieldBuilder, this._config, 'children'),
+        avatarField: pushBuilderFactory(JcAvatarFieldBuilder, this._config, 'children'),
+        durationPicker: pushBuilderFactory(JcDurationPickerBuilder, this._config, 'children'),
+        fieldRow: pushBuilderFactory(JcFieldRowBuilder, this._config, 'children'),
+    };
+    constructor(options = {}) {
+        super(COMPONENT_TYPE.FORM, options);
+        this.with(options);
+    }
+    with(options) {
+        super.with(options);
+        if (options?.isDiscardChangesAlertEnabled !== undefined) {
+            this._config.isDiscardChangesAlertEnabled = toBooleanOrExpression(options.isDiscardChangesAlertEnabled);
+        }
+        if (options?.initialValues !== undefined) {
+            this._config.initialValues = options.initialValues;
+        }
+        return this;
+    }
+    state = {
+        data: (excludeFields) => {
+            const instanceId = this.instanceId;
+            if (instanceId === undefined) {
+                throw new Error('Cannot access state of a form without an instanceId');
+            }
+            if (!excludeFields) {
+                return `@ctx.components.${instanceId}.state.data`;
+            }
+            const fieldExpr = Array.isArray(excludeFields) ? JSON.stringify(excludeFields) : excludeFields;
+            return `@ctx.components.${instanceId}.state.data ~> | $ | {}, function($v){$v?$v:[]}(${fieldExpr}) |`;
+        },
+        isValid: () => {
+            const instanceId = this.instanceId;
+            if (instanceId === undefined) {
+                throw new Error('Cannot access state of a form without an instanceId');
+            }
+            return `@ctx.components.${instanceId}.state.isValid`;
+        },
+    };
+    _validate() {
+        const config = this._config;
+        const children = config.children;
+        if (!Array.isArray(children) || children.length === 0) {
+            throw new Error('Form MUST have at least one control');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jc.form.js","sourceRoot":"","sources":["../../src/component/jc.form.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  type BooleanOrExpression,\n  type Expression,\n  pushBuilderFactory,\n  toBooleanOrExpression,\n} from '../abstract/index.js'\nimport { ComponentBaseBuilder, type JcBaseInput } from './jc.abstract.js'\nimport { JcAvatarBuilder } from './jc.avatar.js'\n\n// Import all form field builders\nimport { JcAmountControlBuilder } from './jc.amount-control.js'\nimport { JcAvatarFieldBuilder } from './jc.avatar-field.js'\nimport { JcBannerBuilder } from './jc.banner.js'\nimport { JcBarChartBuilder } from './jc.bar-chart.js'\nimport { JcCardOnDefaultBuilder } from './jc.card.on-default.js'\nimport { JcCarouselBuilder } from './jc.carousel.js'\nimport { JcCheckboxBuilder } from './jc.checkbox.js'\nimport { JcChoiceFieldBuilder } from './jc.choice-field.js'\nimport { JcCountDownBuilder } from './jc.count-down.js'\nimport { JcCountUpBuilder } from './jc.count-up.js'\nimport { JcDatePickerBuilder } from './jc.date-picker.js'\nimport { JcDividerBuilder } from './jc.divider.js'\nimport { JcDropdownBuilder } from './jc.dropdown.js'\nimport { JcDurationPickerBuilder } from './jc.duration-picker.js'\nimport { JcEmailFieldBuilder } from './jc.email-field.js'\nimport { JcEntityBuilder } from './jc.entity.js'\nimport { JcExpanderBuilder } from './jc.expander.js'\nimport { JcFieldRowBuilder } from './jc.field-row.js'\nimport { JcGridBuilder } from './jc.grid.js'\nimport { JcImageOnDefaultBuilder } from './jc.image.on-default.js'\nimport { JcInteractiveImageBuilder } from './jc.interactive-image.js'\nimport { JcLineChartBuilder } from './jc.line-chart.js'\nimport { JcListBuilder } from './jc.list.js'\nimport { JcListItemStandaloneBuilder } from './jc.list-item.standalone.js'\nimport { JcLocationBuilder } from './jc.location.js'\nimport { JcMediaFieldBuilder } from './jc.media-field.js'\nimport { JcNumberFieldBuilder } from './jc.number-field.js'\nimport { JcPieChartBuilder } from './jc.pie-chart.js'\nimport { JcProgressBarBuilder } from './jc.progress-bar.js'\nimport { JcRatingBuilder } from './jc.rating.js'\nimport { JcSectionOnDefaultBuilder } from './jc.section.on-default.js'\nimport { JcSegmentedControlBuilder } from './jc.segmented-control.js'\nimport { JcSignatureFieldBuilder } from './jc.signature-field.js'\nimport { JcSliderBuilder } from './jc.slider.js'\nimport { JcStepperBuilder } from './jc.stepper.js'\nimport { JcTextFieldBuilder } from './jc.text-field.js'\nimport { COMPONENT_TYPE } from './jc.types.js'\nimport { JcVideoPlayerOnJigBuilder } from './jc.video-player.on-jig.js'\nimport { JcWebViewOnDefaultBuilder } from './jc.web-view.on-default.js'\n\n/**\n * Form input interface.\n * @see #/definitions/jc-form\n * @alias form\n */\nexport interface JcFormInput extends JcBaseInput {\n  /**\n   * Show alert on unsaved changes.\n   * @default true\n   */\n  isDiscardChangesAlertEnabled?: BooleanOrExpression\n  initialValues?: Record<string, unknown> | Expression\n}\n\n/**\n * Build field groups with state.\n */\nexport class JcFormBuilder extends ComponentBaseBuilder<JcFormInput> {\n  /**\n   * Factory for form fields and layout.\n   * ~12 field types plus section/fieldRow.\n   * Auto-adds to form.\n   */\n  readonly addControl = {\n    amountControl: pushBuilderFactory(JcAmountControlBuilder, this._config, 'children'),\n    carousel: pushBuilderFactory(JcCarouselBuilder, this._config, 'children'),\n    section: pushBuilderFactory(JcSectionOnDefaultBuilder, this._config, 'children'),\n    card: pushBuilderFactory(JcCardOnDefaultBuilder, this._config, 'children'),\n    image: pushBuilderFactory(JcImageOnDefaultBuilder, this._config, 'children'),\n    expander: pushBuilderFactory(JcExpanderBuilder, this._config, 'children'),\n    list: pushBuilderFactory(JcListBuilder, this._config, 'children'),\n    listItem: pushBuilderFactory(JcListItemStandaloneBuilder, this._config, 'children'),\n    location: pushBuilderFactory(JcLocationBuilder, this._config, 'children'),\n    progressBar: pushBuilderFactory(JcProgressBarBuilder, this._config, 'children'),\n    stepper: pushBuilderFactory(JcStepperBuilder, this._config, 'children'),\n    videoPlayer: pushBuilderFactory(JcVideoPlayerOnJigBuilder, this._config, 'children'),\n    webView: pushBuilderFactory(JcWebViewOnDefaultBuilder, this._config, 'children'),\n    interactiveImage: pushBuilderFactory(JcInteractiveImageBuilder, this._config, 'children'),\n    grid: pushBuilderFactory(JcGridBuilder, this._config, 'children'),\n    countDown: pushBuilderFactory(JcCountDownBuilder, this._config, 'children'),\n    countUp: pushBuilderFactory(JcCountUpBuilder, this._config, 'children'),\n    avatar: pushBuilderFactory(JcAvatarBuilder, this._config, 'children'),\n    banner: pushBuilderFactory(JcBannerBuilder, this._config, 'children'),\n    barChart: pushBuilderFactory(JcBarChartBuilder, this._config, 'children'),\n    entity: pushBuilderFactory(JcEntityBuilder, this._config, 'children'),\n    lineChart: pushBuilderFactory(JcLineChartBuilder, this._config, 'children'),\n    pieChart: pushBuilderFactory(JcPieChartBuilder, this._config, 'children'),\n    divider: pushBuilderFactory(JcDividerBuilder, this._config, 'children'),\n    segmented: pushBuilderFactory(JcSegmentedControlBuilder, this._config, 'children'),\n    textField: pushBuilderFactory(JcTextFieldBuilder, this._config, 'children'),\n    checkbox: pushBuilderFactory(JcCheckboxBuilder, this._config, 'children'),\n    choiceField: pushBuilderFactory(JcChoiceFieldBuilder, this._config, 'children'),\n    emailField: pushBuilderFactory(JcEmailFieldBuilder, this._config, 'children'),\n    numberField: pushBuilderFactory(JcNumberFieldBuilder, this._config, 'children'),\n    rating: pushBuilderFactory(JcRatingBuilder, this._config, 'children'),\n    dropdown: pushBuilderFactory(JcDropdownBuilder, this._config, 'children'),\n    datePicker: pushBuilderFactory(JcDatePickerBuilder, this._config, 'children'),\n    signatureField: pushBuilderFactory(JcSignatureFieldBuilder, this._config, 'children'),\n    slider: pushBuilderFactory(JcSliderBuilder, this._config, 'children'),\n    mediaField: pushBuilderFactory(JcMediaFieldBuilder, this._config, 'children'),\n    avatarField: pushBuilderFactory(JcAvatarFieldBuilder, this._config, 'children'),\n    durationPicker: pushBuilderFactory(JcDurationPickerBuilder, this._config, 'children'),\n    fieldRow: pushBuilderFactory(JcFieldRowBuilder, this._config, 'children'),\n  }\n\n  constructor(options: JcFormInput = {}) {\n    super(COMPONENT_TYPE.FORM, options)\n    this.with(options)\n  }\n\n  override with(options?: Partial<Omit<JcFormInput, 'instanceId'>>): this {\n    super.with(options)\n\n    if (options?.isDiscardChangesAlertEnabled !== undefined) {\n      this._config.isDiscardChangesAlertEnabled = toBooleanOrExpression(\n        options.isDiscardChangesAlertEnabled,\n      )\n    }\n\n    if (options?.initialValues !== undefined) {\n      this._config.initialValues = options.initialValues\n    }\n\n    return this\n  }\n\n  state = {\n    // form data can be filtered to exclude fields\n    // use array of field or jsonata expression resulting to array of field names\n    data: (excludeFields?: string | string[]): string => {\n      const instanceId = this.instanceId\n      if (instanceId === undefined) {\n        throw new Error('Cannot access state of a form without an instanceId')\n      }\n      if (!excludeFields) {\n        return `@ctx.components.${instanceId}.state.data`\n      }\n\n      const fieldExpr = Array.isArray(excludeFields) ? JSON.stringify(excludeFields) : excludeFields\n\n      return `@ctx.components.${instanceId}.state.data ~> | $ | {}, function($v){$v?$v:[]}(${fieldExpr}) |`\n    },\n    isValid: (): string => {\n      const instanceId = this.instanceId\n      if (instanceId === undefined) {\n        throw new Error('Cannot access state of a form without an instanceId')\n      }\n      return `@ctx.components.${instanceId}.state.isValid`\n    },\n  }\n\n  override _validate(): void {\n    const config = this._config\n\n    const children = config.children\n\n    if (!Array.isArray(children) || children.length === 0) {\n      throw new Error('Form MUST have at least one control')\n    }\n  }\n}\n"]}

package/dist/component/jc.gallery-item.d.ts

@@ -0,0 +1,12 @@
+import { type Expression } from '../abstract/index.js';
+import { type JcBaseInput, ComponentBaseBuilder } from './jc.abstract.js';
+export interface JcGalleryItemInput extends JcBaseInput {
+    readonly imageUri: string | Expression;
+}
+export declare class JcGalleryItemBuilder extends ComponentBaseBuilder<JcGalleryItemInput> {
+    readonly onSharePress: import("../action/ja.in-background.factory.js").ActionInBackgroundBuilders;
+    readonly onDeletePress: import("../action/ja.in-background.factory.js").ActionInBackgroundBuilders;
+    constructor(options: JcGalleryItemInput);
+    with(options: Partial<Omit<JcGalleryItemInput, 'instanceId'>>): this;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/component/jc.gallery-item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jc.gallery-item.d.ts","sourceRoot":"","sources":["../../src/component/jc.gallery-item.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAwB,MAAM,sBAAsB,CAAA;AAE5E,OAAO,EAAE,KAAK,WAAW,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAGzE,MAAM,WAAW,kBAAmB,SAAQ,WAAW;IAErD,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,CAAA;CACvC;AAMD,qBAAa,oBAAqB,SAAQ,oBAAoB,CAAC,kBAAkB,CAAC;IAEhF,QAAQ,CAAC,YAAY,6EAEnB;IAGF,QAAQ,CAAC,aAAa,6EAEpB;IAEF,YAAY,OAAO,EAAE,kBAAkB,EAGtC;IAEQ,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,kBAAkB,EAAE,YAAY,CAAC,CAAC,GAAG,IAAI,CAQ5E;CACF","sourcesContent":["import { type Expression, toStringOrExpression } from '../abstract/index.js'\nimport { createActionInBackgroundBuildersFactory } from '../action/ja.in-background.factory.js'\nimport { type JcBaseInput, ComponentBaseBuilder } from './jc.abstract.js'\nimport { COMPONENT_TYPE } from './jc.types.js'\n\nexport interface JcGalleryItemInput extends JcBaseInput {\n  /** URL of the image to display. */\n  readonly imageUri: string | Expression\n}\n\n/**\n * Image item for use inside a gallery screen.\n * @alias component.gallery-item\n */\nexport class JcGalleryItemBuilder extends ComponentBaseBuilder<JcGalleryItemInput> {\n  /** Action triggered when the share button is pressed. */\n  readonly onSharePress = createActionInBackgroundBuildersFactory((action) => {\n    this._setToConfig('onSharePress', action)\n  })\n\n  /** Action triggered when the delete button is pressed. */\n  readonly onDeletePress = createActionInBackgroundBuildersFactory((action) => {\n    this._setToConfig('onDeletePress', action)\n  })\n\n  constructor(options: JcGalleryItemInput) {\n    super(COMPONENT_TYPE.GALLERY_ITEM, options)\n    this.with(options)\n  }\n\n  override with(options: Partial<Omit<JcGalleryItemInput, 'instanceId'>>): this {\n    super.with(options)\n\n    if (options.imageUri !== undefined) {\n      this._config.imageUri = toStringOrExpression(options.imageUri)\n    }\n\n    return this\n  }\n}\n"]}

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

@@ -0,0 +1,24 @@
+import { toStringOrExpression } from '../abstract/index.js';
+import { createActionInBackgroundBuildersFactory } from '../action/ja.in-background.factory.js';
+import { ComponentBaseBuilder } from './jc.abstract.js';
+import { COMPONENT_TYPE } from './jc.types.js';
+export class JcGalleryItemBuilder extends ComponentBaseBuilder {
+    onSharePress = createActionInBackgroundBuildersFactory((action) => {
+        this._setToConfig('onSharePress', action);
+    });
+    onDeletePress = createActionInBackgroundBuildersFactory((action) => {
+        this._setToConfig('onDeletePress', action);
+    });
+    constructor(options) {
+        super(COMPONENT_TYPE.GALLERY_ITEM, options);
+        this.with(options);
+    }
+    with(options) {
+        super.with(options);
+        if (options.imageUri !== undefined) {
+            this._config.imageUri = toStringOrExpression(options.imageUri);
+        }
+        return this;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/component/jc.grid-item.d.ts

@@ -0,0 +1,15 @@
+import { type GridItemSize } from './common/index.js';
+import { type DefaultScreenFactoryMethodsFor } from './jc.abstract.factory.js';
+import { type JcBaseInput, ComponentBaseBuilder } from './jc.abstract.js';
+declare const ALLOWED_TYPES: readonly ["component.jig-widget", "component.image"];
+export interface JcGridItemInput extends JcBaseInput {
+    readonly size?: GridItemSize;
+}
+export declare class JcGridItemBuilder extends ComponentBaseBuilder<JcGridItemInput> {
+    readonly addControl: DefaultScreenFactoryMethodsFor<typeof ALLOWED_TYPES>;
+    constructor(options?: JcGridItemInput);
+    size(size: GridItemSize | string): this;
+    with(options?: Partial<Omit<JcGridItemInput, 'instanceId'>>): this;
+}
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/component/jc.grid-item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jc.grid-item.d.ts","sourceRoot":"","sources":["../../src/component/jc.grid-item.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,YAAY,EAAkB,MAAM,mBAAmB,CAAA;AACrE,OAAO,EAEL,KAAK,8BAA8B,EACpC,MAAM,0BAA0B,CAAA;AACjC,OAAO,EAAE,KAAK,WAAW,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAEzE,QAAA,MAAM,aAAa,sDAKT,CAAA;AAKV,MAAM,WAAW,eAAgB,SAAQ,WAAW;IAClD,QAAQ,CAAC,IAAI,CAAC,EAAE,YAAY,CAAA;CAC7B;AAKD,qBAAa,iBAAkB,SAAQ,oBAAoB,CAAC,eAAe,CAAC;IAE1E,QAAQ,CAAC,UAAU,EAAE,8BAA8B,CAAC,OAAO,aAAa,CAAC,CAAA;IAEzE,YAAY,OAAO,GAAE,eAAoB,EAWxC;IAOD,IAAI,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,GAAG,IAAI,CAGtC;IAEQ,IAAI,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,eAAe,EAAE,YAAY,CAAC,CAAC,GAAG,IAAI,CAQ1E;CACF","sourcesContent":["import { COMPONENT_TYPE } from './jc.types.js'\nimport { type GridItemSize, toGridItemSize } from './common/index.js'\nimport {\n  JcDefaultScreenFactory,\n  type DefaultScreenFactoryMethodsFor,\n} from './jc.abstract.factory.js'\nimport { type JcBaseInput, ComponentBaseBuilder } from './jc.abstract.js'\n// Runtime validation: allowed component types for grid items\nconst ALLOWED_TYPES = [\n  COMPONENT_TYPE.JIG_WIDGET,\n  COMPONENT_TYPE.IMAGE,\n  // TODO: enable custom components IFF required\n  // COMPONENT_TYPE.CUSTOM_COMPONENT,\n] as const\n\n/**\n * Input options for grid item component.\n */\nexport interface JcGridItemInput extends JcBaseInput {\n  readonly size?: GridItemSize\n}\n\n/**\n * Builds grid cells with content.\n */\nexport class JcGridItemBuilder extends ComponentBaseBuilder<JcGridItemInput> {\n  /** Component factory for inline custom component children. */\n  readonly addControl: DefaultScreenFactoryMethodsFor<typeof ALLOWED_TYPES>\n\n  constructor(options: JcGridItemInput = {}) {\n    super(COMPONENT_TYPE.GRID_ITEM, options)\n\n    // Set defaults\n    this._config.size = '1x1'\n\n    this.addControl = new JcDefaultScreenFactory(ALLOWED_TYPES, (component) => {\n      this._setToConfig('children', component)\n    })\n\n    this.with(options)\n  }\n\n  /**\n   * Sets grid cell dimensions.\n   * Format: 'widthxheight' (e.g., '2x3').\n   * Width/height 1-4.\n   */\n  size(size: GridItemSize | string): this {\n    this._config.size = toGridItemSize(size) ?? '1x1'\n    return this\n  }\n\n  override with(options?: Partial<Omit<JcGridItemInput, 'instanceId'>>): this {\n    super.with(options)\n\n    if (options?.size !== undefined) {\n      this._config.size = toGridItemSize(options.size) ?? '1x1'\n    }\n\n    return this\n  }\n}\n"]}

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

@@ -0,0 +1,31 @@
+import { COMPONENT_TYPE } from './jc.types.js';
+import { toGridItemSize } from './common/index.js';
+import { JcDefaultScreenFactory, } from './jc.abstract.factory.js';
+import { ComponentBaseBuilder } from './jc.abstract.js';
+const ALLOWED_TYPES = [
+    COMPONENT_TYPE.JIG_WIDGET,
+    COMPONENT_TYPE.IMAGE,
+];
+export class JcGridItemBuilder extends ComponentBaseBuilder {
+    addControl;
+    constructor(options = {}) {
+        super(COMPONENT_TYPE.GRID_ITEM, options);
+        this._config.size = '1x1';
+        this.addControl = new JcDefaultScreenFactory(ALLOWED_TYPES, (component) => {
+            this._setToConfig('children', component);
+        });
+        this.with(options);
+    }
+    size(size) {
+        this._config.size = toGridItemSize(size) ?? '1x1';
+        return this;
+    }
+    with(options) {
+        super.with(options);
+        if (options?.size !== undefined) {
+            this._config.size = toGridItemSize(options.size) ?? '1x1';
+        }
+        return this;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,16 @@
+import { type Expression } from '../abstract/index.js';
+import { type JcBase, type JcBaseInput, ComponentBaseBuilder } from './jc.abstract.js';
+import { JcGridItemBuilder, type JcGridItemInput } from './jc.grid-item.js';
+export interface JcGridInput extends JcBaseInput {
+}
+export declare class JcGridBuilder extends ComponentBaseBuilder<JcGridInput> {
+    private _kind?;
+    constructor(options?: JcGridInput);
+    static(options?: JcGridItemInput): JcGridItemBuilder;
+    dynamic(dataExpression: string | Expression | Array<Record<string, unknown>>): this;
+    item(options?: JcGridItemInput): JcGridItemBuilder;
+    columns(columnCount: number): this;
+    spacing(spacing: number): this;
+    build(): JcBase;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"jc.grid.d.ts","sourceRoot":"","sources":["../../src/component/jc.grid.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAgB,MAAM,sBAAsB,CAAA;AACpE,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,WAAW,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AACtF,OAAO,EAAE,iBAAiB,EAAE,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAM3E,MAAM,WAAW,WAAY,SAAQ,WAAW;CAE/C;AAKD,qBAAa,aAAc,SAAQ,oBAAoB,CAAC,WAAW,CAAC;IAClE,OAAO,CAAC,KAAK,CAAC,CAAsB;IAEpC,YAAY,OAAO,GAAE,WAAgB,EAGpC;IAQD,MAAM,CAAC,OAAO,CAAC,EAAE,eAAe,GAAG,iBAAiB,CAWnD;IAQD,OAAO,CAAC,cAAc,EAAE,MAAM,GAAG,UAAU,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,IAAI,CAYlF;IAQD,IAAI,CAAC,OAAO,CAAC,EAAE,eAAe,GAAG,iBAAiB,CASjD;IAOD,OAAO,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAKjC;IAOD,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAK7B;IAEQ,KAAK,IAAI,MAAM,CAQvB;CACF","sourcesContent":["import { type Expression, toExpression } from '../abstract/index.js'\nimport { type JcBase, type JcBaseInput, ComponentBaseBuilder } from './jc.abstract.js'\nimport { JcGridItemBuilder, type JcGridItemInput } from './jc.grid-item.js'\nimport { COMPONENT_TYPE } from './jc.types.js'\n\n/**\n * Input options for grid component.\n */\nexport interface JcGridInput extends JcBaseInput {\n  // Grid mode determined by methods, not constructor options\n}\n\n/**\n * Builds responsive grid layouts.\n */\nexport class JcGridBuilder extends ComponentBaseBuilder<JcGridInput> {\n  private _kind?: 'static' | 'dynamic'\n\n  constructor(options: JcGridInput = {}) {\n    super(COMPONENT_TYPE.GRID, options)\n    this.with(options)\n  }\n\n  /**\n   * Adds item to custom grid (static/manual placement).\n   * Use for grids with mixed component types or specific layouts.\n   * @param options Grid item configuration\n   * @returns Grid item builder for adding child component\n   */\n  static(options?: JcGridItemInput): JcGridItemBuilder {\n    if (this._kind === 'dynamic') {\n      throw new Error('Cannot add children to a dynamic grid')\n    }\n    this._kind = 'static'\n\n    const children = (this._config.children ?? []) as JcGridItemBuilder[]\n    const builder = new JcGridItemBuilder(options)\n    children.push(builder)\n    this._config.children = children\n    return builder\n  }\n\n  /**\n   * Configures auto grid (dynamic/data-driven).\n   * Grid items generated from datasource with item template.\n   * @param dataExpression Data source expression or array\n   * @returns Grid builder for further configuration\n   */\n  dynamic(dataExpression: string | Expression | Array<Record<string, unknown>>): this {\n    if (this._kind === 'static') {\n      throw new Error('Cannot set data on a static grid')\n    }\n    this._kind = 'dynamic'\n\n    this._config.data =\n      typeof dataExpression === 'string' && dataExpression.startsWith('=')\n        ? toExpression(dataExpression)\n        : dataExpression\n\n    return this\n  }\n\n  /**\n   * Defines item template for auto grid.\n   * Template applied to each data item. Requires dynamic() first.\n   * @param options Item template configuration\n   * @returns Grid item builder for template definition\n   */\n  item(options?: JcGridItemInput): JcGridItemBuilder {\n    if (this._kind === 'static') {\n      throw new Error('item() can only be called after dynamic()')\n    }\n    this._kind = 'dynamic'\n\n    const builder = new JcGridItemBuilder(options)\n    this._config.item = builder\n    return builder\n  }\n\n  /**\n   * Sets column count for auto grid layout.\n   * Only applies to dynamic/auto grids.\n   * @param columnCount Number of columns\n   */\n  columns(columnCount: number): this {\n    if (this._kind === 'dynamic') {\n      this._config.columnCount = columnCount\n    }\n    return this\n  }\n\n  /**\n   * Sets gap between items in pixels.\n   * Only applies to dynamic/auto grids.\n   * @param spacing Gap size in pixels\n   */\n  spacing(spacing: number): this {\n    if (this._kind === 'dynamic') {\n      this._config.spacing = spacing\n    }\n    return this\n  }\n\n  override build(): JcBase {\n    if (!this._kind) {\n      throw new Error('Grid must be either static or dynamic with items')\n    }\n    if (this._kind === 'dynamic' && !this._config.item) {\n      throw new Error('Dynamic grid requires item template. Call .item() to define the template.')\n    }\n    return super.build()\n  }\n}\n"]}

package/dist/component/jc.grid.js

@@ -0,0 +1,64 @@
+import { toExpression } from '../abstract/index.js';
+import { ComponentBaseBuilder } from './jc.abstract.js';
+import { JcGridItemBuilder } from './jc.grid-item.js';
+import { COMPONENT_TYPE } from './jc.types.js';
+export class JcGridBuilder extends ComponentBaseBuilder {
+    _kind;
+    constructor(options = {}) {
+        super(COMPONENT_TYPE.GRID, options);
+        this.with(options);
+    }
+    static(options) {
+        if (this._kind === 'dynamic') {
+            throw new Error('Cannot add children to a dynamic grid');
+        }
+        this._kind = 'static';
+        const children = (this._config.children ?? []);
+        const builder = new JcGridItemBuilder(options);
+        children.push(builder);
+        this._config.children = children;
+        return builder;
+    }
+    dynamic(dataExpression) {
+        if (this._kind === 'static') {
+            throw new Error('Cannot set data on a static grid');
+        }
+        this._kind = 'dynamic';
+        this._config.data =
+            typeof dataExpression === 'string' && dataExpression.startsWith('=')
+                ? toExpression(dataExpression)
+                : dataExpression;
+        return this;
+    }
+    item(options) {
+        if (this._kind === 'static') {
+            throw new Error('item() can only be called after dynamic()');
+        }
+        this._kind = 'dynamic';
+        const builder = new JcGridItemBuilder(options);
+        this._config.item = builder;
+        return builder;
+    }
+    columns(columnCount) {
+        if (this._kind === 'dynamic') {
+            this._config.columnCount = columnCount;
+        }
+        return this;
+    }
+    spacing(spacing) {
+        if (this._kind === 'dynamic') {
+            this._config.spacing = spacing;
+        }
+        return this;
+    }
+    build() {
+        if (!this._kind) {
+            throw new Error('Grid must be either static or dynamic with items');
+        }
+        if (this._kind === 'dynamic' && !this._config.item) {
+            throw new Error('Dynamic grid requires item template. Call .item() to define the template.');
+        }
+        return super.build();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,17 @@
+import { type JcBase } from './jc.abstract.js';
+export declare function isComponentWithChildren(component: unknown): component is JcBase & {
+    options: {
+        children: JcBase[];
+    };
+};
+export declare function isComponentWithData(component: unknown): component is JcBase & {
+    options: {
+        data: Record<string, unknown>;
+    };
+};
+export declare function isComponentWithItem(component: unknown): component is JcBase & {
+    options: {
+        item: JcBase;
+    };
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiamMuZ3VhcmRzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29tcG9uZW50L2pjLmd1YXJkcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsS0FBSyxNQUFNLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQTtBQUU5Qyx3QkFBZ0IsdUJBQXVCLENBQ3JDLFNBQVMsRUFBRSxPQUFPLEdBQ2pCLFNBQVMsSUFBSSxNQUFNLEdBQUc7SUFBRSxPQUFPLEVBQUU7UUFBRSxRQUFRLEVBQUUsTUFBTSxFQUFFLENBQUE7S0FBRSxDQUFBO0NBQUUsQ0FPM0Q7QUFFRCx3QkFBZ0IsbUJBQW1CLENBQ2pDLFNBQVMsRUFBRSxPQUFPLEdBQ2pCLFNBQVMsSUFBSSxNQUFNLEdBQUc7SUFBRSxPQUFPLEVBQUU7UUFBRSxJQUFJLEVBQUUsTUFBTSxDQUFDLE1BQU0sRUFBRSxPQUFPLENBQUMsQ0FBQTtLQUFFLENBQUE7Q0FBRSxDQUV0RTtBQUVELHdCQUFnQixtQkFBbUIsQ0FDakMsU0FBUyxFQUFFLE9BQU8sR0FDakIsU0FBUyxJQUFJLE1BQU0sR0FBRztJQUFFLE9BQU8sRUFBRTtRQUFFLElBQUksRUFBRSxNQUFNLENBQUE7S0FBRSxDQUFBO0NBQUUsQ0FFckQiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBpc09iamVjdCB9IGZyb20gJy4uL3V0aWxzL2luZGV4LmpzJ1xuaW1wb3J0IHsgdHlwZSBKY0Jhc2UgfSBmcm9tICcuL2pjLmFic3RyYWN0LmpzJ1xuXG5leHBvcnQgZnVuY3Rpb24gaXNDb21wb25lbnRXaXRoQ2hpbGRyZW4oXG4gIGNvbXBvbmVudDogdW5rbm93bixcbik6IGNvbXBvbmVudCBpcyBKY0Jhc2UgJiB7IG9wdGlvbnM6IHsgY2hpbGRyZW46IEpjQmFzZVtdIH0gfSB7XG4gIHJldHVybiAoXG4gICAgaXNPYmplY3QoY29tcG9uZW50KSAmJlxuICAgIGlzT2JqZWN0KGNvbXBvbmVudC5vcHRpb25zKSAmJlxuICAgIEFycmF5LmlzQXJyYXkoY29tcG9uZW50Lm9wdGlvbnMuY2hpbGRyZW4pICYmXG4gICAgY29tcG9uZW50Lm9wdGlvbnMuY2hpbGRyZW4ubGVuZ3RoID4gMFxuICApXG59XG5cbmV4cG9ydCBmdW5jdGlvbiBpc0NvbXBvbmVudFdpdGhEYXRhKFxuICBjb21wb25lbnQ6IHVua25vd24sXG4pOiBjb21wb25lbnQgaXMgSmNCYXNlICYgeyBvcHRpb25zOiB7IGRhdGE6IFJlY29yZDxzdHJpbmcsIHVua25vd24+IH0gfSB7XG4gIHJldHVybiBpc09iamVjdChjb21wb25lbnQpICYmIGlzT2JqZWN0KGNvbXBvbmVudC5vcHRpb25zKSAmJiAnZGF0YScgaW4gY29tcG9uZW50Lm9wdGlvbnNcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGlzQ29tcG9uZW50V2l0aEl0ZW0oXG4gIGNvbXBvbmVudDogdW5rbm93bixcbik6IGNvbXBvbmVudCBpcyBKY0Jhc2UgJiB7IG9wdGlvbnM6IHsgaXRlbTogSmNCYXNlIH0gfSB7XG4gIHJldHVybiBpc09iamVjdChjb21wb25lbnQpICYmIGlzT2JqZWN0KGNvbXBvbmVudC5vcHRpb25zKSAmJiBpc09iamVjdChjb21wb25lbnQub3B0aW9ucy5pdGVtKVxufVxuIl19

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

@@ -0,0 +1 @@
+{"version":3,"file":"jc.guards.d.ts","sourceRoot":"","sources":["../../src/component/jc.guards.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAE9C,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,OAAO,GACjB,SAAS,IAAI,MAAM,GAAG;IAAE,OAAO,EAAE;QAAE,QAAQ,EAAE,MAAM,EAAE,CAAA;KAAE,CAAA;CAAE,CAO3D;AAED,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,OAAO,GACjB,SAAS,IAAI,MAAM,GAAG;IAAE,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAA;CAAE,CAEtE;AAED,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,OAAO,GACjB,SAAS,IAAI,MAAM,GAAG;IAAE,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAErD","sourcesContent":["import { isObject } from '../utils/index.js'\nimport { type JcBase } from './jc.abstract.js'\n\nexport function isComponentWithChildren(\n  component: unknown,\n): component is JcBase & { options: { children: JcBase[] } } {\n  return (\n    isObject(component) &&\n    isObject(component.options) &&\n    Array.isArray(component.options.children) &&\n    component.options.children.length > 0\n  )\n}\n\nexport function isComponentWithData(\n  component: unknown,\n): component is JcBase & { options: { data: Record<string, unknown> } } {\n  return isObject(component) && isObject(component.options) && 'data' in component.options\n}\n\nexport function isComponentWithItem(\n  component: unknown,\n): component is JcBase & { options: { item: JcBase } } {\n  return isObject(component) && isObject(component.options) && isObject(component.options.item)\n}\n"]}

package/dist/component/jc.guards.js

@@ -0,0 +1,14 @@
+import { isObject } from '../utils/index.js';
+export function isComponentWithChildren(component) {
+    return (isObject(component) &&
+        isObject(component.options) &&
+        Array.isArray(component.options.children) &&
+        component.options.children.length > 0);
+}
+export function isComponentWithData(component) {
+    return isObject(component) && isObject(component.options) && 'data' in component.options;
+}
+export function isComponentWithItem(component) {
+    return isObject(component) && isObject(component.options) && isObject(component.options.item);
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,19 @@
+import { type ColorValueOrConditions, type EmphasisDefinition, type Expression } from '../abstract/index.js';
+import { type IconName } from '../icon/index.js';
+import { type IconShape, type IconSize, type IconType } from './common/index.js';
+import { type JcBaseInput, ComponentBaseBuilder } from './jc.abstract.js';
+export interface JcIconInput extends JcBaseInput {
+    readonly icon?: IconName | Expression;
+    readonly type?: IconType | Expression;
+    readonly shape?: IconShape | Expression;
+    readonly color?: ColorValueOrConditions;
+    readonly emphasis?: EmphasisDefinition;
+    readonly size?: IconSize | Expression;
+}
+export declare class JcIconBuilder extends ComponentBaseBuilder<JcIconInput> {
+    readonly onPress: import("../action/ja.in-background.factory.js").ActionInBackgroundBuilders;
+    constructor(options?: JcIconInput);
+    name(name: IconName | Expression): this;
+    with(options?: Partial<Omit<JcIconInput, 'instanceId'>>): this;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiamMuaWNvbi5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbXBvbmVudC9qYy5pY29uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxLQUFLLHNCQUFzQixFQUMzQixLQUFLLGtCQUFrQixFQUN2QixLQUFLLFVBQVUsRUFDaEIsTUFBTSxzQkFBc0IsQ0FBQTtBQUU3QixPQUFPLEVBQUUsS0FBSyxRQUFRLEVBQTBCLE1BQU0sa0JBQWtCLENBQUE7QUFDeEUsT0FBTyxFQUFFLEtBQUssU0FBUyxFQUFFLEtBQUssUUFBUSxFQUFFLEtBQUssUUFBUSxFQUFFLE1BQU0sbUJBQW1CLENBQUE7QUFDaEYsT0FBTyxFQUFFLEtBQUssV0FBVyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sa0JBQWtCLENBQUE7QUFNekUsTUFBTSxXQUFXLFdBQVksU0FBUSxXQUFXO0lBQzlDLFFBQVEsQ0FBQyxJQUFJLENBQUMsRUFBRSxRQUFRLEdBQUcsVUFBVSxDQUFBO0lBQ3JDLFFBQVEsQ0FBQyxJQUFJLENBQUMsRUFBRSxRQUFRLEdBQUcsVUFBVSxDQUFBO0lBQ3JDLFFBQVEsQ0FBQyxLQUFLLENBQUMsRUFBRSxTQUFTLEdBQUcsVUFBVSxDQUFBO0lBQ3ZDLFFBQVEsQ0FBQyxLQUFLLENBQUMsRUFBRSxzQkFBc0IsQ0FBQTtJQUN2QyxRQUFRLENBQUMsUUFBUSxDQUFDLEVBQUUsa0JBQWtCLENBQUE7SUFDdEMsUUFBUSxDQUFDLElBQUksQ0FBQyxFQUFFLFFBQVEsR0FBRyxVQUFVLENBQUE7Q0FDdEM7QUFLRCxxQkFBYSxhQUFjLFNBQVEsb0JBQW9CLENBQUMsV0FBVyxDQUFDO0lBRWxFLFFBQVEsQ0FBQyxPQUFPLDZFQUVkO0lBRUYsWUFBWSxPQUFPLEdBQUUsV0FBZ0IsRUFPcEM7SUFNRCxJQUFJLENBQUMsSUFBSSxFQUFFLFFBQVEsR0FBRyxVQUFVLEdBQUcsSUFBSSxDQUd0QztJQUVRLElBQUksQ0FBQyxPQUFPLENBQUMsRUFBRSxPQUFPLENBQUMsSUFBSSxDQUFDLFdBQVcsRUFBRSxZQUFZLENBQUMsQ0FBQyxHQUFHLElBQUksQ0F1QnRFO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xuICB0eXBlIENvbG9yVmFsdWVPckNvbmRpdGlvbnMsXG4gIHR5cGUgRW1waGFzaXNEZWZpbml0aW9uLFxuICB0eXBlIEV4cHJlc3Npb24sXG59IGZyb20gJy4uL2Fic3RyYWN0L2luZGV4LmpzJ1xuaW1wb3J0IHsgY3JlYXRlQWN0aW9uSW5CYWNrZ3JvdW5kQnVpbGRlcnNGYWN0b3J5IH0gZnJvbSAnLi4vYWN0aW9uL2phLmluLWJhY2tncm91bmQuZmFjdG9yeS5qcydcbmltcG9ydCB7IHR5cGUgSWNvbk5hbWUsIHRvSWNvbk5hbWVPckV4cHJlc3Npb24gfSBmcm9tICcuLi9pY29uL2luZGV4LmpzJ1xuaW1wb3J0IHsgdHlwZSBJY29uU2hhcGUsIHR5cGUgSWNvblNpemUsIHR5cGUgSWNvblR5cGUgfSBmcm9tICcuL2NvbW1vbi9pbmRleC5qcydcbmltcG9ydCB7IHR5cGUgSmNCYXNlSW5wdXQsIENvbXBvbmVudEJhc2VCdWlsZGVyIH0gZnJvbSAnLi9qYy5hYnN0cmFjdC5qcydcbmltcG9ydCB7IENPTVBPTkVOVF9UWVBFIH0gZnJvbSAnLi9qYy50eXBlcy5qcydcblxuLyoqXG4gKiBJbnB1dCBvcHRpb25zIGZvciBpY29uIGNvbXBvbmVudC5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBKY0ljb25JbnB1dCBleHRlbmRzIEpjQmFzZUlucHV0IHtcbiAgcmVhZG9ubHkgaWNvbj86IEljb25OYW1lIHwgRXhwcmVzc2lvblxuICByZWFkb25seSB0eXBlPzogSWNvblR5cGUgfCBFeHByZXNzaW9uXG4gIHJlYWRvbmx5IHNoYXBlPzogSWNvblNoYXBlIHwgRXhwcmVzc2lvblxuICByZWFkb25seSBjb2xvcj86IENvbG9yVmFsdWVPckNvbmRpdGlvbnNcbiAgcmVhZG9ubHkgZW1waGFzaXM/OiBFbXBoYXNpc0RlZmluaXRpb25cbiAgcmVhZG9ubHkgc2l6ZT86IEljb25TaXplIHwgRXhwcmVzc2lvblxufVxuXG4vKipcbiAqIEJ1aWxkcyBpY29ucyB3aXRoIHN0eWxpbmcgYW5kIGFjdGlvbnMuXG4gKi9cbmV4cG9ydCBjbGFzcyBKY0ljb25CdWlsZGVyIGV4dGVuZHMgQ29tcG9uZW50QmFzZUJ1aWxkZXI8SmNJY29uSW5wdXQ+IHtcbiAgLyoqIENvbmZpZ3VyZXMgaWNvbiB0YXAgaW50ZXJhY3Rpb25zLiAqL1xuICByZWFkb25seSBvblByZXNzID0gY3JlYXRlQWN0aW9uSW5CYWNrZ3JvdW5kQnVpbGRlcnNGYWN0b3J5KChhY3Rpb24pID0+IHtcbiAgICB0aGlzLl9zZXRUb0NvbmZpZygnb25QcmVzcycsIGFjdGlvbilcbiAgfSlcblxuICBjb25zdHJ1Y3RvcihvcHRpb25zOiBKY0ljb25JbnB1dCA9IHt9KSB7XG4gICAgc3VwZXIoQ09NUE9ORU5UX1RZUEUuSUNPTiwgb3B0aW9ucylcblxuICAgIC8vIFNldCBkZWZhdWx0c1xuICAgIHRoaXMuX2NvbmZpZy5pY29uID0gJ2RhdGEtZmlsZS1zdGFyJ1xuXG4gICAgdGhpcy53aXRoKG9wdGlvbnMpXG4gIH1cblxuICAvKipcbiAgICogU2V0cyBpY29uIG5hbWUuXG4gICAqIEBwYXJhbSBuYW1lIEljb24gbmFtZSBvciBleHByZXNzaW9uXG4gICAqL1xuICBuYW1lKG5hbWU6IEljb25OYW1lIHwgRXhwcmVzc2lvbik6IHRoaXMge1xuICAgIHRoaXMuX2NvbmZpZy5pY29uID0gdG9JY29uTmFtZU9yRXhwcmVzc2lvbihuYW1lKVxuICAgIHJldHVybiB0aGlzXG4gIH1cblxuICBvdmVycmlkZSB3aXRoKG9wdGlvbnM/OiBQYXJ0aWFsPE9taXQ8SmNJY29uSW5wdXQsICdpbnN0YW5jZUlkJz4+KTogdGhpcyB7XG4gICAgc3VwZXIud2l0aChvcHRpb25zKVxuXG4gICAgaWYgKG9wdGlvbnM/Lmljb24gIT09IHVuZGVmaW5lZCkge1xuICAgICAgdGhpcy5fY29uZmlnLmljb24gPSB0b0ljb25OYW1lT3JFeHByZXNzaW9uKG9wdGlvbnMuaWNvbilcbiAgICB9XG4gICAgaWYgKG9wdGlvbnM/LnR5cGUgIT09IHVuZGVmaW5lZCkge1xuICAgICAgdGhpcy5fY29uZmlnLnR5cGUgPSBvcHRpb25zLnR5cGVcbiAgICB9XG4gICAgaWYgKG9wdGlvbnM/LnNoYXBlICE9PSB1bmRlZmluZWQpIHtcbiAgICAgIHRoaXMuX2NvbmZpZy5zaGFwZSA9IG9wdGlvbnMuc2hhcGVcbiAgICB9XG4gICAgaWYgKG9wdGlvbnM/LmNvbG9yICE9PSB1bmRlZmluZWQpIHtcbiAgICAgIHRoaXMuX2NvbmZpZy5jb2xvciA9IG9wdGlvbnMuY29sb3JcbiAgICB9XG4gICAgaWYgKG9wdGlvbnM/LmVtcGhhc2lzICE9PSB1bmRlZmluZWQpIHtcbiAgICAgIHRoaXMuX2NvbmZpZy5lbXBoYXNpcyA9IG9wdGlvbnMuZW1waGFzaXNcbiAgICB9XG4gICAgaWYgKG9wdGlvbnM/LnNpemUgIT09IHVuZGVmaW5lZCkge1xuICAgICAgdGhpcy5fY29uZmlnLnNpemUgPSBvcHRpb25zLnNpemVcbiAgICB9XG5cbiAgICByZXR1cm4gdGhpc1xuICB9XG59XG4iXX0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"jc.icon.d.ts","sourceRoot":"","sources":["../../src/component/jc.icon.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,sBAAsB,EAC3B,KAAK,kBAAkB,EACvB,KAAK,UAAU,EAChB,MAAM,sBAAsB,CAAA;AAE7B,OAAO,EAAE,KAAK,QAAQ,EAA0B,MAAM,kBAAkB,CAAA;AACxE,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,KAAK,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAChF,OAAO,EAAE,KAAK,WAAW,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAMzE,MAAM,WAAW,WAAY,SAAQ,WAAW;IAC9C,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,GAAG,UAAU,CAAA;IACrC,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,GAAG,UAAU,CAAA;IACrC,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,GAAG,UAAU,CAAA;IACvC,QAAQ,CAAC,KAAK,CAAC,EAAE,sBAAsB,CAAA;IACvC,QAAQ,CAAC,QAAQ,CAAC,EAAE,kBAAkB,CAAA;IACtC,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,GAAG,UAAU,CAAA;CACtC;AAKD,qBAAa,aAAc,SAAQ,oBAAoB,CAAC,WAAW,CAAC;IAElE,QAAQ,CAAC,OAAO,6EAEd;IAEF,YAAY,OAAO,GAAE,WAAgB,EAOpC;IAMD,IAAI,CAAC,IAAI,EAAE,QAAQ,GAAG,UAAU,GAAG,IAAI,CAGtC;IAEQ,IAAI,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC,GAAG,IAAI,CAuBtE;CACF","sourcesContent":["import {\n  type ColorValueOrConditions,\n  type EmphasisDefinition,\n  type Expression,\n} from '../abstract/index.js'\nimport { createActionInBackgroundBuildersFactory } from '../action/ja.in-background.factory.js'\nimport { type IconName, toIconNameOrExpression } from '../icon/index.js'\nimport { type IconShape, type IconSize, type IconType } from './common/index.js'\nimport { type JcBaseInput, ComponentBaseBuilder } from './jc.abstract.js'\nimport { COMPONENT_TYPE } from './jc.types.js'\n\n/**\n * Input options for icon component.\n */\nexport interface JcIconInput extends JcBaseInput {\n  readonly icon?: IconName | Expression\n  readonly type?: IconType | Expression\n  readonly shape?: IconShape | Expression\n  readonly color?: ColorValueOrConditions\n  readonly emphasis?: EmphasisDefinition\n  readonly size?: IconSize | Expression\n}\n\n/**\n * Builds icons with styling and actions.\n */\nexport class JcIconBuilder extends ComponentBaseBuilder<JcIconInput> {\n  /** Configures icon tap interactions. */\n  readonly onPress = createActionInBackgroundBuildersFactory((action) => {\n    this._setToConfig('onPress', action)\n  })\n\n  constructor(options: JcIconInput = {}) {\n    super(COMPONENT_TYPE.ICON, options)\n\n    // Set defaults\n    this._config.icon = 'data-file-star'\n\n    this.with(options)\n  }\n\n  /**\n   * Sets icon name.\n   * @param name Icon name or expression\n   */\n  name(name: IconName | Expression): this {\n    this._config.icon = toIconNameOrExpression(name)\n    return this\n  }\n\n  override with(options?: Partial<Omit<JcIconInput, 'instanceId'>>): this {\n    super.with(options)\n\n    if (options?.icon !== undefined) {\n      this._config.icon = toIconNameOrExpression(options.icon)\n    }\n    if (options?.type !== undefined) {\n      this._config.type = options.type\n    }\n    if (options?.shape !== undefined) {\n      this._config.shape = options.shape\n    }\n    if (options?.color !== undefined) {\n      this._config.color = options.color\n    }\n    if (options?.emphasis !== undefined) {\n      this._config.emphasis = options.emphasis\n    }\n    if (options?.size !== undefined) {\n      this._config.size = options.size\n    }\n\n    return this\n  }\n}\n"]}

package/dist/component/jc.icon.js

@@ -0,0 +1,41 @@
+import { createActionInBackgroundBuildersFactory } from '../action/ja.in-background.factory.js';
+import { toIconNameOrExpression } from '../icon/index.js';
+import { ComponentBaseBuilder } from './jc.abstract.js';
+import { COMPONENT_TYPE } from './jc.types.js';
+export class JcIconBuilder extends ComponentBaseBuilder {
+    onPress = createActionInBackgroundBuildersFactory((action) => {
+        this._setToConfig('onPress', action);
+    });
+    constructor(options = {}) {
+        super(COMPONENT_TYPE.ICON, options);
+        this._config.icon = 'data-file-star';
+        this.with(options);
+    }
+    name(name) {
+        this._config.icon = toIconNameOrExpression(name);
+        return this;
+    }
+    with(options) {
+        super.with(options);
+        if (options?.icon !== undefined) {
+            this._config.icon = toIconNameOrExpression(options.icon);
+        }
+        if (options?.type !== undefined) {
+            this._config.type = options.type;
+        }
+        if (options?.shape !== undefined) {
+            this._config.shape = options.shape;
+        }
+        if (options?.color !== undefined) {
+            this._config.color = options.color;
+        }
+        if (options?.emphasis !== undefined) {
+            this._config.emphasis = options.emphasis;
+        }
+        if (options?.size !== undefined) {
+            this._config.size = options.size;
+        }
+        return this;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,28 @@
+import { type Expression, type ImageResizeMode, type InstanceId, type TextValue, TextValueBuilder } from '../abstract/index.js';
+import { type JaInBackground } from '../action/index.js';
+import { type ImageSource } from './common/index.js';
+import { type JcBase, type JcBaseInput, ComponentBaseBuilder } from './jc.abstract.js';
+import { COMPONENT_TYPE } from './jc.types.js';
+export interface JcImageBase extends JcBase {
+    readonly type: typeof COMPONENT_TYPE.IMAGE;
+    options: {
+        source: ImageSource;
+        title?: TextValue;
+        subtitle?: TextValue;
+        resizeMode?: ImageResizeMode;
+        onPress?: JaInBackground;
+    };
+}
+export interface JcImageBaseInput extends JcBaseInput {
+    readonly instanceId?: InstanceId;
+    readonly resizeMode?: ImageResizeMode;
+    readonly source?: string | Expression | URL | ImageSource;
+    readonly title?: string | TextValue | TextValueBuilder;
+    readonly subtitle?: string | TextValue | TextValueBuilder;
+}
+export declare abstract class JcImageBuilderBase<TInput extends JcImageBaseInput, TOutput extends JcImageBase> extends ComponentBaseBuilder<TInput, TOutput> {
+    protected constructor(options: TInput);
+    with(options?: Partial<Omit<TInput, 'instanceId'>>): this;
+    build(): TOutput;
+}
+//# sourceMappingURL=data:application/json;base64,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