@jigx/core-sdk 1.0.0

package/dist/screen/screen.default.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen.default.d.ts","sourceRoot":"","sources":["../../src/screen/screen.default.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,YAAY,EAEjB,WAAW,EACZ,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EACL,KAAK,MAAM,EACX,eAAe,EACf,oBAAoB,EACpB,iBAAiB,EACjB,KAAK,MAAM,EACX,sBAAsB,EACtB,iBAAiB,EACjB,iBAAiB,EACjB,oBAAoB,EACpB,kBAAkB,EAClB,gBAAgB,EAChB,+BAA+B,EAC/B,mBAAmB,EACnB,gBAAgB,EAChB,iBAAiB,EACjB,uBAAuB,EACvB,mBAAmB,EACnB,eAAe,EACf,iBAAiB,EACjB,iBAAiB,EACjB,aAAa,EACb,aAAa,EACb,uBAAuB,EACvB,yBAAyB,EACzB,kBAAkB,EAClB,aAAa,EACb,2BAA2B,EAC3B,iBAAiB,EACjB,mBAAmB,EACnB,oBAAoB,EACpB,iBAAiB,EACjB,oBAAoB,EACpB,eAAe,EACf,yBAAyB,EACzB,yBAAyB,EACzB,uBAAuB,EACvB,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,yBAAyB,EACzB,yBAAyB,EAC1B,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACtB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EACL,KAAK,UAAU,EACf,oBAAoB,EACpB,KAAK,sBAAsB,EAC5B,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAYpD,MAAM,WAAW,aAAc,SAAQ,UAAU;IAC/C,QAAQ,CAAC,IAAI,EAAE,OAAO,WAAW,CAAC,OAAO,CAAA;IACzC,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC,YAAY,EAAE,gBAAgB,GAAG,gBAAgB,GAAG,gBAAgB,CAAC,CAAA;CAC3F;AAED,MAAM,WAAW,kBAAmB,SAAQ,sBAAsB;IAChE,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAA;CAChC;AASD,qBAAa,oBAAqB,SAAQ,oBAAoB;IAC5D,YAAY,OAAO,EAAE,kBAAkB,EAEtC;IAEQ,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,kBAAkB,EAAE,UAAU,CAAC,CAAC,GAAG,IAAI,CAQ1E;IAED,MAAM,oFAAkE;IAExE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAwCT;IAEQ,SAAS,IAAI,IAAI,CAQzB;CACF","sourcesContent":["import {\n  assignBuilderFactory,\n  type DatasourceId,\n  pushBuilderFactory,\n  SCREEN_TYPE,\n} from '../abstract/index.js'\nimport {\n  type Filter,\n  JcAvatarBuilder,\n  JcAvatarFieldBuilder,\n  JcBarChartBuilder,\n  type JcBase,\n  JcCardOnDefaultBuilder,\n  JcCarouselBuilder,\n  JcCheckboxBuilder,\n  JcChoiceFieldBuilder,\n  JcCountDownBuilder,\n  JcCountUpBuilder,\n  JcCustomComponentInteropBuilder,\n  JcDatePickerBuilder,\n  JcDividerBuilder,\n  JcDropdownBuilder,\n  JcDurationPickerBuilder,\n  JcEmailFieldBuilder,\n  JcEntityBuilder,\n  JcExpanderBuilder,\n  JcFieldRowBuilder,\n  JcFormBuilder,\n  JcGridBuilder,\n  JcImageOnDefaultBuilder,\n  JcInteractiveImageBuilder,\n  JcLineChartBuilder,\n  JcListBuilder,\n  JcListItemStandaloneBuilder,\n  JcLocationBuilder,\n  JcMediaFieldBuilder,\n  JcNumberFieldBuilder,\n  JcPieChartBuilder,\n  JcProgressBarBuilder,\n  JcRatingBuilder,\n  JcSectionOnDefaultBuilder,\n  JcSegmentedControlBuilder,\n  JcSignatureFieldBuilder,\n  JcSliderBuilder,\n  JcStepperBuilder,\n  JcTextFieldBuilder,\n  JcVideoPlayerOnJigBuilder,\n  JcWebViewOnDefaultBuilder,\n} from '../component/index.js'\nimport {\n  type SqliteDatasource,\n  type StaticDatasource,\n  type SystemDatasource,\n} from '../datasource/index.js'\nimport {\n  type ScreenBase,\n  ScreenBaseBuilderNew,\n  type ScreenBaseBuilderInput,\n} from './screen.abstract.js'\nimport { ListFilterBuilder } from './screen.list.js'\n\n/**\n * Most versatile screen type for custom layouts.\n * Combine any components: forms, lists, charts, images, buttons.\n * Use for dashboards, forms, detail views, mixed content.\n * Components arranged vertically in order defined.\n * Choose when list/calendar screens don't fit needs.\n * Most common screen type in Jigx applications.\n * @alias jig.default\n * @see #/definitions/jig-default-specification\n */\nexport interface DefaultScreen extends ScreenBase {\n  readonly type: typeof SCREEN_TYPE.DEFAULT\n  children: JcBase[] // Components array\n  filter?: Filter\n  isSearchable?: boolean\n  datasources?: Record<DatasourceId, SqliteDatasource | StaticDatasource | SystemDatasource>\n}\n\nexport interface DefaultScreenInput extends ScreenBaseBuilderInput {\n  readonly isSearchable?: boolean\n}\n\n/**\n * Build custom screens with flexible component composition.\n * Assemble any combination of UI elements in vertical layout.\n * Create forms, dashboards, detail views, or information displays.\n * Add components sequentially using the addControl factory.\n * Most versatile screen type for custom UI patterns.\n */\nexport class DefaultScreenBuilder extends ScreenBaseBuilderNew {\n  constructor(options: DefaultScreenInput) {\n    super(SCREEN_TYPE.DEFAULT, options)\n  }\n\n  override with(options: Partial<Omit<DefaultScreenInput, 'screenId'>>): this {\n    super.with(options)\n\n    if (options.isSearchable !== undefined) {\n      this._config.isSearchable = options.isSearchable\n    }\n\n    return this\n  }\n\n  filter = assignBuilderFactory(ListFilterBuilder, this._config, 'filter')\n\n  addControl = {\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    rating: pushBuilderFactory(JcRatingBuilder, 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    customComponent: pushBuilderFactory(JcCustomComponentInteropBuilder, this._config, 'children'),\n    avatar: pushBuilderFactory(JcAvatarBuilder, this._config, 'children'),\n    barChart: pushBuilderFactory(JcBarChartBuilder, this._config, 'children'),\n    entity: pushBuilderFactory(JcEntityBuilder, this._config, 'children'),\n    form: pushBuilderFactory(JcFormBuilder, 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    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  override _validate(): void {\n    super._validate()\n    const children = this._config.children\n    if (Array.isArray(children)) {\n      children.forEach((child) => {\n        child?._validate?.()\n      })\n    }\n  }\n}\n"]}

package/dist/screen/screen.default.js

@@ -0,0 +1,68 @@
+import { assignBuilderFactory, pushBuilderFactory, SCREEN_TYPE, } from '../abstract/index.js';
+import { JcAvatarBuilder, JcAvatarFieldBuilder, JcBarChartBuilder, JcCardOnDefaultBuilder, JcCarouselBuilder, JcCheckboxBuilder, JcChoiceFieldBuilder, JcCountDownBuilder, JcCountUpBuilder, JcCustomComponentInteropBuilder, JcDatePickerBuilder, JcDividerBuilder, JcDropdownBuilder, JcDurationPickerBuilder, JcEmailFieldBuilder, JcEntityBuilder, JcExpanderBuilder, JcFieldRowBuilder, JcFormBuilder, JcGridBuilder, JcImageOnDefaultBuilder, JcInteractiveImageBuilder, JcLineChartBuilder, JcListBuilder, JcListItemStandaloneBuilder, JcLocationBuilder, JcMediaFieldBuilder, JcNumberFieldBuilder, JcPieChartBuilder, JcProgressBarBuilder, JcRatingBuilder, JcSectionOnDefaultBuilder, JcSegmentedControlBuilder, JcSignatureFieldBuilder, JcSliderBuilder, JcStepperBuilder, JcTextFieldBuilder, JcVideoPlayerOnJigBuilder, JcWebViewOnDefaultBuilder, } from '../component/index.js';
+import { ScreenBaseBuilderNew, } from './screen.abstract.js';
+import { ListFilterBuilder } from './screen.list.js';
+export class DefaultScreenBuilder extends ScreenBaseBuilderNew {
+    constructor(options) {
+        super(SCREEN_TYPE.DEFAULT, options);
+    }
+    with(options) {
+        super.with(options);
+        if (options.isSearchable !== undefined) {
+            this._config.isSearchable = options.isSearchable;
+        }
+        return this;
+    }
+    filter = assignBuilderFactory(ListFilterBuilder, this._config, 'filter');
+    addControl = {
+        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'),
+        rating: pushBuilderFactory(JcRatingBuilder, 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'),
+        customComponent: pushBuilderFactory(JcCustomComponentInteropBuilder, this._config, 'children'),
+        avatar: pushBuilderFactory(JcAvatarBuilder, this._config, 'children'),
+        barChart: pushBuilderFactory(JcBarChartBuilder, this._config, 'children'),
+        entity: pushBuilderFactory(JcEntityBuilder, this._config, 'children'),
+        form: pushBuilderFactory(JcFormBuilder, 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'),
+        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'),
+    };
+    _validate() {
+        super._validate();
+        const children = this._config.children;
+        if (Array.isArray(children)) {
+            children.forEach((child) => {
+                child?._validate?.();
+            });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"screen.default.js","sourceRoot":"","sources":["../../src/screen/screen.default.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  assignBuilderFactory,\n  type DatasourceId,\n  pushBuilderFactory,\n  SCREEN_TYPE,\n} from '../abstract/index.js'\nimport {\n  type Filter,\n  JcAvatarBuilder,\n  JcAvatarFieldBuilder,\n  JcBarChartBuilder,\n  type JcBase,\n  JcCardOnDefaultBuilder,\n  JcCarouselBuilder,\n  JcCheckboxBuilder,\n  JcChoiceFieldBuilder,\n  JcCountDownBuilder,\n  JcCountUpBuilder,\n  JcCustomComponentInteropBuilder,\n  JcDatePickerBuilder,\n  JcDividerBuilder,\n  JcDropdownBuilder,\n  JcDurationPickerBuilder,\n  JcEmailFieldBuilder,\n  JcEntityBuilder,\n  JcExpanderBuilder,\n  JcFieldRowBuilder,\n  JcFormBuilder,\n  JcGridBuilder,\n  JcImageOnDefaultBuilder,\n  JcInteractiveImageBuilder,\n  JcLineChartBuilder,\n  JcListBuilder,\n  JcListItemStandaloneBuilder,\n  JcLocationBuilder,\n  JcMediaFieldBuilder,\n  JcNumberFieldBuilder,\n  JcPieChartBuilder,\n  JcProgressBarBuilder,\n  JcRatingBuilder,\n  JcSectionOnDefaultBuilder,\n  JcSegmentedControlBuilder,\n  JcSignatureFieldBuilder,\n  JcSliderBuilder,\n  JcStepperBuilder,\n  JcTextFieldBuilder,\n  JcVideoPlayerOnJigBuilder,\n  JcWebViewOnDefaultBuilder,\n} from '../component/index.js'\nimport {\n  type SqliteDatasource,\n  type StaticDatasource,\n  type SystemDatasource,\n} from '../datasource/index.js'\nimport {\n  type ScreenBase,\n  ScreenBaseBuilderNew,\n  type ScreenBaseBuilderInput,\n} from './screen.abstract.js'\nimport { ListFilterBuilder } from './screen.list.js'\n\n/**\n * Most versatile screen type for custom layouts.\n * Combine any components: forms, lists, charts, images, buttons.\n * Use for dashboards, forms, detail views, mixed content.\n * Components arranged vertically in order defined.\n * Choose when list/calendar screens don't fit needs.\n * Most common screen type in Jigx applications.\n * @alias jig.default\n * @see #/definitions/jig-default-specification\n */\nexport interface DefaultScreen extends ScreenBase {\n  readonly type: typeof SCREEN_TYPE.DEFAULT\n  children: JcBase[] // Components array\n  filter?: Filter\n  isSearchable?: boolean\n  datasources?: Record<DatasourceId, SqliteDatasource | StaticDatasource | SystemDatasource>\n}\n\nexport interface DefaultScreenInput extends ScreenBaseBuilderInput {\n  readonly isSearchable?: boolean\n}\n\n/**\n * Build custom screens with flexible component composition.\n * Assemble any combination of UI elements in vertical layout.\n * Create forms, dashboards, detail views, or information displays.\n * Add components sequentially using the addControl factory.\n * Most versatile screen type for custom UI patterns.\n */\nexport class DefaultScreenBuilder extends ScreenBaseBuilderNew {\n  constructor(options: DefaultScreenInput) {\n    super(SCREEN_TYPE.DEFAULT, options)\n  }\n\n  override with(options: Partial<Omit<DefaultScreenInput, 'screenId'>>): this {\n    super.with(options)\n\n    if (options.isSearchable !== undefined) {\n      this._config.isSearchable = options.isSearchable\n    }\n\n    return this\n  }\n\n  filter = assignBuilderFactory(ListFilterBuilder, this._config, 'filter')\n\n  addControl = {\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    rating: pushBuilderFactory(JcRatingBuilder, 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    customComponent: pushBuilderFactory(JcCustomComponentInteropBuilder, this._config, 'children'),\n    avatar: pushBuilderFactory(JcAvatarBuilder, this._config, 'children'),\n    barChart: pushBuilderFactory(JcBarChartBuilder, this._config, 'children'),\n    entity: pushBuilderFactory(JcEntityBuilder, this._config, 'children'),\n    form: pushBuilderFactory(JcFormBuilder, 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    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  override _validate(): void {\n    super._validate()\n    const children = this._config.children\n    if (Array.isArray(children)) {\n      children.forEach((child) => {\n        child?._validate?.()\n      })\n    }\n  }\n}\n"]}

package/dist/screen/screen.document.d.ts

@@ -0,0 +1,58 @@
+import { BaseBuilder, type Expression, SCREEN_TYPE } from '../abstract/index.js';
+import { type ScreenBase, type ScreenBaseBuilderInput, ScreenBaseBuilderNew } from './screen.abstract.js';
+export interface DocumentScreen extends ScreenBase {
+    readonly type: typeof SCREEN_TYPE.DOCUMENT;
+    readonly source: DocumentScreenSource;
+}
+interface DocumentPdfSource {
+    readonly documentType: 'PDF';
+    readonly uri?: string | Expression;
+    readonly base64?: string | Expression;
+    readonly content?: string | Expression;
+}
+interface DocumentHtmlSource {
+    readonly documentType: 'HTML';
+    readonly uri?: string | Expression;
+    readonly base64?: string | Expression;
+    readonly content?: string | Expression;
+    readonly isTrackingTransparencyRequired?: boolean | Expression;
+}
+type DocumentScreenSource = DocumentPdfSource | DocumentHtmlSource;
+export interface DocumentPdfSourceInput {
+    uri?: string | Expression;
+    base64?: string | Expression;
+    content?: string | Expression;
+}
+export interface DocumentHtmlSourceInput {
+    uri?: string | Expression;
+    base64?: string | Expression;
+    content?: string | Expression;
+    isTrackingTransparencyRequired?: boolean | Expression;
+}
+export declare class DocumentPdfSourceBuilder extends BaseBuilder {
+    protected readonly _config: Record<string, unknown>;
+    constructor(options?: DocumentPdfSourceInput);
+    with(options: Partial<DocumentPdfSourceInput>): this;
+    _validate(): void;
+    build(): Record<string, unknown>;
+}
+export declare class DocumentHtmlSourceBuilder extends BaseBuilder {
+    protected readonly _config: Record<string, unknown>;
+    constructor(options?: DocumentHtmlSourceInput);
+    with(options: Partial<DocumentHtmlSourceInput>): this;
+    _validate(): void;
+    build(): Record<string, unknown>;
+}
+export type DocumentScreenInput = ScreenBaseBuilderInput;
+export declare class DocumentScreenBuilder extends ScreenBaseBuilderNew {
+    readonly state: {
+        readonly data: string;
+    };
+    readonly source: {
+        pdf: (options?: DocumentPdfSourceInput | undefined) => DocumentPdfSourceBuilder;
+        html: (options?: DocumentHtmlSourceInput | undefined) => DocumentHtmlSourceBuilder;
+    };
+    constructor(options: DocumentScreenInput);
+}
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"screen.document.d.ts","sourceRoot":"","sources":["../../src/screen/screen.document.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,WAAW,EAEX,KAAK,UAAU,EACf,WAAW,EAEZ,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EACL,KAAK,UAAU,EACf,KAAK,sBAAsB,EAC3B,oBAAoB,EACrB,MAAM,sBAAsB,CAAA;AAY7B,MAAM,WAAW,cAAe,SAAQ,UAAU;IAChD,QAAQ,CAAC,IAAI,EAAE,OAAO,WAAW,CAAC,QAAQ,CAAA;IAC1C,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAA;CACtC;AAED,UAAU,iBAAiB;IACzB,QAAQ,CAAC,YAAY,EAAE,KAAK,CAAA;IAC5B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IAClC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IACrC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;CACvC;AAED,UAAU,kBAAkB;IAC1B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IAClC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IACrC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IACtC,QAAQ,CAAC,8BAA8B,CAAC,EAAE,OAAO,GAAG,UAAU,CAAA;CAC/D;AAED,KAAK,oBAAoB,GAAG,iBAAiB,GAAG,kBAAkB,CAAA;AAElE,MAAM,WAAW,sBAAsB;IACrC,GAAG,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IACzB,MAAM,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IAC5B,OAAO,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;CAC9B;AAED,MAAM,WAAW,uBAAuB;IACtC,GAAG,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IACzB,MAAM,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IAC5B,OAAO,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IAC7B,8BAA8B,CAAC,EAAE,OAAO,GAAG,UAAU,CAAA;CACtD;AAKD,qBAAa,wBAAyB,SAAQ,WAAW;IACvD,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAA0B;IAE7E,YAAY,OAAO,GAAE,sBAA2B,EAG/C;IAED,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,sBAAsB,CAAC,GAAG,IAAI,CAanD;IAED,SAAS,IAAI,IAAI,CAAG;IAEpB,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAE/B;CACF;AAKD,qBAAa,yBAA0B,SAAQ,WAAW;IACxD,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAA2B;IAE9E,YAAY,OAAO,GAAE,uBAA4B,EAGhD;IAED,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,uBAAuB,CAAC,GAAG,IAAI,CAmBpD;IAED,SAAS,IAAI,IAAI,CAAG;IAEpB,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAE/B;CACF;AAED,MAAM,MAAM,mBAAmB,GAAG,sBAAsB,CAAA;AAMxD,qBAAa,qBAAsB,SAAQ,oBAAoB;IAC7D,QAAQ,CAAC,KAAK,EAAE;QACd,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KACtB,CAAA;IAED,QAAQ,CAAC,MAAM;;;MAGd;IAED,YACE,OAAO,EAAE,mBAAmB,EAO7B;CACF","sourcesContent":["import {\n  assignBuilderFactory,\n  BaseBuilder,\n  buildTree,\n  type Expression,\n  SCREEN_TYPE,\n  toExpression,\n} from '../abstract/index.js'\nimport {\n  type ScreenBase,\n  type ScreenBaseBuilderInput,\n  ScreenBaseBuilderNew,\n} from './screen.abstract.js'\n\n/**\n * Display PDF files or HTML pages inside app.\n * Use for reports, terms of service, help docs.\n * Load from URL, base64 data, or inline content.\n * PDF: View documents without external apps.\n * HTML: Embed web content with tracking control.\n * Commonly paired with generate-pdf action.\n * @alias jig.document\n * @see #/definitions/jig-document-specification\n */\nexport interface DocumentScreen extends ScreenBase {\n  readonly type: typeof SCREEN_TYPE.DOCUMENT\n  readonly source: DocumentScreenSource\n}\n\ninterface DocumentPdfSource {\n  readonly documentType: 'PDF'\n  readonly uri?: string | Expression\n  readonly base64?: string | Expression\n  readonly content?: string | Expression\n}\n\ninterface DocumentHtmlSource {\n  readonly documentType: 'HTML'\n  readonly uri?: string | Expression\n  readonly base64?: string | Expression\n  readonly content?: string | Expression\n  readonly isTrackingTransparencyRequired?: boolean | Expression\n}\n\ntype DocumentScreenSource = DocumentPdfSource | DocumentHtmlSource\n\nexport interface DocumentPdfSourceInput {\n  uri?: string | Expression\n  base64?: string | Expression\n  content?: string | Expression\n}\n\nexport interface DocumentHtmlSourceInput {\n  uri?: string | Expression\n  base64?: string | Expression\n  content?: string | Expression\n  isTrackingTransparencyRequired?: boolean | Expression\n}\n\n/**\n * Builds PDF document source.\n */\nexport class DocumentPdfSourceBuilder extends BaseBuilder {\n  protected readonly _config: Record<string, unknown> = { documentType: 'PDF' }\n\n  constructor(options: DocumentPdfSourceInput = {}) {\n    super()\n    this.with(options)\n  }\n\n  with(options: Partial<DocumentPdfSourceInput>): this {\n    if (options.uri !== undefined) {\n      this._config.uri = typeof options.uri === 'string' ? options.uri : toExpression(options.uri)\n    }\n    if (options.base64 !== undefined) {\n      this._config.base64 =\n        typeof options.base64 === 'string' ? options.base64 : toExpression(options.base64)\n    }\n    if (options.content !== undefined) {\n      this._config.content =\n        typeof options.content === 'string' ? options.content : toExpression(options.content)\n    }\n    return this\n  }\n\n  _validate(): void {}\n\n  build(): Record<string, unknown> {\n    return buildTree(this._config)\n  }\n}\n\n/**\n * Builds HTML document source.\n */\nexport class DocumentHtmlSourceBuilder extends BaseBuilder {\n  protected readonly _config: Record<string, unknown> = { documentType: 'HTML' }\n\n  constructor(options: DocumentHtmlSourceInput = {}) {\n    super()\n    this.with(options)\n  }\n\n  with(options: Partial<DocumentHtmlSourceInput>): this {\n    if (options.uri !== undefined) {\n      this._config.uri = typeof options.uri === 'string' ? options.uri : toExpression(options.uri)\n    }\n    if (options.base64 !== undefined) {\n      this._config.base64 =\n        typeof options.base64 === 'string' ? options.base64 : toExpression(options.base64)\n    }\n    if (options.content !== undefined) {\n      this._config.content =\n        typeof options.content === 'string' ? options.content : toExpression(options.content)\n    }\n    if (options.isTrackingTransparencyRequired !== undefined) {\n      this._config.isTrackingTransparencyRequired =\n        typeof options.isTrackingTransparencyRequired === 'string'\n          ? toExpression(options.isTrackingTransparencyRequired)\n          : options.isTrackingTransparencyRequired\n    }\n    return this\n  }\n\n  _validate(): void {}\n\n  build(): Record<string, unknown> {\n    return buildTree(this._config)\n  }\n}\n\nexport type DocumentScreenInput = ScreenBaseBuilderInput\n\n/**\n * Builds screens for PDF/HTML document display.\n * Supports URLs, base64, and inline content.\n */\nexport class DocumentScreenBuilder extends ScreenBaseBuilderNew {\n  readonly state: {\n    readonly data: string\n  }\n\n  readonly source = {\n    pdf: assignBuilderFactory(DocumentPdfSourceBuilder, this._config, 'source'),\n    html: assignBuilderFactory(DocumentHtmlSourceBuilder, this._config, 'source'),\n  }\n\n  constructor(\n    options: DocumentScreenInput,\n  ) {\n    super(SCREEN_TYPE.DOCUMENT, options)\n\n    this.state = {\n      data: `@ctx.jigs.${this.screenId}.state.data`,\n    }\n  }\n}\n"]}

package/dist/screen/screen.document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen.document.d.ts","sourceRoot":"","sources":["../../src/screen/screen.document.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,WAAW,EAEX,KAAK,UAAU,EACf,WAAW,EAEZ,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EACL,KAAK,UAAU,EACf,KAAK,sBAAsB,EAC3B,oBAAoB,EACrB,MAAM,sBAAsB,CAAA;AAY7B,MAAM,WAAW,cAAe,SAAQ,UAAU;IAChD,QAAQ,CAAC,IAAI,EAAE,OAAO,WAAW,CAAC,QAAQ,CAAA;IAC1C,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAA;CACtC;AAED,UAAU,iBAAiB;IACzB,QAAQ,CAAC,YAAY,EAAE,KAAK,CAAA;IAC5B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IAClC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IACrC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;CACvC;AAED,UAAU,kBAAkB;IAC1B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IAClC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IACrC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IACtC,QAAQ,CAAC,8BAA8B,CAAC,EAAE,OAAO,GAAG,UAAU,CAAA;CAC/D;AAED,KAAK,oBAAoB,GAAG,iBAAiB,GAAG,kBAAkB,CAAA;AAElE,MAAM,WAAW,sBAAsB;IACrC,GAAG,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IACzB,MAAM,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IAC5B,OAAO,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;CAC9B;AAED,MAAM,WAAW,uBAAuB;IACtC,GAAG,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IACzB,MAAM,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IAC5B,OAAO,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IAC7B,8BAA8B,CAAC,EAAE,OAAO,GAAG,UAAU,CAAA;CACtD;AAKD,qBAAa,wBAAyB,SAAQ,WAAW;IACvD,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAA0B;IAE7E,YAAY,OAAO,GAAE,sBAA2B,EAG/C;IAED,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,sBAAsB,CAAC,GAAG,IAAI,CAanD;IAED,SAAS,IAAI,IAAI,CAAG;IAEpB,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAE/B;CACF;AAKD,qBAAa,yBAA0B,SAAQ,WAAW;IACxD,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAA2B;IAE9E,YAAY,OAAO,GAAE,uBAA4B,EAGhD;IAED,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,uBAAuB,CAAC,GAAG,IAAI,CAmBpD;IAED,SAAS,IAAI,IAAI,CAAG;IAEpB,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAE/B;CACF;AAED,MAAM,MAAM,mBAAmB,GAAG,sBAAsB,CAAA;AAMxD,qBAAa,qBAAsB,SAAQ,oBAAoB;IAC7D,QAAQ,CAAC,KAAK,EAAE;QACd,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KACtB,CAAA;IAED,QAAQ,CAAC,MAAM;;;MAGd;IAED,YACE,OAAO,EAAE,mBAAmB,EAO7B;CACF","sourcesContent":["import {\n  assignBuilderFactory,\n  BaseBuilder,\n  buildTree,\n  type Expression,\n  SCREEN_TYPE,\n  toExpression,\n} from '../abstract/index.js'\nimport {\n  type ScreenBase,\n  type ScreenBaseBuilderInput,\n  ScreenBaseBuilderNew,\n} from './screen.abstract.js'\n\n/**\n * Display PDF files or HTML pages inside app.\n * Use for reports, terms of service, help docs.\n * Load from URL, base64 data, or inline content.\n * PDF: View documents without external apps.\n * HTML: Embed web content with tracking control.\n * Commonly paired with generate-pdf action.\n * @alias jig.document\n * @see #/definitions/jig-document-specification\n */\nexport interface DocumentScreen extends ScreenBase {\n  readonly type: typeof SCREEN_TYPE.DOCUMENT\n  readonly source: DocumentScreenSource\n}\n\ninterface DocumentPdfSource {\n  readonly documentType: 'PDF'\n  readonly uri?: string | Expression\n  readonly base64?: string | Expression\n  readonly content?: string | Expression\n}\n\ninterface DocumentHtmlSource {\n  readonly documentType: 'HTML'\n  readonly uri?: string | Expression\n  readonly base64?: string | Expression\n  readonly content?: string | Expression\n  readonly isTrackingTransparencyRequired?: boolean | Expression\n}\n\ntype DocumentScreenSource = DocumentPdfSource | DocumentHtmlSource\n\nexport interface DocumentPdfSourceInput {\n  uri?: string | Expression\n  base64?: string | Expression\n  content?: string | Expression\n}\n\nexport interface DocumentHtmlSourceInput {\n  uri?: string | Expression\n  base64?: string | Expression\n  content?: string | Expression\n  isTrackingTransparencyRequired?: boolean | Expression\n}\n\n/**\n * Builds PDF document source.\n */\nexport class DocumentPdfSourceBuilder extends BaseBuilder {\n  protected readonly _config: Record<string, unknown> = { documentType: 'PDF' }\n\n  constructor(options: DocumentPdfSourceInput = {}) {\n    super()\n    this.with(options)\n  }\n\n  with(options: Partial<DocumentPdfSourceInput>): this {\n    if (options.uri !== undefined) {\n      this._config.uri = typeof options.uri === 'string' ? options.uri : toExpression(options.uri)\n    }\n    if (options.base64 !== undefined) {\n      this._config.base64 =\n        typeof options.base64 === 'string' ? options.base64 : toExpression(options.base64)\n    }\n    if (options.content !== undefined) {\n      this._config.content =\n        typeof options.content === 'string' ? options.content : toExpression(options.content)\n    }\n    return this\n  }\n\n  _validate(): void {}\n\n  build(): Record<string, unknown> {\n    return buildTree(this._config)\n  }\n}\n\n/**\n * Builds HTML document source.\n */\nexport class DocumentHtmlSourceBuilder extends BaseBuilder {\n  protected readonly _config: Record<string, unknown> = { documentType: 'HTML' }\n\n  constructor(options: DocumentHtmlSourceInput = {}) {\n    super()\n    this.with(options)\n  }\n\n  with(options: Partial<DocumentHtmlSourceInput>): this {\n    if (options.uri !== undefined) {\n      this._config.uri = typeof options.uri === 'string' ? options.uri : toExpression(options.uri)\n    }\n    if (options.base64 !== undefined) {\n      this._config.base64 =\n        typeof options.base64 === 'string' ? options.base64 : toExpression(options.base64)\n    }\n    if (options.content !== undefined) {\n      this._config.content =\n        typeof options.content === 'string' ? options.content : toExpression(options.content)\n    }\n    if (options.isTrackingTransparencyRequired !== undefined) {\n      this._config.isTrackingTransparencyRequired =\n        typeof options.isTrackingTransparencyRequired === 'string'\n          ? toExpression(options.isTrackingTransparencyRequired)\n          : options.isTrackingTransparencyRequired\n    }\n    return this\n  }\n\n  _validate(): void {}\n\n  build(): Record<string, unknown> {\n    return buildTree(this._config)\n  }\n}\n\nexport type DocumentScreenInput = ScreenBaseBuilderInput\n\n/**\n * Builds screens for PDF/HTML document display.\n * Supports URLs, base64, and inline content.\n */\nexport class DocumentScreenBuilder extends ScreenBaseBuilderNew {\n  readonly state: {\n    readonly data: string\n  }\n\n  readonly source = {\n    pdf: assignBuilderFactory(DocumentPdfSourceBuilder, this._config, 'source'),\n    html: assignBuilderFactory(DocumentHtmlSourceBuilder, this._config, 'source'),\n  }\n\n  constructor(\n    options: DocumentScreenInput,\n  ) {\n    super(SCREEN_TYPE.DOCUMENT, options)\n\n    this.state = {\n      data: `@ctx.jigs.${this.screenId}.state.data`,\n    }\n  }\n}\n"]}

package/dist/screen/screen.document.js

@@ -0,0 +1,72 @@
+import { assignBuilderFactory, BaseBuilder, buildTree, SCREEN_TYPE, toExpression, } from '../abstract/index.js';
+import { ScreenBaseBuilderNew, } from './screen.abstract.js';
+export class DocumentPdfSourceBuilder extends BaseBuilder {
+    _config = { documentType: 'PDF' };
+    constructor(options = {}) {
+        super();
+        this.with(options);
+    }
+    with(options) {
+        if (options.uri !== undefined) {
+            this._config.uri = typeof options.uri === 'string' ? options.uri : toExpression(options.uri);
+        }
+        if (options.base64 !== undefined) {
+            this._config.base64 =
+                typeof options.base64 === 'string' ? options.base64 : toExpression(options.base64);
+        }
+        if (options.content !== undefined) {
+            this._config.content =
+                typeof options.content === 'string' ? options.content : toExpression(options.content);
+        }
+        return this;
+    }
+    _validate() { }
+    build() {
+        return buildTree(this._config);
+    }
+}
+export class DocumentHtmlSourceBuilder extends BaseBuilder {
+    _config = { documentType: 'HTML' };
+    constructor(options = {}) {
+        super();
+        this.with(options);
+    }
+    with(options) {
+        if (options.uri !== undefined) {
+            this._config.uri = typeof options.uri === 'string' ? options.uri : toExpression(options.uri);
+        }
+        if (options.base64 !== undefined) {
+            this._config.base64 =
+                typeof options.base64 === 'string' ? options.base64 : toExpression(options.base64);
+        }
+        if (options.content !== undefined) {
+            this._config.content =
+                typeof options.content === 'string' ? options.content : toExpression(options.content);
+        }
+        if (options.isTrackingTransparencyRequired !== undefined) {
+            this._config.isTrackingTransparencyRequired =
+                typeof options.isTrackingTransparencyRequired === 'string'
+                    ? toExpression(options.isTrackingTransparencyRequired)
+                    : options.isTrackingTransparencyRequired;
+        }
+        return this;
+    }
+    _validate() { }
+    build() {
+        return buildTree(this._config);
+    }
+}
+export class DocumentScreenBuilder extends ScreenBaseBuilderNew {
+    state;
+    source = {
+        pdf: assignBuilderFactory(DocumentPdfSourceBuilder, this._config, 'source'),
+        html: assignBuilderFactory(DocumentHtmlSourceBuilder, this._config, 'source'),
+    };
+    constructor(options) {
+        super(SCREEN_TYPE.DOCUMENT, options);
+        this.state = {
+            data: `@ctx.jigs.${this.screenId}.state.data`,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"screen.document.js","sourceRoot":"","sources":["../../src/screen/screen.document.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  assignBuilderFactory,\n  BaseBuilder,\n  buildTree,\n  type Expression,\n  SCREEN_TYPE,\n  toExpression,\n} from '../abstract/index.js'\nimport {\n  type ScreenBase,\n  type ScreenBaseBuilderInput,\n  ScreenBaseBuilderNew,\n} from './screen.abstract.js'\n\n/**\n * Display PDF files or HTML pages inside app.\n * Use for reports, terms of service, help docs.\n * Load from URL, base64 data, or inline content.\n * PDF: View documents without external apps.\n * HTML: Embed web content with tracking control.\n * Commonly paired with generate-pdf action.\n * @alias jig.document\n * @see #/definitions/jig-document-specification\n */\nexport interface DocumentScreen extends ScreenBase {\n  readonly type: typeof SCREEN_TYPE.DOCUMENT\n  readonly source: DocumentScreenSource\n}\n\ninterface DocumentPdfSource {\n  readonly documentType: 'PDF'\n  readonly uri?: string | Expression\n  readonly base64?: string | Expression\n  readonly content?: string | Expression\n}\n\ninterface DocumentHtmlSource {\n  readonly documentType: 'HTML'\n  readonly uri?: string | Expression\n  readonly base64?: string | Expression\n  readonly content?: string | Expression\n  readonly isTrackingTransparencyRequired?: boolean | Expression\n}\n\ntype DocumentScreenSource = DocumentPdfSource | DocumentHtmlSource\n\nexport interface DocumentPdfSourceInput {\n  uri?: string | Expression\n  base64?: string | Expression\n  content?: string | Expression\n}\n\nexport interface DocumentHtmlSourceInput {\n  uri?: string | Expression\n  base64?: string | Expression\n  content?: string | Expression\n  isTrackingTransparencyRequired?: boolean | Expression\n}\n\n/**\n * Builds PDF document source.\n */\nexport class DocumentPdfSourceBuilder extends BaseBuilder {\n  protected readonly _config: Record<string, unknown> = { documentType: 'PDF' }\n\n  constructor(options: DocumentPdfSourceInput = {}) {\n    super()\n    this.with(options)\n  }\n\n  with(options: Partial<DocumentPdfSourceInput>): this {\n    if (options.uri !== undefined) {\n      this._config.uri = typeof options.uri === 'string' ? options.uri : toExpression(options.uri)\n    }\n    if (options.base64 !== undefined) {\n      this._config.base64 =\n        typeof options.base64 === 'string' ? options.base64 : toExpression(options.base64)\n    }\n    if (options.content !== undefined) {\n      this._config.content =\n        typeof options.content === 'string' ? options.content : toExpression(options.content)\n    }\n    return this\n  }\n\n  _validate(): void {}\n\n  build(): Record<string, unknown> {\n    return buildTree(this._config)\n  }\n}\n\n/**\n * Builds HTML document source.\n */\nexport class DocumentHtmlSourceBuilder extends BaseBuilder {\n  protected readonly _config: Record<string, unknown> = { documentType: 'HTML' }\n\n  constructor(options: DocumentHtmlSourceInput = {}) {\n    super()\n    this.with(options)\n  }\n\n  with(options: Partial<DocumentHtmlSourceInput>): this {\n    if (options.uri !== undefined) {\n      this._config.uri = typeof options.uri === 'string' ? options.uri : toExpression(options.uri)\n    }\n    if (options.base64 !== undefined) {\n      this._config.base64 =\n        typeof options.base64 === 'string' ? options.base64 : toExpression(options.base64)\n    }\n    if (options.content !== undefined) {\n      this._config.content =\n        typeof options.content === 'string' ? options.content : toExpression(options.content)\n    }\n    if (options.isTrackingTransparencyRequired !== undefined) {\n      this._config.isTrackingTransparencyRequired =\n        typeof options.isTrackingTransparencyRequired === 'string'\n          ? toExpression(options.isTrackingTransparencyRequired)\n          : options.isTrackingTransparencyRequired\n    }\n    return this\n  }\n\n  _validate(): void {}\n\n  build(): Record<string, unknown> {\n    return buildTree(this._config)\n  }\n}\n\nexport type DocumentScreenInput = ScreenBaseBuilderInput\n\n/**\n * Builds screens for PDF/HTML document display.\n * Supports URLs, base64, and inline content.\n */\nexport class DocumentScreenBuilder extends ScreenBaseBuilderNew {\n  readonly state: {\n    readonly data: string\n  }\n\n  readonly source = {\n    pdf: assignBuilderFactory(DocumentPdfSourceBuilder, this._config, 'source'),\n    html: assignBuilderFactory(DocumentHtmlSourceBuilder, this._config, 'source'),\n  }\n\n  constructor(\n    options: DocumentScreenInput,\n  ) {\n    super(SCREEN_TYPE.DOCUMENT, options)\n\n    this.state = {\n      data: `@ctx.jigs.${this.screenId}.state.data`,\n    }\n  }\n}\n"]}

package/dist/screen/screen.full-screen.d.ts

@@ -0,0 +1,23 @@
+import { SCREEN_TYPE } from '../abstract/index.js';
+import { type JcBase } from '../component/index.js';
+import { JcChatBuilder } from '../component/jc.chat.js';
+import { JcCustomComponentInteropBuilder } from '../component/jc.custom-component.interop.js';
+import { JcLocationBuilder } from '../component/jc.location.js';
+import { JcWebViewOnFullBuilder } from '../component/jc.web-view.on-full.js';
+import { type ScreenBase, type ScreenBaseBuilderInput, ScreenBaseBuilderNew } from './screen.abstract.js';
+export type FullScreenChild = JcBase;
+export type FullScreenInput = ScreenBaseBuilderInput;
+export interface FullScreen extends ScreenBase {
+    readonly type: typeof SCREEN_TYPE.FULL_SCREEN;
+    readonly component: FullScreenChild;
+}
+export declare class FullScreenBuilder extends ScreenBaseBuilderNew {
+    readonly addControl: {
+        location: (options?: import("../component/jc.location.js").JcLocationInput | undefined) => JcLocationBuilder;
+        chat: (options?: import("../component/jc.chat.js").JcChatInput | undefined) => JcChatBuilder;
+        webView: (options?: import("../component/jc.web-view.on-full.js").JcWebViewOnFullInput | undefined) => JcWebViewOnFullBuilder;
+        customComponent: (input: import("../component/jc.custom-component.interop.js").JcCustomComponentInteropInput) => JcCustomComponentInteropBuilder;
+    };
+    constructor(options: FullScreenInput);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/screen/screen.full-screen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen.full-screen.d.ts","sourceRoot":"","sources":["../../src/screen/screen.full-screen.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,WAAW,EAAE,MAAM,sBAAsB,CAAA;AACxE,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,uBAAuB,CAAA;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AACvD,OAAO,EAAE,+BAA+B,EAAE,MAAM,6CAA6C,CAAA;AAC7F,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AAC/D,OAAO,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAA;AAC5E,OAAO,EACL,KAAK,UAAU,EACf,KAAK,sBAAsB,EAC3B,oBAAoB,EACrB,MAAM,sBAAsB,CAAA;AAG7B,MAAM,MAAM,eAAe,GAAG,MAAM,CAAA;AAEpC,MAAM,MAAM,eAAe,GAAG,sBAAsB,CAAA;AAiBpD,MAAM,WAAW,UAAW,SAAQ,UAAU;IAC5C,QAAQ,CAAC,IAAI,EAAE,OAAO,WAAW,CAAC,WAAW,CAAA;IAC7C,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAA;CACpC;AAOD,qBAAa,iBAAkB,SAAQ,oBAAoB;IAEzD,QAAQ,CAAC,UAAU;;;;;MASlB;IAED,YACE,OAAO,EAAE,eAAe,EAGzB;CACF","sourcesContent":["import { assignBuilderFactory, SCREEN_TYPE } from '../abstract/index.js'\nimport { type JcBase } from '../component/index.js'\nimport { JcChatBuilder } from '../component/jc.chat.js'\nimport { JcCustomComponentInteropBuilder } from '../component/jc.custom-component.interop.js'\nimport { JcLocationBuilder } from '../component/jc.location.js'\nimport { JcWebViewOnFullBuilder } from '../component/jc.web-view.on-full.js'\nimport {\n  type ScreenBase,\n  type ScreenBaseBuilderInput,\n  ScreenBaseBuilderNew,\n} from './screen.abstract.js'\n\n/** @see #/definitions/JigFullScreenChild */\nexport type FullScreenChild = JcBase\n\nexport type FullScreenInput = ScreenBaseBuilderInput\n\n/**\n * Display single component in full screen\n * Support location, chat, webview components\n *\n * Use full-screen screens when:\n * - Displaying maps with interactive location features and markers\n * - Creating chat interfaces for customer support or messaging\n * - Embedding web content that needs maximum screen real estate\n * - Building custom components that require full attention\n * - Designing immersive experiences that break out of normal app flow\n * - Focusing user attention on a single critical task or decision\n *\n * @alias jig.full-screen\n * @see #/definitions/jig-full-screen-specification\n */\nexport interface FullScreen extends ScreenBase {\n  readonly type: typeof SCREEN_TYPE.FULL_SCREEN\n  readonly component: FullScreenChild\n}\n\n/**\n * Build full-screen immersive experiences.\n * Display one component taking entire viewport.\n * Support location, chat, webview, custom components.\n */\nexport class FullScreenBuilder extends ScreenBaseBuilderNew {\n  /** Component factory. Only one component per full-screen. */\n  readonly addControl = {\n    location: assignBuilderFactory(JcLocationBuilder, this._config, 'component'),\n    chat: assignBuilderFactory(JcChatBuilder, this._config, 'component'),\n    webView: assignBuilderFactory(JcWebViewOnFullBuilder, this._config, 'component'),\n    customComponent: assignBuilderFactory(\n      JcCustomComponentInteropBuilder,\n      this._config,\n      'component',\n    ),\n  }\n\n  constructor(\n    options: FullScreenInput,\n  ) {\n    super(SCREEN_TYPE.FULL_SCREEN, options)\n  }\n}\n"]}

package/dist/screen/screen.full-screen.js

@@ -0,0 +1,18 @@
+import { assignBuilderFactory, SCREEN_TYPE } from '../abstract/index.js';
+import { JcChatBuilder } from '../component/jc.chat.js';
+import { JcCustomComponentInteropBuilder } from '../component/jc.custom-component.interop.js';
+import { JcLocationBuilder } from '../component/jc.location.js';
+import { JcWebViewOnFullBuilder } from '../component/jc.web-view.on-full.js';
+import { ScreenBaseBuilderNew, } from './screen.abstract.js';
+export class FullScreenBuilder extends ScreenBaseBuilderNew {
+    addControl = {
+        location: assignBuilderFactory(JcLocationBuilder, this._config, 'component'),
+        chat: assignBuilderFactory(JcChatBuilder, this._config, 'component'),
+        webView: assignBuilderFactory(JcWebViewOnFullBuilder, this._config, 'component'),
+        customComponent: assignBuilderFactory(JcCustomComponentInteropBuilder, this._config, 'component'),
+    };
+    constructor(options) {
+        super(SCREEN_TYPE.FULL_SCREEN, options);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/screen/screen.gallery.d.ts

@@ -0,0 +1,15 @@
+import { type Expression, SCREEN_TYPE } from '../abstract/index.js';
+import { type JcBase, JcGalleryItemBuilder } from '../component/index.js';
+import { type ScreenBase, type ScreenBaseBuilderInput, ScreenBaseBuilderNew } from './screen.abstract.js';
+export interface GalleryScreen extends ScreenBase {
+    readonly type: typeof SCREEN_TYPE.GALLERY;
+    readonly item: JcBase;
+    data?: Expression;
+}
+export type GalleryScreenInput = ScreenBaseBuilderInput;
+export declare class GalleryScreenBuilder extends ScreenBaseBuilderNew {
+    constructor(options: GalleryScreenInput);
+    item: (options: import("../component/jc.gallery-item.ts").JcGalleryItemInput) => JcGalleryItemBuilder;
+    data(data: string | Expression): this;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/screen/screen.gallery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen.gallery.d.ts","sourceRoot":"","sources":["../../src/screen/screen.gallery.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,UAAU,EACf,WAAW,EAEZ,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,KAAK,MAAM,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAA;AACzE,OAAO,EACL,KAAK,UAAU,EACf,KAAK,sBAAsB,EAC3B,oBAAoB,EACrB,MAAM,sBAAsB,CAAA;AAO7B,MAAM,WAAW,aAAc,SAAQ,UAAU;IAC/C,QAAQ,CAAC,IAAI,EAAE,OAAO,WAAW,CAAC,OAAO,CAAA;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,IAAI,CAAC,EAAE,UAAU,CAAA;CAClB;AAED,MAAM,MAAM,kBAAkB,GAAG,sBAAsB,CAAA;AAMvD,qBAAa,oBAAqB,SAAQ,oBAAoB;IAC5D,YAAY,OAAO,EAAE,kBAAkB,EAEtC;IAGD,IAAI,kGAAmE;IAMvE,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAGpC;CACF","sourcesContent":["import {\n  assignBuilderFactory,\n  type Expression,\n  SCREEN_TYPE,\n  toExpression,\n} from '../abstract/index.js'\nimport { type JcBase, JcGalleryItemBuilder } from '../component/index.js'\nimport {\n  type ScreenBase,\n  type ScreenBaseBuilderInput,\n  ScreenBaseBuilderNew,\n} from './screen.abstract.js'\n\n/**\n * Data-bound gallery screen with item template.\n * @alias jig.gallery\n * @see #/definitions/jig-gallery-specification\n */\nexport interface GalleryScreen extends ScreenBase {\n  readonly type: typeof SCREEN_TYPE.GALLERY\n  readonly item: JcBase\n  data?: Expression\n}\n\nexport type GalleryScreenInput = ScreenBaseBuilderInput\n\n/**\n * Builds gallery screens with data-bound item rendering.\n * Bind a datasource expression and configure the item template.\n */\nexport class GalleryScreenBuilder extends ScreenBaseBuilderNew {\n  constructor(options: GalleryScreenInput) {\n    super(SCREEN_TYPE.GALLERY, options)\n  }\n\n  /** Configure the gallery item template. */\n  item = assignBuilderFactory(JcGalleryItemBuilder, this._config, 'item')\n\n  /**\n   * Sets the data source expression for the gallery.\n   * @param data - Expression returning the data array\n   */\n  data(data: string | Expression): this {\n    this._config.data = toExpression(data)\n    return this\n  }\n}\n"]}

package/dist/screen/screen.gallery.js

@@ -0,0 +1,14 @@
+import { assignBuilderFactory, SCREEN_TYPE, toExpression, } from '../abstract/index.js';
+import { JcGalleryItemBuilder } from '../component/index.js';
+import { ScreenBaseBuilderNew, } from './screen.abstract.js';
+export class GalleryScreenBuilder extends ScreenBaseBuilderNew {
+    constructor(options) {
+        super(SCREEN_TYPE.GALLERY, options);
+    }
+    item = assignBuilderFactory(JcGalleryItemBuilder, this._config, 'item');
+    data(data) {
+        this._config.data = toExpression(data);
+        return this;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/screen/screen.grid.base.d.ts

@@ -0,0 +1,18 @@
+import { SCREEN_TYPE } from '../abstract/index.js';
+import { type Filter } from '../component/index.js';
+import { type ScreenBase, type ScreenBaseBuilderInput, ScreenBaseBuilderNew } from './screen.abstract.js';
+import { ListFilterBuilder } from './screen.list.js';
+export interface BaseGridScreen extends ScreenBase {
+    readonly type: typeof SCREEN_TYPE.GRID;
+    filter?: Filter;
+    isSearchable?: boolean;
+}
+export interface GridScreenInput extends ScreenBaseBuilderInput {
+    readonly isSearchable?: boolean;
+}
+export declare abstract class GridScreenBaseBuilder extends ScreenBaseBuilderNew {
+    protected constructor(options: GridScreenInput);
+    with(options: Partial<Omit<GridScreenInput, 'screenId'>>): this;
+    filter: (options: import("./screen.list.js").ListFilterBuilderInput) => ListFilterBuilder;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/screen/screen.grid.base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen.grid.base.d.ts","sourceRoot":"","sources":["../../src/screen/screen.grid.base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,WAAW,EAAE,MAAM,sBAAsB,CAAA;AACxE,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,uBAAuB,CAAA;AACnD,OAAO,EACL,KAAK,UAAU,EACf,KAAK,sBAAsB,EAC3B,oBAAoB,EACrB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAQpD,MAAM,WAAW,cAAe,SAAQ,UAAU;IAChD,QAAQ,CAAC,IAAI,EAAE,OAAO,WAAW,CAAC,IAAI,CAAA;IACtC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB;AAED,MAAM,WAAW,eAAgB,SAAQ,sBAAsB;IAC7D,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAA;CAChC;AAOD,8BAAsB,qBAAsB,SAAQ,oBAAoB;IACtE,SAAS,aAAa,OAAO,EAAE,eAAe,EAE7C;IAEQ,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,eAAe,EAAE,UAAU,CAAC,CAAC,GAAG,IAAI,CAQvE;IAED,MAAM,oFAAkE;CACzE","sourcesContent":["import { assignBuilderFactory, SCREEN_TYPE } from '../abstract/index.js'\nimport { type Filter } from '../component/index.js'\nimport {\n  type ScreenBase,\n  type ScreenBaseBuilderInput,\n  ScreenBaseBuilderNew,\n} from './screen.abstract.js'\nimport { ListFilterBuilder } from './screen.list.js'\n\n/**\n * Base interface for grid layout screens.\n * Foundation for static and dynamic grid variations.\n * @alias jig.grid\n * @see #/definitions/jig-grid-specification\n */\nexport interface BaseGridScreen extends ScreenBase {\n  readonly type: typeof SCREEN_TYPE.GRID\n  filter?: Filter\n  isSearchable?: boolean\n}\n\nexport interface GridScreenInput extends ScreenBaseBuilderInput {\n  readonly isSearchable?: boolean\n}\n\n/**\n * Base builder for grid screens.\n * Shared foundation for static and dynamic grids.\n * @see #/definitions/jig-grid-specification\n */\nexport abstract class GridScreenBaseBuilder extends ScreenBaseBuilderNew {\n  protected constructor(options: GridScreenInput) {\n    super(SCREEN_TYPE.GRID, options)\n  }\n\n  override with(options: Partial<Omit<GridScreenInput, 'screenId'>>): this {\n    super.with(options)\n\n    if (options.isSearchable !== undefined) {\n      this._config.isSearchable = options.isSearchable\n    }\n\n    return this\n  }\n\n  filter = assignBuilderFactory(ListFilterBuilder, this._config, 'filter')\n}\n"]}

package/dist/screen/screen.grid.base.js

@@ -0,0 +1,17 @@
+import { assignBuilderFactory, SCREEN_TYPE } from '../abstract/index.js';
+import { ScreenBaseBuilderNew, } from './screen.abstract.js';
+import { ListFilterBuilder } from './screen.list.js';
+export class GridScreenBaseBuilder extends ScreenBaseBuilderNew {
+    constructor(options) {
+        super(SCREEN_TYPE.GRID, options);
+    }
+    with(options) {
+        super.with(options);
+        if (options.isSearchable !== undefined) {
+            this._config.isSearchable = options.isSearchable;
+        }
+        return this;
+    }
+    filter = assignBuilderFactory(ListFilterBuilder, this._config, 'filter');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/screen/screen.grid.dynamic.d.ts

@@ -0,0 +1,18 @@
+import { type DatasourceId, type Expression } from '../abstract/index.js';
+import { type JcBase, JcGridItemBuilder } from '../component/index.js';
+import { type DatasourceBase } from '../datasource/index.js';
+import { type ScreenBaseBuilderInput } from './screen.abstract.js';
+import { type BaseGridScreen, GridScreenBaseBuilder } from './screen.grid.base.js';
+export interface DynamicGridScreen extends BaseGridScreen {
+    readonly item: JcBase;
+    data?: Expression | string;
+}
+export type DynamicGridScreenInput = ScreenBaseBuilderInput;
+export declare class DynamicGridScreenBuilder extends GridScreenBaseBuilder {
+    readonly addControl: {
+        gridItem: (options?: import("../component/jc.grid-item.ts").JcGridItemInput | undefined) => JcGridItemBuilder;
+    };
+    constructor(options: DynamicGridScreenInput);
+    data(data: DatasourceId | DatasourceBase | Expression): this;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/screen/screen.grid.dynamic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen.grid.dynamic.d.ts","sourceRoot":"","sources":["../../src/screen/screen.grid.dynamic.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,UAAU,EAEhB,MAAM,sBAAsB,CAAA;AAE7B,OAAO,EAAE,KAAK,MAAM,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AACtE,OAAO,EACL,KAAK,cAAc,EAEpB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,sBAAsB,CAAA;AAClE,OAAO,EAAE,KAAK,cAAc,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAA;AAOlF,MAAM,WAAW,iBAAkB,SAAQ,cAAc;IACvD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,IAAI,CAAC,EAAE,UAAU,GAAG,MAAM,CAAA;CAC3B;AAED,MAAM,MAAM,sBAAsB,GAAG,sBAAsB,CAAA;AAO3D,qBAAa,wBAAyB,SAAQ,qBAAqB;IACjE,QAAQ,CAAC,UAAU;;MAElB;IAED,YACE,OAAO,EAAE,sBAAsB,EAGhC;IAKD,IAAI,CAAC,IAAI,EAAE,YAAY,GAAG,cAAc,GAAG,UAAU,GAAG,IAAI,CAS3D;CACF","sourcesContent":["import {\n  assignBuilderFactory,\n  type DatasourceId,\n  type Expression,\n  toExpression,\n} from '../abstract/index.js'\nimport { CTX } from '../application/index.js'\nimport { type JcBase, JcGridItemBuilder } from '../component/index.js'\nimport {\n  type DatasourceBase,\n  isDatasourceBase,\n} from '../datasource/index.js'\nimport { type ScreenBaseBuilderInput } from './screen.abstract.js'\nimport { type BaseGridScreen, GridScreenBaseBuilder } from './screen.grid.base.js'\n\n/**\n * Data-driven grid with template-based items.\n * Single item template applies to all data items.\n * @see #/definitions/jig-grid-specification\n */\nexport interface DynamicGridScreen extends BaseGridScreen {\n  readonly item: JcBase\n  data?: Expression | string\n}\n\nexport type DynamicGridScreenInput = ScreenBaseBuilderInput\n\n/**\n * Builds data-driven grids with template-based items.\n * Single template defines appearance for all items.\n * Items access data via @ctx.current.item expressions.\n */\nexport class DynamicGridScreenBuilder extends GridScreenBaseBuilder {\n  readonly addControl = {\n    gridItem: assignBuilderFactory(JcGridItemBuilder, this._config, 'item'),\n  }\n\n  constructor(\n    options: DynamicGridScreenInput,\n  ) {\n    super(options)\n  }\n\n  /**\n   * Sets data source for grid items.\n   */\n  data(data: DatasourceId | DatasourceBase | Expression): this {\n    if (isDatasourceBase(data)) {\n      this._config.data = CTX.datasources.expr(data.datasourceId)\n    } else if (data.startsWith('=')) {\n      this._config.data = toExpression(data)\n    } else {\n      this._config.data = CTX.datasources.expr(data)\n    }\n    return this\n  }\n}\n"]}

package/dist/screen/screen.grid.dynamic.js

@@ -0,0 +1,26 @@
+import { assignBuilderFactory, toExpression, } from '../abstract/index.js';
+import { CTX } from '../application/index.js';
+import { JcGridItemBuilder } from '../component/index.js';
+import { isDatasourceBase, } from '../datasource/index.js';
+import { GridScreenBaseBuilder } from './screen.grid.base.js';
+export class DynamicGridScreenBuilder extends GridScreenBaseBuilder {
+    addControl = {
+        gridItem: assignBuilderFactory(JcGridItemBuilder, this._config, 'item'),
+    };
+    constructor(options) {
+        super(options);
+    }
+    data(data) {
+        if (isDatasourceBase(data)) {
+            this._config.data = CTX.datasources.expr(data.datasourceId);
+        }
+        else if (data.startsWith('=')) {
+            this._config.data = toExpression(data);
+        }
+        else {
+            this._config.data = CTX.datasources.expr(data);
+        }
+        return this;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/screen/screen.grid.static.d.ts

@@ -0,0 +1,14 @@
+import { type JcBase, JcGridItemBuilder } from '../component/index.js';
+import { type ScreenBaseBuilderInput } from './screen.abstract.js';
+import { type BaseGridScreen, GridScreenBaseBuilder } from './screen.grid.base.js';
+export interface StaticGridScreen extends BaseGridScreen {
+    readonly children: JcBase[];
+}
+export type StaticGridScreenInput = ScreenBaseBuilderInput;
+export declare class StaticGridScreenBuilder extends GridScreenBaseBuilder {
+    readonly addControl: {
+        gridItem: (options?: import("../component/jc.grid-item.ts").JcGridItemInput | undefined) => JcGridItemBuilder;
+    };
+    constructor(options: StaticGridScreenInput);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/screen/screen.grid.static.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen.grid.static.d.ts","sourceRoot":"","sources":["../../src/screen/screen.grid.static.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AACtE,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,sBAAsB,CAAA;AAClE,OAAO,EAAE,KAAK,cAAc,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAA;AAOlF,MAAM,WAAW,gBAAiB,SAAQ,cAAc;IACtD,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAC5B;AAED,MAAM,MAAM,qBAAqB,GAAG,sBAAsB,CAAA;AAO1D,qBAAa,uBAAwB,SAAQ,qBAAqB;IAChE,QAAQ,CAAC,UAAU;;MAElB;IAED,YACE,OAAO,EAAE,qBAAqB,EAG/B;CACF","sourcesContent":["import { pushBuilderFactory } from '../abstract/index.js'\nimport { type JcBase, JcGridItemBuilder } from '../component/index.js'\nimport { type ScreenBaseBuilderInput } from './screen.abstract.js'\nimport { type BaseGridScreen, GridScreenBaseBuilder } from './screen.grid.base.js'\n\n/**\n * Manually configured grid with fixed items.\n * Each item individually sized and configured.\n * @see #/definitions/jig-grid-specification\n */\nexport interface StaticGridScreen extends BaseGridScreen {\n  readonly children: JcBase[]\n}\n\nexport type StaticGridScreenInput = ScreenBaseBuilderInput\n\n/**\n * Builds static grids with manually configured items.\n * Each item individually sized and positioned.\n * Mix different component types and sizes.\n */\nexport class StaticGridScreenBuilder extends GridScreenBaseBuilder {\n  readonly addControl = {\n    gridItem: pushBuilderFactory(JcGridItemBuilder, this._config, 'children'),\n  }\n\n  constructor(\n    options: StaticGridScreenInput,\n  ) {\n    super(options)\n  }\n}\n"]}

package/dist/screen/screen.grid.static.js

@@ -0,0 +1,12 @@
+import { pushBuilderFactory } from '../abstract/index.js';
+import { JcGridItemBuilder } from '../component/index.js';
+import { GridScreenBaseBuilder } from './screen.grid.base.js';
+export class StaticGridScreenBuilder extends GridScreenBaseBuilder {
+    addControl = {
+        gridItem: pushBuilderFactory(JcGridItemBuilder, this._config, 'children'),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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