@jigx/core-sdk 1.0.0

package/dist/component/jc.view.js

@@ -0,0 +1,85 @@
+import { pushBuilderFactory, } from '../abstract/index.js';
+import { createActionInBackgroundBuildersFactory } from '../action/ja.in-background.factory.js';
+import { ComponentBaseBuilder } from './jc.abstract.js';
+import { JcAmountControlBuilder } from './jc.amount-control.js';
+import { JcAvatarBuilder } from './jc.avatar.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 { JcCountDownBuilder } from './jc.count-down.js';
+import { JcCountUpBuilder } from './jc.count-up.js';
+import { JcEntityBuilder } from './jc.entity.js';
+import { JcExpanderBuilder } from './jc.expander.js';
+import { JcFormBuilder } from './jc.form.js';
+import { JcIconBuilder } from './jc.icon.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 { JcListItemBuilder } from './jc.list-item.js';
+import { JcLocationBuilder } from './jc.location.js';
+import { JcPieChartBuilder } from './jc.pie-chart.js';
+import { JcProgressBarBuilder } from './jc.progress-bar.js';
+import { JcRatingBuilder } from './jc.rating.js';
+import { JcSliderBuilder } from './jc.slider.js';
+import { JcStageBuilder } from './jc.stage.js';
+import { JcStepperBuilder } from './jc.stepper.js';
+import { JcTextBuilder } from './jc.text.js';
+import { JcTrendBuilder } from './jc.trend.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 JcViewBuilder extends ComponentBaseBuilder {
+    onPress = createActionInBackgroundBuildersFactory((action) => {
+        this._setToConfig('onPress', action);
+    });
+    constructor(options = {}) {
+        super(COMPONENT_TYPE.VIEW, options);
+        this._config.children = [];
+        this.with(options);
+    }
+    with(options) {
+        super.with(options);
+        if (options.emphasis !== undefined) {
+            this._config.emphasis = options.emphasis;
+        }
+        const { when: _when, emphasis: _emphasis, ...styleProps } = options;
+        if (Object.keys(styleProps).length > 0) {
+            this._config.style = { ...this._config.style, ...styleProps };
+        }
+        return this;
+    }
+    addControl = {
+        amountControl: pushBuilderFactory(JcAmountControlBuilder, this._config, 'children'),
+        avatar: pushBuilderFactory(JcAvatarBuilder, this._config, 'children'),
+        banner: pushBuilderFactory(JcBannerBuilder, this._config, 'children'),
+        barChart: pushBuilderFactory(JcBarChartBuilder, this._config, 'children'),
+        card: pushBuilderFactory(JcCardOnDefaultBuilder, this._config, 'children'),
+        carousel: pushBuilderFactory(JcCarouselBuilder, this._config, 'children'),
+        countDown: pushBuilderFactory(JcCountDownBuilder, this._config, 'children'),
+        countUp: pushBuilderFactory(JcCountUpBuilder, this._config, 'children'),
+        entity: pushBuilderFactory(JcEntityBuilder, this._config, 'children'),
+        expander: pushBuilderFactory(JcExpanderBuilder, this._config, 'children'),
+        form: pushBuilderFactory(JcFormBuilder, this._config, 'children'),
+        icon: pushBuilderFactory(JcIconBuilder, this._config, 'children'),
+        image: pushBuilderFactory(JcImageOnDefaultBuilder, this._config, 'children'),
+        interactiveImage: pushBuilderFactory(JcInteractiveImageBuilder, this._config, 'children'),
+        lineChart: pushBuilderFactory(JcLineChartBuilder, this._config, 'children'),
+        list: pushBuilderFactory(JcListBuilder, this._config, 'children'),
+        listItem: pushBuilderFactory(JcListItemBuilder, this._config, 'children'),
+        location: pushBuilderFactory(JcLocationBuilder, this._config, 'children'),
+        pieChart: pushBuilderFactory(JcPieChartBuilder, this._config, 'children'),
+        progressBar: pushBuilderFactory(JcProgressBarBuilder, this._config, 'children'),
+        rating: pushBuilderFactory(JcRatingBuilder, this._config, 'children'),
+        slider: pushBuilderFactory(JcSliderBuilder, this._config, 'children'),
+        stage: pushBuilderFactory(JcStageBuilder, this._config, 'children'),
+        stepper: pushBuilderFactory(JcStepperBuilder, this._config, 'children'),
+        text: pushBuilderFactory(JcTextBuilder, this._config, 'children'),
+        trend: pushBuilderFactory(JcTrendBuilder, this._config, 'children'),
+        view: pushBuilderFactory(JcViewBuilder, this._config, 'children'),
+        videoPlayer: pushBuilderFactory(JcVideoPlayerOnJigBuilder, this._config, 'children'),
+        webView: pushBuilderFactory(JcWebViewOnDefaultBuilder, this._config, 'children'),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jc.view.js","sourceRoot":"","sources":["../../src/component/jc.view.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  type BooleanOrExpression,\n  type ColorValueOrConditions,\n  type EmphasisDefinition,\n  type Expression,\n  type NumberOrExpression,\n  pushBuilderFactory,\n} from '../abstract/index.js'\nimport { createActionInBackgroundBuildersFactory } from '../action/ja.in-background.factory.js'\nimport { type JcBaseInput, ComponentBaseBuilder } from './jc.abstract.js'\nimport { JcAmountControlBuilder } from './jc.amount-control.js'\nimport { JcAvatarBuilder } from './jc.avatar.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 { JcCountDownBuilder } from './jc.count-down.js'\nimport { JcCountUpBuilder } from './jc.count-up.js'\nimport { JcEntityBuilder } from './jc.entity.js'\nimport { JcExpanderBuilder } from './jc.expander.js'\nimport { JcFormBuilder } from './jc.form.js'\nimport { JcIconBuilder } from './jc.icon.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 { JcListItemBuilder } from './jc.list-item.js'\nimport { JcLocationBuilder } from './jc.location.js'\nimport { JcPieChartBuilder } from './jc.pie-chart.js'\nimport { JcProgressBarBuilder } from './jc.progress-bar.js'\nimport { JcRatingBuilder } from './jc.rating.js'\nimport { JcSliderBuilder } from './jc.slider.js'\nimport { JcStageBuilder } from './jc.stage.js'\nimport { JcStepperBuilder } from './jc.stepper.js'\nimport { JcTextBuilder } from './jc.text.js'\nimport { JcTrendBuilder } from './jc.trend.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/** Spacing values used for margin, padding, gap, and position offsets. */\ntype SpacingType = 'none' | 'minimal' | 'small' | 'medium' | 'regular' | 'large'\n\n/** Corner radius values. */\ntype RadiusType = 'tiny' | 'small' | 'medium' | 'regular' | 'large'\n\n/** Flex direction values. */\ntype FlexDirection = 'row' | 'column' | 'row-reverse' | 'column-reverse'\n\n/** Flex wrap values. */\ntype FlexWrap = 'wrap' | 'nowrap' | 'wrap-reverse'\n\n/** Justify content values. */\ntype JustifyContent =\n  | 'flex-start'\n  | 'flex-end'\n  | 'center'\n  | 'space-between'\n  | 'space-around'\n  | 'space-evenly'\n\n/** Align items values. */\ntype AlignItems = 'flex-start' | 'flex-end' | 'center' | 'stretch' | 'baseline'\n\n/** Align content values. */\ntype AlignContent =\n  | 'flex-start'\n  | 'flex-end'\n  | 'center'\n  | 'stretch'\n  | 'space-between'\n  | 'space-around'\n\n/** Align self values. */\ntype AlignSelf = 'auto' | 'flex-start' | 'flex-end' | 'center' | 'stretch' | 'baseline'\n\n/** Overflow values. */\ntype Overflow = 'visible' | 'hidden' | 'scroll'\n\n/** Position values. */\ntype Position = 'absolute' | 'relative'\n\n/** Border style values. */\ntype BorderStyleType = 'solid' | 'transparent'\n\n/** Spacing object for directional values. */\ninterface SpacingObject {\n  readonly top?: SpacingType | Expression\n  readonly bottom?: SpacingType | Expression\n  readonly left?: SpacingType | Expression\n  readonly right?: SpacingType | Expression\n  readonly start?: SpacingType | Expression\n  readonly end?: SpacingType | Expression\n  readonly horizontal?: SpacingType | Expression\n  readonly vertical?: SpacingType | Expression\n}\n\n/** Dimension object with min/max constraints. */\ninterface DimensionObject {\n  readonly value?: number | string | Expression\n  readonly min?: number | string | Expression\n  readonly max?: number | string | Expression\n}\n\n/** Gap configuration. */\ninterface GapObject {\n  readonly column?: SpacingType | Expression\n  readonly row?: SpacingType | Expression\n}\n\n/** Flex configuration object. */\ninterface FlexObject {\n  readonly direction?: FlexDirection | Expression\n  readonly grow?: NumberOrExpression\n  readonly basis?: number | string | Expression\n  readonly shrink?: NumberOrExpression\n  readonly wrap?: FlexWrap\n}\n\n/** Radius configuration for individual corners. */\ninterface RadiusObject {\n  readonly topLeft?: RadiusType | Expression\n  readonly topRight?: RadiusType | Expression\n  readonly bottomLeft?: RadiusType | Expression\n  readonly bottomRight?: RadiusType | Expression\n}\n\n/** Border side configuration. */\ninterface BorderSide {\n  readonly style: BorderStyleType | Expression\n  readonly color?: ColorValueOrConditions\n  readonly emphasis?: EmphasisDefinition\n  readonly width?: NumberOrExpression\n}\n\n/** Full border configuration. */\ninterface BorderObject {\n  readonly style?: BorderStyleType | Expression\n  readonly color?: ColorValueOrConditions\n  readonly emphasis?: EmphasisDefinition\n  readonly width?: NumberOrExpression\n  readonly top?: BorderSide\n  readonly bottom?: BorderSide\n  readonly left?: BorderSide\n  readonly right?: BorderSide\n  readonly start?: BorderSide\n  readonly end?: BorderSide\n}\n\n/** Background configuration. */\ninterface BackgroundObject {\n  readonly color?: ColorValueOrConditions\n  readonly emphasis?: EmphasisDefinition\n}\n\n/**\n * Complete view style specification.\n */\nexport interface ViewStyleSpecification {\n  readonly hasShadow?: BooleanOrExpression\n  readonly emphasis?: EmphasisDefinition\n  readonly flex?: NumberOrExpression | FlexObject\n  readonly justifyContent?: JustifyContent | Expression\n  readonly alignItems?: AlignItems | Expression\n  readonly alignContent?: AlignContent | Expression\n  readonly alignSelf?: AlignSelf | Expression\n  readonly overflow?: Overflow | Expression\n  readonly position?: Position | Expression\n  readonly top?: SpacingType | Expression\n  readonly right?: SpacingType | Expression\n  readonly bottom?: SpacingType | Expression\n  readonly left?: SpacingType | Expression\n  readonly width?: number | Expression | DimensionObject\n  readonly height?: number | Expression | DimensionObject\n  readonly margin?: SpacingType | Expression | SpacingObject\n  readonly padding?: SpacingType | Expression | SpacingObject\n  readonly gap?: SpacingType | Expression | GapObject\n  readonly border?: BorderObject\n  readonly radius?: RadiusType | Expression | RadiusObject\n  readonly background?: BackgroundObject\n}\n\n/**\n * Input options for view component.\n * Style properties are flattened — the builder maps them to `style.*` in the config.\n */\nexport interface JcViewInput extends JcBaseInput, ViewStyleSpecification {}\n\n/**\n * Builds view container components for custom layout and positioning.\n * @alias component.view\n */\nexport class JcViewBuilder extends ComponentBaseBuilder<JcViewInput> {\n  /** Action triggered when the view is pressed. */\n  readonly onPress = createActionInBackgroundBuildersFactory((action) => {\n    this._setToConfig('onPress', action)\n  })\n\n  constructor(options: JcViewInput = {}) {\n    super(COMPONENT_TYPE.VIEW, options)\n\n    // Initialize children array\n    this._config.children = []\n    this.with(options)\n  }\n\n  override with(options: Partial<Omit<JcViewInput, 'instanceId'>>): this {\n    super.with(options)\n\n    if (options.emphasis !== undefined) {\n      this._config.emphasis = options.emphasis\n    }\n\n    // Map flat style props to nested style object\n    const { when: _when, emphasis: _emphasis, ...styleProps } = options\n    if (Object.keys(styleProps).length > 0) {\n      this._config.style = { ...(this._config.style as Record<string, unknown>), ...styleProps }\n    }\n\n    return this\n  }\n\n  /** Factory for creating child components inside the view. */\n  addControl = {\n    amountControl: pushBuilderFactory(JcAmountControlBuilder, 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    card: pushBuilderFactory(JcCardOnDefaultBuilder, this._config, 'children'),\n    carousel: pushBuilderFactory(JcCarouselBuilder, this._config, 'children'),\n    countDown: pushBuilderFactory(JcCountDownBuilder, this._config, 'children'),\n    countUp: pushBuilderFactory(JcCountUpBuilder, this._config, 'children'),\n    entity: pushBuilderFactory(JcEntityBuilder, this._config, 'children'),\n    expander: pushBuilderFactory(JcExpanderBuilder, this._config, 'children'),\n    form: pushBuilderFactory(JcFormBuilder, this._config, 'children'),\n    icon: pushBuilderFactory(JcIconBuilder, this._config, 'children'),\n    image: pushBuilderFactory(JcImageOnDefaultBuilder, this._config, 'children'),\n    interactiveImage: pushBuilderFactory(JcInteractiveImageBuilder, this._config, 'children'),\n    lineChart: pushBuilderFactory(JcLineChartBuilder, this._config, 'children'),\n    list: pushBuilderFactory(JcListBuilder, this._config, 'children'),\n    listItem: pushBuilderFactory(JcListItemBuilder, this._config, 'children'),\n    location: pushBuilderFactory(JcLocationBuilder, this._config, 'children'),\n    pieChart: pushBuilderFactory(JcPieChartBuilder, this._config, 'children'),\n    progressBar: pushBuilderFactory(JcProgressBarBuilder, this._config, 'children'),\n    rating: pushBuilderFactory(JcRatingBuilder, this._config, 'children'),\n    slider: pushBuilderFactory(JcSliderBuilder, this._config, 'children'),\n    stage: pushBuilderFactory(JcStageBuilder, this._config, 'children'),\n    stepper: pushBuilderFactory(JcStepperBuilder, this._config, 'children'),\n    text: pushBuilderFactory(JcTextBuilder, this._config, 'children'),\n    trend: pushBuilderFactory(JcTrendBuilder, this._config, 'children'),\n    view: pushBuilderFactory(JcViewBuilder, this._config, 'children'),\n    videoPlayer: pushBuilderFactory(JcVideoPlayerOnJigBuilder, this._config, 'children'),\n    webView: pushBuilderFactory(JcWebViewOnDefaultBuilder, this._config, 'children'),\n  }\n}\n"]}

package/dist/component/jc.web-view.abstract.d.ts

@@ -0,0 +1,15 @@
+import { type BooleanOrExpression, type NumberOrExpression, type StringOrExpression } from '../abstract/index.js';
+import { ComponentBaseBuilder, type JcBaseInput } from './jc.abstract.js';
+export interface JcWebViewBaseInput extends JcBaseInput {
+    readonly uri?: StringOrExpression;
+    readonly content?: StringOrExpression;
+    readonly height?: NumberOrExpression;
+    readonly isTrackingTransparencyRequired?: BooleanOrExpression;
+    readonly zoomLevel?: NumberOrExpression;
+}
+export declare abstract class JcWebViewBuilderBase<TInput extends JcWebViewBaseInput> extends ComponentBaseBuilder<TInput> {
+    readonly onNavigate: import("../action/ja.in-background.factory.js").ActionInBackgroundBuilders;
+    constructor(options: TInput);
+    with(options?: Partial<Omit<TInput, 'instanceId'>>): this;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/component/jc.web-view.abstract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jc.web-view.abstract.d.ts","sourceRoot":"","sources":["../../src/component/jc.web-view.abstract.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EAGxB,MAAM,sBAAsB,CAAA;AAE7B,OAAO,EAAE,oBAAoB,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAGzE,MAAM,WAAW,kBAAmB,SAAQ,WAAW;IACrD,QAAQ,CAAC,GAAG,CAAC,EAAE,kBAAkB,CAAA;IACjC,QAAQ,CAAC,OAAO,CAAC,EAAE,kBAAkB,CAAA;IACrC,QAAQ,CAAC,MAAM,CAAC,EAAE,kBAAkB,CAAA;IACpC,QAAQ,CAAC,8BAA8B,CAAC,EAAE,mBAAmB,CAAA;IAC7D,QAAQ,CAAC,SAAS,CAAC,EAAE,kBAAkB,CAAA;CACxC;AAKD,8BAAsB,oBAAoB,CACxC,MAAM,SAAS,kBAAkB,CACjC,SAAQ,oBAAoB,CAAC,MAAM,CAAC;IAEpC,QAAQ,CAAC,UAAU,6EAEjB;IAEF,YAAY,OAAO,EAAE,MAAM,EAG1B;IAEQ,IAAI,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,GAAG,IAAI,CA0BjE;CACF","sourcesContent":["import {\n  type BooleanOrExpression,\n  type NumberOrExpression,\n  type StringOrExpression,\n  toBooleanOrExpression,\n  toNumberOrExpression,\n} from '../abstract/index.js'\nimport { createActionInBackgroundBuildersFactory } from '../action/ja.in-background.factory.js'\nimport { ComponentBaseBuilder, type JcBaseInput } from './jc.abstract.js'\nimport { COMPONENT_TYPE } from './jc.types.js'\n\nexport interface JcWebViewBaseInput extends JcBaseInput {\n  readonly uri?: StringOrExpression\n  readonly content?: StringOrExpression\n  readonly height?: NumberOrExpression\n  readonly isTrackingTransparencyRequired?: BooleanOrExpression\n  readonly zoomLevel?: NumberOrExpression\n}\n\n/**\n * Build web views.\n */\nexport abstract class JcWebViewBuilderBase<\n  TInput extends JcWebViewBaseInput,\n> extends ComponentBaseBuilder<TInput> {\n  /** Navigation action handler. */\n  readonly onNavigate = createActionInBackgroundBuildersFactory((action) => {\n    this._setToConfig('onNavigate', action)\n  })\n\n  constructor(options: TInput) {\n    super(COMPONENT_TYPE.WEB_VIEW, options)\n    this.with(options)\n  }\n\n  override with(options?: Partial<Omit<TInput, 'instanceId'>>): this {\n    super.with(options)\n\n    if (options?.uri !== undefined) {\n      this._config.uri = options.uri\n    }\n\n    if (options?.content !== undefined) {\n      this._config.content = options.content\n    }\n\n    if (options?.height !== undefined) {\n      this._config.height = toNumberOrExpression(options.height)\n    }\n\n    if (options?.isTrackingTransparencyRequired !== undefined) {\n      this._config.isTrackingTransparencyRequired = toBooleanOrExpression(\n        options.isTrackingTransparencyRequired,\n      )\n    }\n\n    if (options?.zoomLevel !== undefined) {\n      this._config.zoomLevel = toNumberOrExpression(options.zoomLevel)\n    }\n\n    return this\n  }\n}\n"]}

package/dist/component/jc.web-view.abstract.js

@@ -0,0 +1,33 @@
+import { toBooleanOrExpression, toNumberOrExpression, } 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 JcWebViewBuilderBase extends ComponentBaseBuilder {
+    onNavigate = createActionInBackgroundBuildersFactory((action) => {
+        this._setToConfig('onNavigate', action);
+    });
+    constructor(options) {
+        super(COMPONENT_TYPE.WEB_VIEW, options);
+        this.with(options);
+    }
+    with(options) {
+        super.with(options);
+        if (options?.uri !== undefined) {
+            this._config.uri = options.uri;
+        }
+        if (options?.content !== undefined) {
+            this._config.content = options.content;
+        }
+        if (options?.height !== undefined) {
+            this._config.height = toNumberOrExpression(options.height);
+        }
+        if (options?.isTrackingTransparencyRequired !== undefined) {
+            this._config.isTrackingTransparencyRequired = toBooleanOrExpression(options.isTrackingTransparencyRequired);
+        }
+        if (options?.zoomLevel !== undefined) {
+            this._config.zoomLevel = toNumberOrExpression(options.zoomLevel);
+        }
+        return this;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/component/jc.web-view.on-default.d.ts

@@ -0,0 +1,5 @@
+import { type JcWebViewBaseInput, JcWebViewBuilderBase } from './jc.web-view.abstract.js';
+export type JcWebViewOnDefaultInput = JcWebViewBaseInput;
+export declare class JcWebViewOnDefaultBuilder extends JcWebViewBuilderBase<JcWebViewOnDefaultInput> {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiamMud2ViLXZpZXcub24tZGVmYXVsdC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbXBvbmVudC9qYy53ZWItdmlldy5vbi1kZWZhdWx0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLGtCQUFrQixFQUFFLG9CQUFvQixFQUFFLE1BQU0sMkJBQTJCLENBQUE7QUFFekYsTUFBTSxNQUFNLHVCQUF1QixHQUFHLGtCQUFrQixDQUFBO0FBTXhELHFCQUFhLHlCQUEwQixTQUFRLG9CQUFvQixDQUFDLHVCQUF1QixDQUFDO0NBQUciLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyB0eXBlIEpjV2ViVmlld0Jhc2VJbnB1dCwgSmNXZWJWaWV3QnVpbGRlckJhc2UgfSBmcm9tICcuL2pjLndlYi12aWV3LmFic3RyYWN0LmpzJ1xuXG5leHBvcnQgdHlwZSBKY1dlYlZpZXdPbkRlZmF1bHRJbnB1dCA9IEpjV2ViVmlld0Jhc2VJbnB1dFxuXG4vKipcbiAqIEJ1aWxkcyB3ZWIgdmlldyBjb21wb25lbnRzIGZvciBkaXNwbGF5aW5nIHdlYiBjb250ZW50IGlubGluZS5cbiAqIEBhbGlhcyBjb21wb25lbnQud2ViLXZpZXcub24tZGVmYXVsdFxuICovXG5leHBvcnQgY2xhc3MgSmNXZWJWaWV3T25EZWZhdWx0QnVpbGRlciBleHRlbmRzIEpjV2ViVmlld0J1aWxkZXJCYXNlPEpjV2ViVmlld09uRGVmYXVsdElucHV0PiB7fVxuIl19

package/dist/component/jc.web-view.on-default.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jc.web-view.on-default.d.ts","sourceRoot":"","sources":["../../src/component/jc.web-view.on-default.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAEzF,MAAM,MAAM,uBAAuB,GAAG,kBAAkB,CAAA;AAMxD,qBAAa,yBAA0B,SAAQ,oBAAoB,CAAC,uBAAuB,CAAC;CAAG","sourcesContent":["import { type JcWebViewBaseInput, JcWebViewBuilderBase } from './jc.web-view.abstract.js'\n\nexport type JcWebViewOnDefaultInput = JcWebViewBaseInput\n\n/**\n * Builds web view components for displaying web content inline.\n * @alias component.web-view.on-default\n */\nexport class JcWebViewOnDefaultBuilder extends JcWebViewBuilderBase<JcWebViewOnDefaultInput> {}\n"]}

package/dist/component/jc.web-view.on-default.js

@@ -0,0 +1,4 @@
+import { JcWebViewBuilderBase } from './jc.web-view.abstract.js';
+export class JcWebViewOnDefaultBuilder extends JcWebViewBuilderBase {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiamMud2ViLXZpZXcub24tZGVmYXVsdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb21wb25lbnQvamMud2ViLXZpZXcub24tZGVmYXVsdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQTJCLG9CQUFvQixFQUFFLE1BQU0sMkJBQTJCLENBQUE7QUFRekYsTUFBTSxPQUFPLHlCQUEwQixTQUFRLG9CQUE2QztDQUFHIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgdHlwZSBKY1dlYlZpZXdCYXNlSW5wdXQsIEpjV2ViVmlld0J1aWxkZXJCYXNlIH0gZnJvbSAnLi9qYy53ZWItdmlldy5hYnN0cmFjdC5qcydcblxuZXhwb3J0IHR5cGUgSmNXZWJWaWV3T25EZWZhdWx0SW5wdXQgPSBKY1dlYlZpZXdCYXNlSW5wdXRcblxuLyoqXG4gKiBCdWlsZHMgd2ViIHZpZXcgY29tcG9uZW50cyBmb3IgZGlzcGxheWluZyB3ZWIgY29udGVudCBpbmxpbmUuXG4gKiBAYWxpYXMgY29tcG9uZW50LndlYi12aWV3Lm9uLWRlZmF1bHRcbiAqL1xuZXhwb3J0IGNsYXNzIEpjV2ViVmlld09uRGVmYXVsdEJ1aWxkZXIgZXh0ZW5kcyBKY1dlYlZpZXdCdWlsZGVyQmFzZTxKY1dlYlZpZXdPbkRlZmF1bHRJbnB1dD4ge31cbiJdfQ==

package/dist/component/jc.web-view.on-full.d.ts

@@ -0,0 +1,10 @@
+import { type BooleanOrExpression, type StringOrExpression } from '../abstract/index.js';
+import { type JcWebViewBaseInput, JcWebViewBuilderBase } from './jc.web-view.abstract.js';
+export interface JcWebViewOnFullInput extends JcWebViewBaseInput {
+    isEditable?: BooleanOrExpression;
+    initialValue?: StringOrExpression;
+}
+export declare class JcWebViewOnFullBuilder extends JcWebViewBuilderBase<JcWebViewOnFullInput> {
+    constructor(options?: JcWebViewOnFullInput);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiamMud2ViLXZpZXcub24tZnVsbC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbXBvbmVudC9qYy53ZWItdmlldy5vbi1mdWxsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxLQUFLLG1CQUFtQixFQUN4QixLQUFLLGtCQUFrQixFQUV4QixNQUFNLHNCQUFzQixDQUFBO0FBQzdCLE9BQU8sRUFBRSxLQUFLLGtCQUFrQixFQUFFLG9CQUFvQixFQUFFLE1BQU0sMkJBQTJCLENBQUE7QUFFekYsTUFBTSxXQUFXLG9CQUFxQixTQUFRLGtCQUFrQjtJQUM5RCxVQUFVLENBQUMsRUFBRSxtQkFBbUIsQ0FBQTtJQUNoQyxZQUFZLENBQUMsRUFBRSxrQkFBa0IsQ0FBQTtDQUNsQztBQUtELHFCQUFhLHNCQUF1QixTQUFRLG9CQUFvQixDQUFDLG9CQUFvQixDQUFDO0lBQ3BGLFlBQVksT0FBTyxHQUFFLG9CQUF5QixFQVE3QztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgdHlwZSBCb29sZWFuT3JFeHByZXNzaW9uLFxuICB0eXBlIFN0cmluZ09yRXhwcmVzc2lvbixcbiAgdG9Cb29sZWFuT3JFeHByZXNzaW9uLFxufSBmcm9tICcuLi9hYnN0cmFjdC9pbmRleC5qcydcbmltcG9ydCB7IHR5cGUgSmNXZWJWaWV3QmFzZUlucHV0LCBKY1dlYlZpZXdCdWlsZGVyQmFzZSB9IGZyb20gJy4vamMud2ViLXZpZXcuYWJzdHJhY3QuanMnXG5cbmV4cG9ydCBpbnRlcmZhY2UgSmNXZWJWaWV3T25GdWxsSW5wdXQgZXh0ZW5kcyBKY1dlYlZpZXdCYXNlSW5wdXQge1xuICBpc0VkaXRhYmxlPzogQm9vbGVhbk9yRXhwcmVzc2lvblxuICBpbml0aWFsVmFsdWU/OiBTdHJpbmdPckV4cHJlc3Npb25cbn1cblxuLyoqXG4gKiBCdWlsZCBmdWxsIHNjcmVlbiB3ZWIgdmlld3MuXG4gKi9cbmV4cG9ydCBjbGFzcyBKY1dlYlZpZXdPbkZ1bGxCdWlsZGVyIGV4dGVuZHMgSmNXZWJWaWV3QnVpbGRlckJhc2U8SmNXZWJWaWV3T25GdWxsSW5wdXQ+IHtcbiAgY29uc3RydWN0b3Iob3B0aW9uczogSmNXZWJWaWV3T25GdWxsSW5wdXQgPSB7fSkge1xuICAgIHN1cGVyKG9wdGlvbnMpXG4gICAgaWYgKHR5cGVvZiBvcHRpb25zLmlzRWRpdGFibGUgIT09ICd1bmRlZmluZWQnKSB7XG4gICAgICB0aGlzLl9jb25maWcuaXNFZGl0YWJsZSA9IHRvQm9vbGVhbk9yRXhwcmVzc2lvbihvcHRpb25zLmlzRWRpdGFibGUpXG4gICAgfVxuICAgIGlmICh0eXBlb2Ygb3B0aW9ucy5pbml0aWFsVmFsdWUgIT09ICd1bmRlZmluZWQnKSB7XG4gICAgICB0aGlzLl9jb25maWcuaW5pdGlhbFZhbHVlID0gb3B0aW9ucy5pbml0aWFsVmFsdWVcbiAgICB9XG4gIH1cbn1cbiJdfQ==

package/dist/component/jc.web-view.on-full.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jc.web-view.on-full.d.ts","sourceRoot":"","sources":["../../src/component/jc.web-view.on-full.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EAExB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,KAAK,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAEzF,MAAM,WAAW,oBAAqB,SAAQ,kBAAkB;IAC9D,UAAU,CAAC,EAAE,mBAAmB,CAAA;IAChC,YAAY,CAAC,EAAE,kBAAkB,CAAA;CAClC;AAKD,qBAAa,sBAAuB,SAAQ,oBAAoB,CAAC,oBAAoB,CAAC;IACpF,YAAY,OAAO,GAAE,oBAAyB,EAQ7C;CACF","sourcesContent":["import {\n  type BooleanOrExpression,\n  type StringOrExpression,\n  toBooleanOrExpression,\n} from '../abstract/index.js'\nimport { type JcWebViewBaseInput, JcWebViewBuilderBase } from './jc.web-view.abstract.js'\n\nexport interface JcWebViewOnFullInput extends JcWebViewBaseInput {\n  isEditable?: BooleanOrExpression\n  initialValue?: StringOrExpression\n}\n\n/**\n * Build full screen web views.\n */\nexport class JcWebViewOnFullBuilder extends JcWebViewBuilderBase<JcWebViewOnFullInput> {\n  constructor(options: JcWebViewOnFullInput = {}) {\n    super(options)\n    if (typeof options.isEditable !== 'undefined') {\n      this._config.isEditable = toBooleanOrExpression(options.isEditable)\n    }\n    if (typeof options.initialValue !== 'undefined') {\n      this._config.initialValue = options.initialValue\n    }\n  }\n}\n"]}

package/dist/component/jc.web-view.on-full.js

@@ -0,0 +1,14 @@
+import { toBooleanOrExpression, } from '../abstract/index.js';
+import { JcWebViewBuilderBase } from './jc.web-view.abstract.js';
+export class JcWebViewOnFullBuilder extends JcWebViewBuilderBase {
+    constructor(options = {}) {
+        super(options);
+        if (typeof options.isEditable !== 'undefined') {
+            this._config.isEditable = toBooleanOrExpression(options.isEditable);
+        }
+        if (typeof options.initialValue !== 'undefined') {
+            this._config.initialValue = options.initialValue;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiamMud2ViLXZpZXcub24tZnVsbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb21wb25lbnQvamMud2ViLXZpZXcub24tZnVsbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBR0wscUJBQXFCLEdBQ3RCLE1BQU0sc0JBQXNCLENBQUE7QUFDN0IsT0FBTyxFQUEyQixvQkFBb0IsRUFBRSxNQUFNLDJCQUEyQixDQUFBO0FBVXpGLE1BQU0sT0FBTyxzQkFBdUIsU0FBUSxvQkFBMEM7SUFDcEYsWUFBWSxPQUFPLEdBQXlCLEVBQUUsRUFBRTtRQUM5QyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUE7UUFDZCxJQUFJLE9BQU8sT0FBTyxDQUFDLFVBQVUsS0FBSyxXQUFXLEVBQUUsQ0FBQztZQUM5QyxJQUFJLENBQUMsT0FBTyxDQUFDLFVBQVUsR0FBRyxxQkFBcUIsQ0FBQyxPQUFPLENBQUMsVUFBVSxDQUFDLENBQUE7UUFDckUsQ0FBQztRQUNELElBQUksT0FBTyxPQUFPLENBQUMsWUFBWSxLQUFLLFdBQVcsRUFBRSxDQUFDO1lBQ2hELElBQUksQ0FBQyxPQUFPLENBQUMsWUFBWSxHQUFHLE9BQU8sQ0FBQyxZQUFZLENBQUE7UUFDbEQsQ0FBQztJQUFBLENBQ0Y7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIHR5cGUgQm9vbGVhbk9yRXhwcmVzc2lvbixcbiAgdHlwZSBTdHJpbmdPckV4cHJlc3Npb24sXG4gIHRvQm9vbGVhbk9yRXhwcmVzc2lvbixcbn0gZnJvbSAnLi4vYWJzdHJhY3QvaW5kZXguanMnXG5pbXBvcnQgeyB0eXBlIEpjV2ViVmlld0Jhc2VJbnB1dCwgSmNXZWJWaWV3QnVpbGRlckJhc2UgfSBmcm9tICcuL2pjLndlYi12aWV3LmFic3RyYWN0LmpzJ1xuXG5leHBvcnQgaW50ZXJmYWNlIEpjV2ViVmlld09uRnVsbElucHV0IGV4dGVuZHMgSmNXZWJWaWV3QmFzZUlucHV0IHtcbiAgaXNFZGl0YWJsZT86IEJvb2xlYW5PckV4cHJlc3Npb25cbiAgaW5pdGlhbFZhbHVlPzogU3RyaW5nT3JFeHByZXNzaW9uXG59XG5cbi8qKlxuICogQnVpbGQgZnVsbCBzY3JlZW4gd2ViIHZpZXdzLlxuICovXG5leHBvcnQgY2xhc3MgSmNXZWJWaWV3T25GdWxsQnVpbGRlciBleHRlbmRzIEpjV2ViVmlld0J1aWxkZXJCYXNlPEpjV2ViVmlld09uRnVsbElucHV0PiB7XG4gIGNvbnN0cnVjdG9yKG9wdGlvbnM6IEpjV2ViVmlld09uRnVsbElucHV0ID0ge30pIHtcbiAgICBzdXBlcihvcHRpb25zKVxuICAgIGlmICh0eXBlb2Ygb3B0aW9ucy5pc0VkaXRhYmxlICE9PSAndW5kZWZpbmVkJykge1xuICAgICAgdGhpcy5fY29uZmlnLmlzRWRpdGFibGUgPSB0b0Jvb2xlYW5PckV4cHJlc3Npb24ob3B0aW9ucy5pc0VkaXRhYmxlKVxuICAgIH1cbiAgICBpZiAodHlwZW9mIG9wdGlvbnMuaW5pdGlhbFZhbHVlICE9PSAndW5kZWZpbmVkJykge1xuICAgICAgdGhpcy5fY29uZmlnLmluaXRpYWxWYWx1ZSA9IG9wdGlvbnMuaW5pdGlhbFZhbHVlXG4gICAgfVxuICB9XG59XG4iXX0=

package/dist/database/database.abstract.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod/v4';
+import { type DatabaseId, type TableName } from '../abstract/index.js';
+import { BaseBuilder } from '../abstract/base-builder.js';
+export interface FreeFormTable {
+}
+export type DataTable = null;
+declare const DataTablesSchema: z.ZodRecord<z.ZodString, z.ZodNull>;
+export type DataTables = z.infer<typeof DataTablesSchema>;
+export declare const DatabaseSchema: z.ZodObject<{
+    databaseId: z.ZodLiteral<"default">;
+    tables: z.ZodRecord<z.ZodString, z.ZodNull>;
+}, z.core.$strip>;
+export type Database = z.infer<typeof DatabaseSchema>;
+export declare const DatabasesSchema: z.ZodObject<{
+    default: z.ZodObject<{
+        databaseId: z.ZodLiteral<"default">;
+        tables: z.ZodRecord<z.ZodString, z.ZodNull>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type Databases = z.infer<typeof DatabasesSchema>;
+export interface DatabasesContainer {
+    readonly databases: {
+        readonly default: DefaultDatabaseBuilder;
+    };
+}
+declare abstract class DatabaseBuilder extends BaseBuilder {
+    protected readonly _config: Record<string, unknown>;
+    protected constructor();
+    get databaseId(): DatabaseId;
+    table(...names: Array<string | TableName>): this;
+    _validate(): void;
+    abstract build(): Database;
+}
+export declare class DefaultDatabaseBuilder extends DatabaseBuilder {
+    constructor();
+    build(): Database;
+}
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YWJhc2UuYWJzdHJhY3QuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kYXRhYmFzZS9kYXRhYmFzZS5hYnN0cmFjdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsQ0FBQyxFQUFFLE1BQU0sUUFBUSxDQUFBO0FBQzFCLE9BQU8sRUFDTCxLQUFLLFVBQVUsRUFHZixLQUFLLFNBQVMsRUFHZixNQUFNLHNCQUFzQixDQUFBO0FBQzdCLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQTtBQUt6RCxNQUFNLFdBQVcsYUFBYTtDQUFHO0FBS2pDLE1BQU0sTUFBTSxTQUFTLEdBQUcsSUFBSSxDQUFBO0FBRTVCLFFBQUEsTUFBTSxnQkFBZ0IscUNBQXNDLENBQUE7QUFLNUQsTUFBTSxNQUFNLFVBQVUsR0FBRyxDQUFDLENBQUMsS0FBSyxDQUFDLE9BQU8sZ0JBQWdCLENBQUMsQ0FBQTtBQUV6RCxlQUFPLE1BQU0sY0FBYzs7O2lCQUd6QixDQUFBO0FBRUYsTUFBTSxNQUFNLFFBQVEsR0FBRyxDQUFDLENBQUMsS0FBSyxDQUFDLE9BQU8sY0FBYyxDQUFDLENBQUE7QUFFckQsZUFBTyxNQUFNLGVBQWU7Ozs7O2lCQUUxQixDQUFBO0FBRUYsTUFBTSxNQUFNLFNBQVMsR0FBRyxDQUFDLENBQUMsS0FBSyxDQUFDLE9BQU8sZUFBZSxDQUFDLENBQUE7QUFzQnZELE1BQU0sV0FBVyxrQkFBa0I7SUFDakMsUUFBUSxDQUFDLFNBQVMsRUFBRTtRQUFFLFFBQVEsQ0FBQyxPQUFPLEVBQUUsc0JBQXNCLENBQUE7S0FBRSxDQUFBO0NBQ2pFO0FBRUQsdUJBQWUsZUFBZ0IsU0FBUSxXQUFXO0lBQ2hELFNBQVMsQ0FBQyxRQUFRLENBQUMsT0FBTyxFQUFFLE1BQU0sQ0FBQyxNQUFNLEVBQUUsT0FBTyxDQUFDLENBQUs7SUFFeEQsU0FBUyxlQUdSO0lBT0QsSUFBSSxVQUFVLElBQUksVUFBVSxDQUUzQjtJQVFELEtBQUssQ0FBQyxHQUFHLEtBQUssRUFBRSxLQUFLLENBQUMsTUFBTSxHQUFHLFNBQVMsQ0FBQyxHQUFHLElBQUksQ0FPL0M7SUFFRCxTQUFTLElBQUksSUFBSSxDQUFHO0lBTXBCLFFBQVEsQ0FBQyxLQUFLLElBQUksUUFBUSxDQUFBO0NBQzNCO0FBZ0JELHFCQUFhLHNCQUF1QixTQUFRLGVBQWU7SUFDekQsY0FFQztJQUVRLEtBQUssSUFBSSxRQUFRLENBS3pCO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyB6IH0gZnJvbSAnem9kL3Y0J1xuaW1wb3J0IHtcbiAgdHlwZSBEYXRhYmFzZUlkLFxuICBEYXRhYmFzZUlkU2NoZW1hLFxuICBEZWZhdWx0RGF0YWJhc2VJZCxcbiAgdHlwZSBUYWJsZU5hbWUsXG4gIFRhYmxlTmFtZVNjaGVtYSxcbiAgdG9EYXRhYmFzZVRhYmxlTmFtZSxcbn0gZnJvbSAnLi4vYWJzdHJhY3QvaW5kZXguanMnXG5pbXBvcnQgeyBCYXNlQnVpbGRlciB9IGZyb20gJy4uL2Fic3RyYWN0L2Jhc2UtYnVpbGRlci5qcydcblxuLyoqXG4gKiBGcmVlLWZvcm0gdGFibGUgZGVmaW5pdGlvbiAoY3VycmVudGx5IGVtcHR5KS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBGcmVlRm9ybVRhYmxlIHt9XG5cbi8qKlxuICogRGF0YSB0YWJsZSB0eXBlIC0gZWl0aGVyIG51bGwgb3IgRnJlZUZvcm1UYWJsZS5cbiAqL1xuZXhwb3J0IHR5cGUgRGF0YVRhYmxlID0gbnVsbFxuXG5jb25zdCBEYXRhVGFibGVzU2NoZW1hID0gei5yZWNvcmQoVGFibGVOYW1lU2NoZW1hLCB6Lm51bGwoKSlcblxuLyoqXG4gKiBEYXRhIHRhYmxlcyBkZWZpbml0aW9uIC0gcmVjb3JkIG9mIHRhYmxlIG5hbWVzIHRvIHRhYmxlIGRlZmluaXRpb25zLlxuICovXG5leHBvcnQgdHlwZSBEYXRhVGFibGVzID0gei5pbmZlcjx0eXBlb2YgRGF0YVRhYmxlc1NjaGVtYT5cblxuZXhwb3J0IGNvbnN0IERhdGFiYXNlU2NoZW1hID0gei5vYmplY3Qoe1xuICBkYXRhYmFzZUlkOiBEYXRhYmFzZUlkU2NoZW1hLFxuICB0YWJsZXM6IERhdGFUYWJsZXNTY2hlbWEsXG59KVxuXG5leHBvcnQgdHlwZSBEYXRhYmFzZSA9IHouaW5mZXI8dHlwZW9mIERhdGFiYXNlU2NoZW1hPlxuXG5leHBvcnQgY29uc3QgRGF0YWJhc2VzU2NoZW1hID0gei5vYmplY3Qoe1xuICBkZWZhdWx0OiBEYXRhYmFzZVNjaGVtYSxcbn0pXG5cbmV4cG9ydCB0eXBlIERhdGFiYXNlcyA9IHouaW5mZXI8dHlwZW9mIERhdGFiYXNlc1NjaGVtYT5cblxuLyoqXG4gKiBEYXRhYmFzZSBkZWZpbml0aW9uIHdpdGggaWQgYW5kIHRhYmxlcy5cbiAqL1xuLy8gZXhwb3J0IGludGVyZmFjZSBEYXRhYmFzZSB7XG4vLyAgIGRhdGFiYXNlSWQ6IERhdGFiYXNlSWRcbi8vICAgdGFibGVzOiBEYXRhVGFibGVzXG4vLyB9XG5cbi8qKlxuICogRGF0YWJhc2VzIGNvbnRhaW5lciAtIG9ubHkgc3VwcG9ydHMgJ2RlZmF1bHQnIGRhdGFiYXNlLlxuICovXG4vLyBleHBvcnQgaW50ZXJmYWNlIERhdGFiYXNlcyB7XG4vLyAgIGRlZmF1bHQ6IERhdGFiYXNlXG4vLyB9XG5cbi8vIGV4cG9ydCBjb25zdCBEZWZhdWx0RGF0YWJhc2VJZDogRGF0YWJhc2VJZCA9IHRvRGF0YWJhc2VJZCgnZGVmYXVsdCcpXG5cbi8qKlxuICogQ29udGFpbmVyIGZvciBkYXRhYmFzZSBjb2xsZWN0aW9ucyBpbiBzb2x1dGlvbnMuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRGF0YWJhc2VzQ29udGFpbmVyIHtcbiAgcmVhZG9ubHkgZGF0YWJhc2VzOiB7IHJlYWRvbmx5IGRlZmF1bHQ6IERlZmF1bHREYXRhYmFzZUJ1aWxkZXIgfVxufVxuXG5hYnN0cmFjdCBjbGFzcyBEYXRhYmFzZUJ1aWxkZXIgZXh0ZW5kcyBCYXNlQnVpbGRlciB7XG4gIHByb3RlY3RlZCByZWFkb25seSBfY29uZmlnOiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPiA9IHt9XG5cbiAgcHJvdGVjdGVkIGNvbnN0cnVjdG9yKCkge1xuICAgIHN1cGVyKClcbiAgICB0aGlzLl9jb25maWcudGFibGVzID0ge31cbiAgfVxuXG4gIC8qKlxuICAgKiBHZXQgZGF0YWJhc2UgSUQuIEFsd2F5cyAnZGVmYXVsdCcuXG4gICAqXG4gICAqIEByZXR1cm5zICdkZWZhdWx0J1xuICAgKi9cbiAgZ2V0IGRhdGFiYXNlSWQoKTogRGF0YWJhc2VJZCB7XG4gICAgcmV0dXJuIERlZmF1bHREYXRhYmFzZUlkXG4gIH1cblxuICAvKipcbiAgICogQWRkIHRhYmxlcyB0byBkYXRhYmFzZS4gRHVwbGljYXRlcyBhdXRvLXJlbW92ZWQuXG4gICAqXG4gICAqIEBwYXJhbSBuYW1lcyAtIFRhYmxlIG5hbWVzIChzbmFrZV9jYXNlIG9yIGtlYmFiLWNhc2UpXG4gICAqIEByZXR1cm5zIEJ1aWxkZXIgZm9yIGNoYWluaW5nXG4gICAqL1xuICB0YWJsZSguLi5uYW1lczogQXJyYXk8c3RyaW5nIHwgVGFibGVOYW1lPik6IHRoaXMge1xuICAgIGNvbnN0IHRhYmxlcyA9IHRoaXMuX2NvbmZpZy50YWJsZXMgYXMgUmVjb3JkPFRhYmxlTmFtZSwgbnVsbD5cbiAgICBjb25zdCB1bmlxdWUgPSBbLi4ubmV3IFNldChuYW1lcykua2V5cygpXVxuICAgIGZvciAoY29uc3QgbiBvZiB1bmlxdWUpIHtcbiAgICAgIHRhYmxlc1t0b0RhdGFiYXNlVGFibGVOYW1lKG4pXSA9IG51bGxcbiAgICB9XG4gICAgcmV0dXJuIHRoaXNcbiAgfVxuXG4gIF92YWxpZGF0ZSgpOiB2b2lkIHt9XG5cbiAgLyoqXG4gICAqIEJ1aWxkIGRhdGFiYXNlIGRlZmluaXRpb24uXG4gICAqIEByZXR1cm5zIENvbXBsZXRlIERhdGFiYXNlIG9iamVjdFxuICAgKi9cbiAgYWJzdHJhY3QgYnVpbGQoKTogRGF0YWJhc2Vcbn1cblxuLyoqXG4gKiBCdWlsZCBEeW5hbWljIERhdGEgZGF0YWJhc2UgY29uZmlndXJhdGlvbnMuXG4gKlxuICogRGVmaW5lIE5vU1FMIHRhYmxlcyBmb3IgY2xvdWQtc3luY2VkIEpTT04gZG9jdW1lbnRzLlxuICogU2luZ2xlICdkZWZhdWx0JyBkYXRhYmFzZSBwZXIgYXBwbGljYXRpb24uIDM1MEtCIG1heCBwZXIgcmVjb3JkLlxuICogV29ya3Mgb2ZmbGluZSwgc3luY3Mgd2hlbiByZWNvbm5lY3RlZC5cbiAqXG4gKiBUYWJsZSBuYW1pbmc6IGxvd2VyY2FzZSwgMi01MCBjaGFycywgYWxwaGFudW1lcmljICsgZGFzaC91bmRlcnNjb3JlLlxuICpcbiAqXG4gKlxuICogQGFsaWFzIGRlZmF1bHRcbiAqIEBzZWUgU3FsaXRlRGF0YXNvdXJjZUJ1aWxkZXJcbiAqL1xuZXhwb3J0IGNsYXNzIERlZmF1bHREYXRhYmFzZUJ1aWxkZXIgZXh0ZW5kcyBEYXRhYmFzZUJ1aWxkZXIge1xuICBjb25zdHJ1Y3RvcigpIHtcbiAgICBzdXBlcigpXG4gIH1cblxuICBvdmVycmlkZSBidWlsZCgpOiBEYXRhYmFzZSB7XG4gICAgcmV0dXJuIHtcbiAgICAgIGRhdGFiYXNlSWQ6IERlZmF1bHREYXRhYmFzZUlkLFxuICAgICAgdGFibGVzOiB0aGlzLl9jb25maWcudGFibGVzIGFzIERhdGFUYWJsZXMsXG4gICAgfVxuICB9XG59XG4iXX0=

package/dist/database/database.abstract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.abstract.d.ts","sourceRoot":"","sources":["../../src/database/database.abstract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAC1B,OAAO,EACL,KAAK,UAAU,EAGf,KAAK,SAAS,EAGf,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAKzD,MAAM,WAAW,aAAa;CAAG;AAKjC,MAAM,MAAM,SAAS,GAAG,IAAI,CAAA;AAE5B,QAAA,MAAM,gBAAgB,qCAAsC,CAAA;AAK5D,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEzD,eAAO,MAAM,cAAc;;;iBAGzB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAErD,eAAO,MAAM,eAAe;;;;;iBAE1B,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAsBvD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,SAAS,EAAE;QAAE,QAAQ,CAAC,OAAO,EAAE,sBAAsB,CAAA;KAAE,CAAA;CACjE;AAED,uBAAe,eAAgB,SAAQ,WAAW;IAChD,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAK;IAExD,SAAS,eAGR;IAOD,IAAI,UAAU,IAAI,UAAU,CAE3B;IAQD,KAAK,CAAC,GAAG,KAAK,EAAE,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,GAAG,IAAI,CAO/C;IAED,SAAS,IAAI,IAAI,CAAG;IAMpB,QAAQ,CAAC,KAAK,IAAI,QAAQ,CAAA;CAC3B;AAgBD,qBAAa,sBAAuB,SAAQ,eAAe;IACzD,cAEC;IAEQ,KAAK,IAAI,QAAQ,CAKzB;CACF","sourcesContent":["import { z } from 'zod/v4'\nimport {\n  type DatabaseId,\n  DatabaseIdSchema,\n  DefaultDatabaseId,\n  type TableName,\n  TableNameSchema,\n  toDatabaseTableName,\n} from '../abstract/index.js'\nimport { BaseBuilder } from '../abstract/base-builder.js'\n\n/**\n * Free-form table definition (currently empty).\n */\nexport interface FreeFormTable {}\n\n/**\n * Data table type - either null or FreeFormTable.\n */\nexport type DataTable = null\n\nconst DataTablesSchema = z.record(TableNameSchema, z.null())\n\n/**\n * Data tables definition - record of table names to table definitions.\n */\nexport type DataTables = z.infer<typeof DataTablesSchema>\n\nexport const DatabaseSchema = z.object({\n  databaseId: DatabaseIdSchema,\n  tables: DataTablesSchema,\n})\n\nexport type Database = z.infer<typeof DatabaseSchema>\n\nexport const DatabasesSchema = z.object({\n  default: DatabaseSchema,\n})\n\nexport type Databases = z.infer<typeof DatabasesSchema>\n\n/**\n * Database definition with id and tables.\n */\n// export interface Database {\n//   databaseId: DatabaseId\n//   tables: DataTables\n// }\n\n/**\n * Databases container - only supports 'default' database.\n */\n// export interface Databases {\n//   default: Database\n// }\n\n// export const DefaultDatabaseId: DatabaseId = toDatabaseId('default')\n\n/**\n * Container for database collections in solutions.\n */\nexport interface DatabasesContainer {\n  readonly databases: { readonly default: DefaultDatabaseBuilder }\n}\n\nabstract class DatabaseBuilder extends BaseBuilder {\n  protected readonly _config: Record<string, unknown> = {}\n\n  protected constructor() {\n    super()\n    this._config.tables = {}\n  }\n\n  /**\n   * Get database ID. Always 'default'.\n   *\n   * @returns 'default'\n   */\n  get databaseId(): DatabaseId {\n    return DefaultDatabaseId\n  }\n\n  /**\n   * Add tables to database. Duplicates auto-removed.\n   *\n   * @param names - Table names (snake_case or kebab-case)\n   * @returns Builder for chaining\n   */\n  table(...names: Array<string | TableName>): this {\n    const tables = this._config.tables as Record<TableName, null>\n    const unique = [...new Set(names).keys()]\n    for (const n of unique) {\n      tables[toDatabaseTableName(n)] = null\n    }\n    return this\n  }\n\n  _validate(): void {}\n\n  /**\n   * Build database definition.\n   * @returns Complete Database object\n   */\n  abstract build(): Database\n}\n\n/**\n * Build Dynamic Data database configurations.\n *\n * Define NoSQL tables for cloud-synced JSON documents.\n * Single 'default' database per application. 350KB max per record.\n * Works offline, syncs when reconnected.\n *\n * Table naming: lowercase, 2-50 chars, alphanumeric + dash/underscore.\n *\n *\n *\n * @alias default\n * @see SqliteDatasourceBuilder\n */\nexport class DefaultDatabaseBuilder extends DatabaseBuilder {\n  constructor() {\n    super()\n  }\n\n  override build(): Database {\n    return {\n      databaseId: DefaultDatabaseId,\n      tables: this._config.tables as DataTables,\n    }\n  }\n}\n"]}

package/dist/database/database.abstract.js

@@ -0,0 +1,42 @@
+import { z } from 'zod/v4';
+import { DatabaseIdSchema, DefaultDatabaseId, TableNameSchema, toDatabaseTableName, } from '../abstract/index.js';
+import { BaseBuilder } from '../abstract/base-builder.js';
+const DataTablesSchema = z.record(TableNameSchema, z.null());
+export const DatabaseSchema = z.object({
+    databaseId: DatabaseIdSchema,
+    tables: DataTablesSchema,
+});
+export const DatabasesSchema = z.object({
+    default: DatabaseSchema,
+});
+class DatabaseBuilder extends BaseBuilder {
+    _config = {};
+    constructor() {
+        super();
+        this._config.tables = {};
+    }
+    get databaseId() {
+        return DefaultDatabaseId;
+    }
+    table(...names) {
+        const tables = this._config.tables;
+        const unique = [...new Set(names).keys()];
+        for (const n of unique) {
+            tables[toDatabaseTableName(n)] = null;
+        }
+        return this;
+    }
+    _validate() { }
+}
+export class DefaultDatabaseBuilder extends DatabaseBuilder {
+    constructor() {
+        super();
+    }
+    build() {
+        return {
+            databaseId: DefaultDatabaseId,
+            tables: this._config.tables,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/database/index.d.ts

@@ -0,0 +1,2 @@
+export * from './database.abstract.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kYXRhYmFzZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHdCQUF3QixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kYXRhYmFzZS5hYnN0cmFjdC5qcydcbiJdfQ==

package/dist/database/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/database/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAA","sourcesContent":["export * from './database.abstract.js'\n"]}

package/dist/database/index.js

@@ -0,0 +1,2 @@
+export * from './database.abstract.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZGF0YWJhc2UvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3QkFBd0IsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZGF0YWJhc2UuYWJzdHJhY3QuanMnXG4iXX0=

package/dist/datasource/datasource.abstract.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod/v4';
+import { type DatasourceId, type DatasourceType } from '../abstract/index.js';
+import { BaseBuilder } from '../abstract/base-builder.js';
+export declare const DatasourceBaseSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        "datasource.reference": "datasource.reference";
+        "datasource.sqlite": "datasource.sqlite";
+        "datasource.static": "datasource.static";
+        "datasource.system": "datasource.system";
+    }>;
+    datasourceId: z.ZodString;
+    instanceId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DatasourceBase = z.infer<typeof DatasourceBaseSchema>;
+export declare function isDatasourceBase(value: unknown): value is DatasourceBase;
+export interface DatasourceBuilderLike {
+    build(): unknown;
+}
+export interface DatasourcesContainer {
+    readonly datasources: Record<DatasourceId, DatasourceBuilderLike>;
+}
+export interface DatasourceBaseOptions {
+    readonly datasourceId: string | DatasourceId;
+    readonly instanceId?: string;
+}
+export declare abstract class DatasourceBaseBuilder<TOutput = unknown> extends BaseBuilder {
+    private readonly _type;
+    private readonly _datasourceId;
+    private readonly _instanceId;
+    protected readonly _config: Record<string, unknown>;
+    protected constructor(type: DatasourceType, options: DatasourceBaseOptions);
+    get type(): DatasourceType;
+    get datasourceId(): DatasourceId;
+    get instanceId(): string;
+    protected _setToConfig(path: string, value: unknown): void;
+    _validate(): void;
+    build(): TOutput;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/datasource/datasource.abstract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datasource.abstract.d.ts","sourceRoot":"","sources":["../../src/datasource/datasource.abstract.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAC1B,OAAO,EACL,KAAK,YAAY,EAEjB,KAAK,cAAc,EAMpB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAEzD,eAAO,MAAM,oBAAoB;;;;;;;;;iBAI/B,CAAA;AAKF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAKjE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc,CAExE;AAKD,MAAM,WAAW,qBAAqB;IACpC,KAAK,IAAI,OAAO,CAAA;CACjB;AAKD,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,YAAY,EAAE,qBAAqB,CAAC,CAAA;CAClE;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,YAAY,CAAA;IAC5C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAC7B;AAcD,8BAAsB,qBAAqB,CAAC,OAAO,GAAG,OAAO,CAAE,SAAQ,WAAW;IAChF,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAc;IAC5C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAQ;IACpC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAK;IAExD,SAAS,aAAa,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,qBAAqB,EAKzE;IAED,IAAI,IAAI,IAAI,cAAc,CAEzB;IAKD,IAAI,YAAY,IAAI,YAAY,CAE/B;IAED,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,SAAS,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAEzD;IAED,SAAS,IAAI,IAAI,CAAG;IAEpB,KAAK,IAAI,OAAO,CAQf;CACF","sourcesContent":["import set from 'lodash/set.js'\nimport { z } from 'zod/v4'\nimport {\n  type DatasourceId,\n  DatasourceIdSchema,\n  type DatasourceType,\n  DatasourceTypeEnum,\n  InstanceIdSchema,\n  buildTree,\n  toDatasourceId,\n  toInstanceId,\n} from '../abstract/index.js'\nimport { BaseBuilder } from '../abstract/base-builder.js'\n\nexport const DatasourceBaseSchema = z.object({\n  type: DatasourceTypeEnum,\n  datasourceId: DatasourceIdSchema,\n  instanceId: InstanceIdSchema.optional(),\n})\n\n/**\n * Base type for all datasources.\n */\nexport type DatasourceBase = z.infer<typeof DatasourceBaseSchema>\n\n/**\n * Type guard for DatasourceBase.\n */\nexport function isDatasourceBase(value: unknown): value is DatasourceBase {\n  return DatasourceBaseSchema.safeParse(value).success\n}\n\n/**\n * Any builder that produces a datasource definition.\n */\nexport interface DatasourceBuilderLike {\n  build(): unknown\n}\n\n/**\n * Container for datasource collections in solutions or screens/jigs.\n */\nexport interface DatasourcesContainer {\n  readonly datasources: Record<DatasourceId, DatasourceBuilderLike>\n}\n\nexport interface DatasourceBaseOptions {\n  readonly datasourceId: string | DatasourceId\n  readonly instanceId?: string\n}\n\n/**\n * Build Jigx datasources. Base class.\n *\n * Types:\n * - `datasource.sqlite`: SQLite + optional cloud sync\n * - `datasource.static`: Embedded JSON data\n * - `datasource.system`: System data (country flags)\n *\n * @see SqliteDatasourceBuilder - Database queries with sync\n * @see StaticDatasourceBuilder - In-memory data\n * @see SystemDatasourceBuilder - Platform-provided data\n */\nexport abstract class DatasourceBaseBuilder<TOutput = unknown> extends BaseBuilder {\n  private readonly _type: DatasourceType\n  private readonly _datasourceId: DatasourceId\n  private readonly _instanceId: string\n  protected readonly _config: Record<string, unknown> = {}\n\n  protected constructor(type: DatasourceType, options: DatasourceBaseOptions) {\n    super()\n    this._type = type\n    this._datasourceId = toDatasourceId(options.datasourceId)\n    this._instanceId = toInstanceId(options.instanceId || options.datasourceId)\n  }\n\n  get type(): DatasourceType {\n    return this._type\n  }\n\n  /**\n   * Get datasource ID for component references.\n   */\n  get datasourceId(): DatasourceId {\n    return this._datasourceId\n  }\n\n  get instanceId(): string {\n    return this._instanceId\n  }\n\n  protected _setToConfig(path: string, value: unknown): void {\n    set(this._config, path, value)\n  }\n\n  _validate(): void {}\n\n  build(): TOutput {\n    const options = buildTree(this._config)\n    return {\n      type: this._type,\n      datasourceId: this._datasourceId,\n      instanceId: this._instanceId,\n      ...(Object.keys(options).length > 0 && { options }),\n    } as TOutput\n  }\n}\n"]}

package/dist/datasource/datasource.abstract.js

@@ -0,0 +1,47 @@
+import set from 'lodash/set.js';
+import { z } from 'zod/v4';
+import { DatasourceIdSchema, DatasourceTypeEnum, InstanceIdSchema, buildTree, toDatasourceId, toInstanceId, } from '../abstract/index.js';
+import { BaseBuilder } from '../abstract/base-builder.js';
+export const DatasourceBaseSchema = z.object({
+    type: DatasourceTypeEnum,
+    datasourceId: DatasourceIdSchema,
+    instanceId: InstanceIdSchema.optional(),
+});
+export function isDatasourceBase(value) {
+    return DatasourceBaseSchema.safeParse(value).success;
+}
+export class DatasourceBaseBuilder extends BaseBuilder {
+    _type;
+    _datasourceId;
+    _instanceId;
+    _config = {};
+    constructor(type, options) {
+        super();
+        this._type = type;
+        this._datasourceId = toDatasourceId(options.datasourceId);
+        this._instanceId = toInstanceId(options.instanceId || options.datasourceId);
+    }
+    get type() {
+        return this._type;
+    }
+    get datasourceId() {
+        return this._datasourceId;
+    }
+    get instanceId() {
+        return this._instanceId;
+    }
+    _setToConfig(path, value) {
+        set(this._config, path, value);
+    }
+    _validate() { }
+    build() {
+        const options = buildTree(this._config);
+        return {
+            type: this._type,
+            datasourceId: this._datasourceId,
+            instanceId: this._instanceId,
+            ...(Object.keys(options).length > 0 && { options }),
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/datasource/datasource.descriptor.d.ts

@@ -0,0 +1,11 @@
+import { type InputDefinitions } from '../screen/index.js';
+import { type ActionId } from '../abstract/index.js';
+export interface DatasourceDescriptor {
+    readonly packageName?: string;
+    readonly datasourceId: string;
+    readonly description?: string;
+    readonly inputDefinitions?: InputDefinitions;
+    readonly actionsToSync?: ActionId[];
+    readonly schema?: unknown;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YXNvdXJjZS5kZXNjcmlwdG9yLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZGF0YXNvdXJjZS9kYXRhc291cmNlLmRlc2NyaXB0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssZ0JBQWdCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQTtBQUMxRCxPQUFPLEVBQUUsS0FBSyxRQUFRLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQTtBQUVwRCxNQUFNLFdBQVcsb0JBQW9CO0lBQ25DLFFBQVEsQ0FBQyxXQUFXLENBQUMsRUFBRSxNQUFNLENBQUE7SUFDN0IsUUFBUSxDQUFDLFlBQVksRUFBRSxNQUFNLENBQUE7SUFDN0IsUUFBUSxDQUFDLFdBQVcsQ0FBQyxFQUFFLE1BQU0sQ0FBQTtJQUM3QixRQUFRLENBQUMsZ0JBQWdCLENBQUMsRUFBRSxnQkFBZ0IsQ0FBQTtJQUM1QyxRQUFRLENBQUMsYUFBYSxDQUFDLEVBQUUsUUFBUSxFQUFFLENBQUE7SUFDbkMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxFQUFFLE9BQU8sQ0FBQTtDQUMxQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHR5cGUgSW5wdXREZWZpbml0aW9ucyB9IGZyb20gJy4uL3NjcmVlbi9pbmRleC5qcydcbmltcG9ydCB7IHR5cGUgQWN0aW9uSWQgfSBmcm9tICcuLi9hYnN0cmFjdC9pbmRleC5qcydcblxuZXhwb3J0IGludGVyZmFjZSBEYXRhc291cmNlRGVzY3JpcHRvciB7XG4gIHJlYWRvbmx5IHBhY2thZ2VOYW1lPzogc3RyaW5nXG4gIHJlYWRvbmx5IGRhdGFzb3VyY2VJZDogc3RyaW5nXG4gIHJlYWRvbmx5IGRlc2NyaXB0aW9uPzogc3RyaW5nXG4gIHJlYWRvbmx5IGlucHV0RGVmaW5pdGlvbnM/OiBJbnB1dERlZmluaXRpb25zXG4gIHJlYWRvbmx5IGFjdGlvbnNUb1N5bmM/OiBBY3Rpb25JZFtdXG4gIHJlYWRvbmx5IHNjaGVtYT86IHVua25vd25cbn1cbiJdfQ==

package/dist/datasource/datasource.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datasource.descriptor.d.ts","sourceRoot":"","sources":["../../src/datasource/datasource.descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAC1D,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAEpD,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,gBAAgB,CAAC,EAAE,gBAAgB,CAAA;IAC5C,QAAQ,CAAC,aAAa,CAAC,EAAE,QAAQ,EAAE,CAAA;IACnC,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAC1B","sourcesContent":["import { type InputDefinitions } from '../screen/index.js'\nimport { type ActionId } from '../abstract/index.js'\n\nexport interface DatasourceDescriptor {\n  readonly packageName?: string\n  readonly datasourceId: string\n  readonly description?: string\n  readonly inputDefinitions?: InputDefinitions\n  readonly actionsToSync?: ActionId[]\n  readonly schema?: unknown\n}\n"]}

package/dist/datasource/datasource.descriptor.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YXNvdXJjZS5kZXNjcmlwdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2RhdGFzb3VyY2UvZGF0YXNvdXJjZS5kZXNjcmlwdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyB0eXBlIElucHV0RGVmaW5pdGlvbnMgfSBmcm9tICcuLi9zY3JlZW4vaW5kZXguanMnXG5pbXBvcnQgeyB0eXBlIEFjdGlvbklkIH0gZnJvbSAnLi4vYWJzdHJhY3QvaW5kZXguanMnXG5cbmV4cG9ydCBpbnRlcmZhY2UgRGF0YXNvdXJjZURlc2NyaXB0b3Ige1xuICByZWFkb25seSBwYWNrYWdlTmFtZT86IHN0cmluZ1xuICByZWFkb25seSBkYXRhc291cmNlSWQ6IHN0cmluZ1xuICByZWFkb25seSBkZXNjcmlwdGlvbj86IHN0cmluZ1xuICByZWFkb25seSBpbnB1dERlZmluaXRpb25zPzogSW5wdXREZWZpbml0aW9uc1xuICByZWFkb25seSBhY3Rpb25zVG9TeW5jPzogQWN0aW9uSWRbXVxuICByZWFkb25seSBzY2hlbWE/OiB1bmtub3duXG59XG4iXX0=

package/dist/datasource/datasource.reference.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod/v4';
+import { type InstanceId, type PrimitiveOrExpression } from '../abstract/index.js';
+import { type DatasourceDescriptor } from './datasource.descriptor.js';
+declare const ReferenceDatasourceSchema: z.ZodObject<{
+    type: z.ZodLiteral<"datasource.reference">;
+    datasourceId: z.ZodString;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodUnion<[z.ZodString, z.ZodString]>, z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodUnion<[z.ZodBoolean, z.ZodString]>, z.ZodUnion<[z.ZodNull, z.ZodString]>]>>>;
+    package: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ReferenceDatasource = z.infer<typeof ReferenceDatasourceSchema>;
+export interface DatasourceReferenceOptions {
+    readonly descriptor: DatasourceDescriptor;
+    readonly instanceId: string | InstanceId;
+}
+export declare class DatasourceReferenceBuilder {
+    private readonly _descriptor;
+    private readonly _instanceId;
+    private readonly _inputs;
+    constructor(options: DatasourceReferenceOptions);
+    get instanceId(): InstanceId;
+    get descriptor(): DatasourceDescriptor;
+    get schema(): unknown | undefined;
+    param(key: string, value: PrimitiveOrExpression): this;
+    build(): ReferenceDatasource;
+    _validate(): {
+        valid: boolean;
+        issues: Array<{
+            message: string;
+        }>;
+    };
+}
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/datasource/datasource.reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datasource.reference.d.ts","sourceRoot":"","sources":["../../src/datasource/datasource.reference.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAC1B,OAAO,EAGL,KAAK,UAAU,EACf,KAAK,qBAAqB,EAG3B,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,4BAA4B,CAAA;AAEtE,QAAA,MAAM,yBAAyB;;;;;iBAK7B,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE3E,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,UAAU,EAAE,oBAAoB,CAAA;IACzC,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,CAAA;CACzC;AAOD,qBAAa,0BAA0B;IACrC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAsB;IAClD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAY;IACxC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA4C;IAEpE,YAAY,OAAO,EAAE,0BAA0B,EAG9C;IAED,IAAI,UAAU,IAAI,UAAU,CAE3B;IAED,IAAI,UAAU,IAAI,oBAAoB,CAErC;IAED,IAAI,MAAM,IAAI,OAAO,GAAG,SAAS,CAEhC;IAQD,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,qBAAqB,GAAG,IAAI,CAGrD;IAED,KAAK,IAAI,mBAAmB,CAc3B;IAGD,SAAS,IAAI;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,KAAK,CAAC;YAAE,OAAO,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KAAE,CA2BlE;CACF","sourcesContent":["import { z } from 'zod/v4'\nimport {\n  DATASOURCE_TYPE,\n  DatasourceIdSchema,\n  type InstanceId,\n  type PrimitiveOrExpression,\n  PrimitiveOrExpressionSchema,\n  toInstanceId,\n} from '../abstract/index.js'\nimport { type DatasourceDescriptor } from './datasource.descriptor.js'\n\nconst ReferenceDatasourceSchema = z.object({\n  type: z.literal(DATASOURCE_TYPE.REFERENCE),\n  datasourceId: DatasourceIdSchema,\n  inputs: z.record(z.string(), PrimitiveOrExpressionSchema).optional(),\n  package: z.string().optional(),\n})\n\nexport type ReferenceDatasource = z.infer<typeof ReferenceDatasourceSchema>\n\nexport interface DatasourceReferenceOptions {\n  readonly descriptor: DatasourceDescriptor\n  readonly instanceId: string | InstanceId\n}\n\n/**\n * Reference existing datasource by ID. Pass inputs at runtime.\n *\n * @see ScreenBaseBuilderNew.addDatasource.reference\n */\nexport class DatasourceReferenceBuilder {\n  private readonly _descriptor: DatasourceDescriptor\n  private readonly _instanceId: InstanceId\n  private readonly _inputs: Record<string, PrimitiveOrExpression> = {}\n\n  constructor(options: DatasourceReferenceOptions) {\n    this._descriptor = options.descriptor\n    this._instanceId = toInstanceId(options.instanceId)\n  }\n\n  get instanceId(): InstanceId {\n    return this._instanceId\n  }\n\n  get descriptor(): DatasourceDescriptor {\n    return this._descriptor\n  }\n\n  get schema(): unknown | undefined {\n    return this._descriptor.schema\n  }\n\n  /**\n   * Add input parameter.\n   *\n   * @param key - Parameter name\n   * @param value - Primitive or expression\n   */\n  param(key: string, value: PrimitiveOrExpression): this {\n    this._inputs[key] = value\n    return this\n  }\n\n  build(): ReferenceDatasource {\n    const result: ReferenceDatasource = {\n      type: DATASOURCE_TYPE.REFERENCE,\n      datasourceId: this._descriptor.datasourceId,\n    }\n\n    if (this._descriptor.packageName) {\n      result.package = this._descriptor.packageName\n    }\n\n    if (Object.keys(this._inputs).length > 0) {\n      result.inputs = { ...this._inputs }\n    }\n    return result\n  }\n\n  // TODO: Fix types - we have to move ValidationResult to core-sdk\n  _validate(): { valid: boolean; issues: Array<{ message: string }> } {\n    if (!this._descriptor.inputDefinitions) {\n      return { valid: true, issues: [] }\n    }\n\n    const names = Object.keys(this._descriptor.inputDefinitions)\n\n    if (names.length === 0) {\n      return { valid: true, issues: [] }\n    }\n\n    let isValid = true\n    const issues = []\n\n    for (const name of names) {\n      const definition = this._descriptor.inputDefinitions[name]\n      const value = this._inputs[name]\n\n      if (definition.required && (typeof value === 'undefined' || value === null)) {\n        isValid = false\n        issues.push({\n          message: `Input parameter \"${name}\" is required but not provided.`,\n        })\n      }\n    }\n\n    return { valid: isValid, issues }\n  }\n}\n"]}