@jigx/core-sdk 1.0.0

package/dist/action/ja.in-background.js

@@ -0,0 +1,247 @@
+import { JaActionListBuilder } from './ja.action-list.js';
+import { JaClearQueueBuilder } from './ja.clear-queue.js';
+import { JaConfirmBuilder } from './ja.confirm.js';
+import { JaDeleteQueueCommandBuilder, } from './ja.delete-queue-command.js';
+import { JaDeleteSyncScopeBuilder, } from './ja.delete-sync-scope.js';
+import { JaDeleteSyncStatusBuilder, } from './ja.delete-sync-status.js';
+import { JaExecuteActionBuilder } from './ja.execute-action.js';
+import { JaFindReplaceBuilder } from './ja.find-replace.js';
+import { JaExecuteEntitiesBuilder } from './ja.execute-entities.js';
+import { JaExecuteEntityBuilder } from './ja.execute-entity.js';
+import { JaExecuteSqlBuilder } from './ja.execute-sql.js';
+import { JaGenerateFileBuilder } from './ja.generate-file.js';
+import { JaGeneratePdfBuilder } from './ja.generate-pdf.js';
+import { JaGoBackBuilder } from './ja.go-back.js';
+import { JaGoToBuilder } from './ja.go-to.js';
+import { JaInfoModalBuilder } from './ja.info-modal.js';
+import { JaOpenAppSettingsBuilder, } from './ja.open-app-settings.js';
+import { JaOpenMapBuilder } from './ja.open-map.js';
+import { JaOpenMediaPickerBuilder, } from './ja.open-media-picker.js';
+import { JaOpenScannerBuilder } from './ja.open-scanner.js';
+import { JaOpenUrlBuilder } from './ja.open-url.js';
+import { JaPrintBuilder } from './ja.print.js';
+import { JaResetApplicationStateBuilder, } from './ja.reset-application-state.js';
+import { JaResetComponentStateBuilder, } from './ja.reset-component-state.js';
+import { JaResetScreenStateBuilder, } from './ja.reset-screen-state.js';
+import { JaResetStateBuilder } from './ja.reset-state.js';
+import { JaRetryQueueCommandBuilder, } from './ja.retry-queue-command.js';
+import { JaSetActiveTabBuilder } from './ja.set-active-tab.js';
+import { JaSetApplicationStateBuilder, } from './ja.set-application-state.js';
+import { JaSetScreenStateBuilder } from './ja.set-screen-state.js';
+import { JaShareBuilder } from './ja.share.js';
+import { JaShowAlertBuilder } from './ja.show-alert.js';
+import { JaStartLocationSharingBuilder, } from './ja.start-location-sharing.js';
+import { JaStartSyncScopeBuilder } from './ja.start-sync-scope.js';
+import { JaStopLocationSharingBuilder, } from './ja.stop-location-sharing.js';
+import { JaSubmitFormBuilder } from './ja.submit-form.js';
+import { JaSyncEntitiesBuilder } from './ja.sync-entities.js';
+import { JaUpdateProfileBuilder } from './ja.update-profile.js';
+export class JaInBackgroundFactory {
+    _binder;
+    constructor(binder) {
+        this._binder = binder;
+    }
+    goto(options) {
+        const action = new JaGoToBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    goBack(options = {}) {
+        const action = new JaGoBackBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    list(options) {
+        const action = new JaActionListBuilder({ ...options });
+        this._binder(action);
+        return action;
+    }
+    setScreenState(options) {
+        const action = new JaSetScreenStateBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    openMediaPicker(options) {
+        const action = new JaOpenMediaPickerBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    openUrl(options) {
+        const action = new JaOpenUrlBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    resetState(options) {
+        const action = new JaResetStateBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    infoModal(options = {}) {
+        const action = new JaInfoModalBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    executeEntity(options = {}) {
+        const action = new JaExecuteEntityBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    syncEntities(options) {
+        const action = new JaSyncEntitiesBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    confirm(options) {
+        const action = new JaConfirmBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    resetComponentState(options = {}) {
+        const action = new JaResetComponentStateBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    resetScreenState(options) {
+        const action = new JaResetScreenStateBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    resetApplicationState(options) {
+        const action = new JaResetApplicationStateBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    setApplicationState(options) {
+        const action = new JaSetApplicationStateBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    submitForm(options) {
+        const action = new JaSubmitFormBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    executeSql(options) {
+        const action = new JaExecuteSqlBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    setActiveTab(options) {
+        const action = new JaSetActiveTabBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    clearQueueCommand(options) {
+        const action = new JaClearQueueBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    deleteQueueCommand(options) {
+        const action = new JaDeleteQueueCommandBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    retryQueueCommand(options) {
+        const action = new JaRetryQueueCommandBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    deleteSyncScope(options) {
+        const action = new JaDeleteSyncScopeBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    deleteSyncStatus(options) {
+        const action = new JaDeleteSyncStatusBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    startSyncScope(options) {
+        const action = new JaStartSyncScopeBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    executeAction(options) {
+        const action = new JaExecuteActionBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    executeEntities(options) {
+        const action = new JaExecuteEntitiesBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    findReplace(options) {
+        const action = new JaFindReplaceBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    generateFile(options) {
+        const action = new JaGenerateFileBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    generatePdf(options) {
+        const action = new JaGeneratePdfBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    openAppSettings(options = {}) {
+        const action = new JaOpenAppSettingsBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    openMap(options) {
+        const action = new JaOpenMapBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    openScanner(options) {
+        const action = new JaOpenScannerBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    print(options) {
+        const action = new JaPrintBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    share(options) {
+        const action = new JaShareBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    showAlert(options = {}) {
+        const action = new JaShowAlertBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    startLocationSharing(options) {
+        const action = new JaStartLocationSharingBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    stopLocationSharing(options) {
+        const action = new JaStopLocationSharingBuilder(options);
+        this._binder(action);
+        return action;
+    }
+    updateProfile(options) {
+        const action = new JaUpdateProfileBuilder(options);
+        this._binder(action);
+        return action;
+    }
+}
+export class JaInBackgroundFactoryOne extends JaInBackgroundFactory {
+    _action;
+    static one() {
+        const factory = new JaInBackgroundFactoryOne((builder) => {
+            factory._action = builder;
+        });
+        return factory;
+    }
+    build() {
+        return this._action?.build();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ja.in-background.js","sourceRoot":"","sources":["../../src/action/ja.in-background.ts"],"names":[],"mappings":"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","sourcesContent":["import { type Expression, type KegInstanceId } from '../abstract/index.js'\nimport { type ActionBaseBuilder, type ActionBaseInput, type JaBase } from './ja.abstract.js'\nimport { JaActionListBuilder, type ActionListActionInput } from './ja.action-list.js'\nimport { JaClearQueueBuilder, type ClearQueueActionInput } from './ja.clear-queue.js'\nimport { JaConfirmBuilder, type ConfirmActionInput } from './ja.confirm.js'\nimport {\n  JaDeleteQueueCommandBuilder,\n  type DeleteQueueCommandActionInput,\n} from './ja.delete-queue-command.js'\nimport {\n  JaDeleteSyncScopeBuilder,\n  type DeleteSyncScopeActionInput,\n} from './ja.delete-sync-scope.js'\nimport {\n  JaDeleteSyncStatusBuilder,\n  type DeleteSyncStatusActionInput,\n} from './ja.delete-sync-status.js'\nimport { JaExecuteActionBuilder, type ExecuteActionActionInput } from './ja.execute-action.js'\nimport { JaFindReplaceBuilder, type FindReplaceActionInput } from './ja.find-replace.js'\nimport { JaExecuteEntitiesBuilder, type ExecuteEntitiesInput } from './ja.execute-entities.js'\nimport { JaExecuteEntityBuilder, type ExecuteEntityInput } from './ja.execute-entity.js'\nimport { JaExecuteSqlBuilder, type ExecuteSqlActionInput } from './ja.execute-sql.js'\nimport { JaGenerateFileBuilder, type GenerateFileActionInput } from './ja.generate-file.js'\nimport { JaGeneratePdfBuilder } from './ja.generate-pdf.js'\nimport { JaGoBackBuilder, type GoBackActionInput } from './ja.go-back.js'\nimport { JaGoToBuilder, type GoToActionInput } from './ja.go-to.js'\nimport { JaInfoModalBuilder, type InfoModalActionInput } from './ja.info-modal.js'\nimport {\n  JaOpenAppSettingsBuilder,\n  type OpenAppSettingsActionInput,\n} from './ja.open-app-settings.js'\nimport { JaOpenMapBuilder, type OpenMapActionInput } from './ja.open-map.js'\nimport {\n  JaOpenMediaPickerBuilder,\n  type OpenMediaPickerActionInput,\n} from './ja.open-media-picker.js'\nimport { JaOpenScannerBuilder, type OpenScannerActionInput } from './ja.open-scanner.js'\nimport { JaOpenUrlBuilder, type OpenUrlActionInput } from './ja.open-url.js'\nimport { JaPrintBuilder, type PrintActionInput } from './ja.print.js'\nimport {\n  JaResetApplicationStateBuilder,\n  type ResetApplicationStateActionInput,\n} from './ja.reset-application-state.js'\nimport {\n  JaResetComponentStateBuilder,\n  type ResetComponentStateActionInput,\n} from './ja.reset-component-state.js'\nimport {\n  JaResetScreenStateBuilder,\n  type ResetScreenStateActionInput,\n} from './ja.reset-screen-state.js'\nimport { JaResetStateBuilder, type ResetStateActionInput } from './ja.reset-state.js'\nimport {\n  JaRetryQueueCommandBuilder,\n  type RetryQueueCommandActionInput,\n} from './ja.retry-queue-command.js'\nimport { JaSetActiveTabBuilder, type SetActiveTabActionInput } from './ja.set-active-tab.js'\nimport {\n  JaSetApplicationStateBuilder,\n  type SetApplicationStateActionInput,\n} from './ja.set-application-state.js'\nimport { JaSetScreenStateBuilder, type SetScreenStateActionInput } from './ja.set-screen-state.js'\nimport { JaShareBuilder, type ShareActionInput } from './ja.share.js'\nimport { JaShowAlertBuilder, type ShowAlertActionInput } from './ja.show-alert.js'\nimport {\n  JaStartLocationSharingBuilder,\n  type StartLocationSharingActionInput,\n} from './ja.start-location-sharing.js'\nimport { JaStartSyncScopeBuilder, type StartSyncScopeActionInput } from './ja.start-sync-scope.js'\nimport {\n  JaStopLocationSharingBuilder,\n  type StopLocationSharingActionInput,\n} from './ja.stop-location-sharing.js'\nimport { JaSubmitFormBuilder, type SubmitFormActionInput } from './ja.submit-form.js'\nimport { JaSyncEntitiesBuilder, type SyncEntitiesActionInput } from './ja.sync-entities.js'\nimport { JaUpdateProfileBuilder, type UpdateProfileActionInput } from './ja.update-profile.js'\n\n/**\n * `JaInBackground` is a type that represents all possible actions that can be executed in the background\n * @alias KegActionInBackground\n * @alias keg-action-in-background\n * @see #/definitions/keg-action-in-background\n */\n// Do NOT arbitrarily add components here, this is a specific, discrete list\nexport type JaInBackground = JaBase\n\n/**\n * `ActionBuilder` is a unified type representing all action builders.\n *\n * After PR #119, action builders were unified - single builder classes (e.g., JaGoToBuilder)\n * handle both button and background contexts via factory type constraints.\n *\n * @see createActionInBackgroundBuildersFactory for background context\n * @see createActionOnButtonBuildersFactory for button context\n * @alias JaInBackgroundBuilders (deprecated name)\n * @alias KegActionInBackground\n * @alias keg-action-in-background\n * @see #/definitions/keg-action-in-background\n */\n// Do NOT arbitrarily add components here, this is a specific, discrete list\nexport type ActionBuilder = ActionBaseBuilder<ActionBaseInput>\n/**\n * @deprecated Use ActionBuilder instead. Kept for backward compatibility.\n */\nexport type JaInBackgroundBuilders = ActionBuilder\n\n/**\n * @deprecated\n */\nexport abstract class JaInBackgroundFactory {\n  private readonly _binder: (action: ActionBuilder) => void\n\n  constructor(binder: (action: ActionBuilder) => void) {\n    this._binder = binder\n  }\n\n  goto(options: GoToActionInput): JaGoToBuilder {\n    const action = new JaGoToBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create a go-back action builder\n   * @param options - Configuration for the go-back action (optional)\n   */\n  goBack(options: GoBackActionInput = {}): JaGoBackBuilder {\n    const action = new JaGoBackBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create an action-list builder.\n   * - Omit `concurrency` to keep YAML default behavior (sequential, without `isSequential`).\n   * - Use `concurrency: 'sequential'` to emit `isSequential: true`.\n   * - Use `concurrency: 'parallel'` to emit `isSequential: false`.\n   */\n  list(options?: ActionListActionInput): JaActionListBuilder {\n    const action = new JaActionListBuilder({ ...options })\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create a set-jig-state action builder\n   * @alias setJigState\n   * @param options - Configuration for the set-jig-state action\n   */\n  setScreenState(options: SetScreenStateActionInput): JaSetScreenStateBuilder {\n    const action = new JaSetScreenStateBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create an open-media-picker action builder\n   * @param options - Configuration for media picker action\n   */\n  openMediaPicker(options: OpenMediaPickerActionInput): JaOpenMediaPickerBuilder {\n    const action = new JaOpenMediaPickerBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create an open-url action builder\n   * @param options - Open URL action configuration\n   */\n  openUrl(options: OpenUrlActionInput): JaOpenUrlBuilder {\n    const action = new JaOpenUrlBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create a reset-state action builder\n   * @alias resetState\n   * @param options\n   */\n  resetState(options: ResetStateActionInput): JaResetStateBuilder {\n    const action = new JaResetStateBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create an info-modal action builder\n   * @param options - Configuration for the info-modal action (optional)\n   */\n  infoModal(options: InfoModalActionInput = {}): JaInfoModalBuilder {\n    const action = new JaInfoModalBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create an execute-entity action builder\n   */\n  executeEntity(options: ExecuteEntityInput = {}): JaExecuteEntityBuilder {\n    const action = new JaExecuteEntityBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create a sync-entities action builder\n   * @param options\n   */\n  syncEntities(options: SyncEntitiesActionInput): JaSyncEntitiesBuilder {\n    const action = new JaSyncEntitiesBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create a confirm action builder\n   * @param options - Configuration for confirm action\n   */\n  confirm(options: ConfirmActionInput): JaConfirmBuilder {\n    const action = new JaConfirmBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create a reset-component-state action builder\n   * @param options - Configuration for reset-component-state action (optional)\n   */\n  resetComponentState(options: ResetComponentStateActionInput = {}): JaResetComponentStateBuilder {\n    const action = new JaResetComponentStateBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create a reset-jig-state action builder\n   */\n  resetScreenState(options: ResetScreenStateActionInput): JaResetScreenStateBuilder {\n    const action = new JaResetScreenStateBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create a reset-solution-state action builder\n   * @alias resetSolutionState\n   * @param options - Reset application state action configuration\n   */\n  resetApplicationState(options: ResetApplicationStateActionInput): JaResetApplicationStateBuilder {\n    const action = new JaResetApplicationStateBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create a set-solution-state action builder\n   * @alias setSolutionState\n   * @param options - Set application state action configuration\n   */\n  setApplicationState(options: SetApplicationStateActionInput): JaSetApplicationStateBuilder {\n    const action = new JaSetApplicationStateBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create a submit-form action builder\n   * @param options - Submit form configuration options\n   */\n  submitForm(options: SubmitFormActionInput): JaSubmitFormBuilder {\n    const action = new JaSubmitFormBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create an execute-sql action builder\n   * @param options - Configuration for execute-sql action\n   */\n  executeSql(options: ExecuteSqlActionInput): JaExecuteSqlBuilder {\n    const action = new JaExecuteSqlBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create a set-active-tab action builder\n   * @param options - Configuration for the set-active-tab action\n   */\n  setActiveTab(options: SetActiveTabActionInput): JaSetActiveTabBuilder {\n    const action = new JaSetActiveTabBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create a clear-queue action builder\n   * @param options - Configuration for clear-queue action\n   */\n  clearQueueCommand(options: ClearQueueActionInput): JaClearQueueBuilder {\n    const action = new JaClearQueueBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create a delete-queue-command action builder\n   * @param options - Configuration for delete-queue-command action\n   */\n  deleteQueueCommand(options: DeleteQueueCommandActionInput): JaDeleteQueueCommandBuilder {\n    const action = new JaDeleteQueueCommandBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create a retry-queue-command action builder\n   * @param options - Configuration for retry-queue-command action\n   */\n  retryQueueCommand(options: RetryQueueCommandActionInput): JaRetryQueueCommandBuilder {\n    const action = new JaRetryQueueCommandBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create a delete-sync-scope action builder\n   * @param options - Configuration for the delete-sync-scope action\n   */\n  deleteSyncScope(options: DeleteSyncScopeActionInput): JaDeleteSyncScopeBuilder {\n    const action = new JaDeleteSyncScopeBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create a delete-sync-status action builder\n   * @param options - Configuration for the delete-sync-status action\n   */\n  deleteSyncStatus(options: DeleteSyncStatusActionInput): JaDeleteSyncStatusBuilder {\n    const action = new JaDeleteSyncStatusBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create a start-sync-scope action builder\n   * @param options - Configuration options for the action\n   */\n  startSyncScope(options: StartSyncScopeActionInput): JaStartSyncScopeBuilder {\n    const action = new JaStartSyncScopeBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create an execute-action action builder\n   * @param options - Configuration options for execute-action\n   */\n  executeAction(options: ExecuteActionActionInput): JaExecuteActionBuilder {\n    const action = new JaExecuteActionBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create an execute-entities action builder\n   * @param options - Configuration for execute-entities action\n   */\n  executeEntities(options: ExecuteEntitiesInput): JaExecuteEntitiesBuilder {\n    const action = new JaExecuteEntitiesBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create a find-replace action builder\n   * @param options - Configuration for find-replace action\n   */\n  findReplace(options: FindReplaceActionInput): JaFindReplaceBuilder {\n    const action = new JaFindReplaceBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create a generate-file action builder\n   * @param options - Configuration for generate-file action\n   */\n  generateFile(options: GenerateFileActionInput): JaGenerateFileBuilder {\n    const action = new JaGenerateFileBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create a generate-pdf action builder\n   * @param options - Options for PDF generation\n   * @param options.fileName - PDF file name\n   * @param options.html - HTML content\n   * @param options.instanceId - Instance ID for tracking\n   */\n  generatePdf(options: {\n    readonly fileName: string | Expression\n    readonly html: string | Expression\n    readonly instanceId?: string | KegInstanceId\n  }): JaGeneratePdfBuilder {\n    const action = new JaGeneratePdfBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create an open-app-settings action builder\n   * @param options - Configuration for open-app-settings action\n   */\n  openAppSettings(options: OpenAppSettingsActionInput = {}): JaOpenAppSettingsBuilder {\n    const action = new JaOpenAppSettingsBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create an open-map action builder\n   * @param options - Configuration for the open-map action\n   */\n  openMap(options: OpenMapActionInput): JaOpenMapBuilder {\n    const action = new JaOpenMapBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create an open-scanner action builder\n   * @param options - Open scanner action configuration\n   */\n  openScanner(options: OpenScannerActionInput): JaOpenScannerBuilder {\n    const action = new JaOpenScannerBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create a print action builder\n   * @param options - Print action configuration\n   */\n  print(options: PrintActionInput): JaPrintBuilder {\n    const action = new JaPrintBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create a share action builder\n   * @param options - Configuration options for the share action\n   */\n  share(options: ShareActionInput): JaShareBuilder {\n    const action = new JaShareBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create a show-alert action builder\n   * @param options - Configuration for the show-alert action (optional)\n   */\n  showAlert(options: ShowAlertActionInput = {}): JaShowAlertBuilder {\n    const action = new JaShowAlertBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create a start-location-sharing action builder\n   * @param options - Configuration options for start-location-sharing action\n   */\n  startLocationSharing(options: StartLocationSharingActionInput): JaStartLocationSharingBuilder {\n    const action = new JaStartLocationSharingBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create a stop-location-sharing action builder\n   * @param options - Configuration options for stop-location-sharing action\n   */\n  stopLocationSharing(options?: StopLocationSharingActionInput): JaStopLocationSharingBuilder {\n    const action = new JaStopLocationSharingBuilder(options)\n    this._binder(action)\n    return action\n  }\n\n  /**\n   * Create an update-profile action builder\n   * @param options - Configuration options for the update-profile action\n   */\n  updateProfile(options: UpdateProfileActionInput): JaUpdateProfileBuilder {\n    const action = new JaUpdateProfileBuilder(options)\n    this._binder(action)\n    return action\n  }\n}\n\nexport class JaInBackgroundFactoryOne extends JaInBackgroundFactory {\n  private _action?: ActionBuilder\n\n  static one(): JaInBackgroundFactoryOne {\n    const factory = new JaInBackgroundFactoryOne((builder: ActionBuilder) => {\n      factory._action = builder\n    })\n    return factory\n  }\n\n  build(): JaInBackground | undefined {\n    return this._action?.build()\n  }\n}\n"]}

package/dist/action/ja.info-modal.d.ts

@@ -0,0 +1,37 @@
+import { type Expression, type StringOrExpression, type TextValue, TextValueBuilder } from '../abstract/index.js';
+import { ActionBaseBuilder, type ActionBaseInput } from './ja.abstract.js';
+export type InfoModalElementInput = {
+    readonly type: 'avatar';
+    readonly text: StringOrExpression;
+    readonly uri?: StringOrExpression;
+} | {
+    readonly type: 'icon';
+    readonly icon: StringOrExpression;
+    readonly color?: 'primary' | 'warning' | 'negative' | 'positive' | 'element' | Expression;
+} | {
+    readonly type: 'image';
+    readonly uri?: StringOrExpression;
+    readonly resizeMode?: 'center' | 'contain' | 'cover' | 'stretch';
+};
+export interface InfoModalInput {
+    readonly title?: TextValue;
+    readonly description?: TextValue;
+    readonly buttonText?: TextValue;
+    readonly element?: InfoModalElementInput;
+}
+export interface InfoModalActionInput extends ActionBaseInput {
+    readonly modal?: InfoModalInput;
+    readonly modalTitle?: TextValue;
+    readonly message?: TextValue;
+}
+export declare class JaInfoModalBuilder<TInput extends InfoModalActionInput = InfoModalActionInput> extends ActionBaseBuilder<InfoModalActionInput> {
+    constructor(options: TInput);
+    modal: {
+        title: (value?: string | number | boolean | import("../abstract/zod.types.ts").TextLocale | import("../abstract/zod.types.ts").TextWithFormat | null | undefined) => TextValueBuilder;
+        description: (value?: string | number | boolean | import("../abstract/zod.types.ts").TextLocale | import("../abstract/zod.types.ts").TextWithFormat | null | undefined) => TextValueBuilder;
+        buttonText: (value?: string | number | boolean | import("../abstract/zod.types.ts").TextLocale | import("../abstract/zod.types.ts").TextWithFormat | null | undefined) => TextValueBuilder;
+        element: (element: InfoModalElementInput) => JaInfoModalBuilder<TInput>;
+    };
+    onConfirmed: import("./ja.in-background.factory.js").ActionInBackgroundBuilders;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/action/ja.info-modal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ja.info-modal.d.ts","sourceRoot":"","sources":["../../src/action/ja.info-modal.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,UAAU,EACf,KAAK,kBAAkB,EACvB,KAAK,SAAS,EACd,gBAAgB,EAEjB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,iBAAiB,EAAE,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAG1E,MAAM,MAAM,qBAAqB,GAC7B;IACE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAA;IACjC,QAAQ,CAAC,GAAG,CAAC,EAAE,kBAAkB,CAAA;CAClC,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAA;IACjC,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,UAAU,GAAG,UAAU,GAAG,SAAS,GAAG,UAAU,CAAA;CAC1F,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,GAAG,CAAC,EAAE,kBAAkB,CAAA;IACjC,QAAQ,CAAC,UAAU,CAAC,EAAE,QAAQ,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAA;CACjE,CAAA;AAEL,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAA;IAC1B,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,CAAA;IAChC,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,CAAA;IAC/B,QAAQ,CAAC,OAAO,CAAC,EAAE,qBAAqB,CAAA;CACzC;AAED,MAAM,WAAW,oBAAqB,SAAQ,eAAe;IAC3D,QAAQ,CAAC,KAAK,CAAC,EAAE,cAAc,CAAA;IAM/B,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,CAAA;IAM/B,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,CAAA;CAC7B;AASD,qBAAa,kBAAkB,CAC7B,MAAM,SAAS,oBAAoB,GAAG,oBAAoB,CAC1D,SAAQ,iBAAiB,CAAC,oBAAoB,CAAC;IAC/C,YAAY,OAAO,EAAE,MAAM,EAwB1B;IAED,KAAK;;;;;MA2BJ;IAED,WAAW,qEAET;CACH","sourcesContent":["import {\n  ACTION_TYPE,\n  assignBuilderFactory,\n  type Expression,\n  type StringOrExpression,\n  type TextValue,\n  TextValueBuilder,\n  toStringOrExpression,\n} from '../abstract/index.js'\nimport { ActionBaseBuilder, type ActionBaseInput } from './ja.abstract.js'\nimport { createActionInBackgroundBuildersFactory } from './ja.in-background.factory.js'\n\nexport type InfoModalElementInput =\n  | {\n      readonly type: 'avatar'\n      readonly text: StringOrExpression\n      readonly uri?: StringOrExpression\n    }\n  | {\n      readonly type: 'icon'\n      readonly icon: StringOrExpression\n      readonly color?: 'primary' | 'warning' | 'negative' | 'positive' | 'element' | Expression\n    }\n  | {\n      readonly type: 'image'\n      readonly uri?: StringOrExpression\n      readonly resizeMode?: 'center' | 'contain' | 'cover' | 'stretch'\n    }\n\nexport interface InfoModalInput {\n  readonly title?: TextValue\n  readonly description?: TextValue\n  readonly buttonText?: TextValue\n  readonly element?: InfoModalElementInput\n}\n\nexport interface InfoModalActionInput extends ActionBaseInput {\n  readonly modal?: InfoModalInput\n\n  /**\n   * Legacy alias for `modal.title`.\n   * @deprecated Use `modal.title` instead.\n   */\n  readonly modalTitle?: TextValue\n\n  /**\n   * Legacy alias for `modal.description`.\n   * @deprecated Use `modal.description` instead.\n   */\n  readonly message?: TextValue\n}\n\n/**\n * Background info-modal action - programmatic information display.\n * @alias action.info-modal\n *\n * Shows informational modals automatically after operations.\n * Used for notifications, status updates, and user guidance.\n */\nexport class JaInfoModalBuilder<\n  TInput extends InfoModalActionInput = InfoModalActionInput,\n> extends ActionBaseBuilder<InfoModalActionInput> {\n  constructor(options: TInput) {\n    super(ACTION_TYPE.INFO_MODAL, options)\n\n    if (options.modal !== undefined) {\n      if (options.modal.title !== undefined) {\n        this.modal.title(options.modal.title)\n      }\n      if (options.modal.description !== undefined) {\n        this.modal.description(options.modal.description)\n      }\n      if (options.modal.buttonText !== undefined) {\n        this.modal.buttonText(options.modal.buttonText)\n      }\n      if (options.modal.element !== undefined) {\n        this.modal.element(options.modal.element)\n      }\n    }\n\n    if (options.modalTitle !== undefined) {\n      this.modal.title(options.modalTitle)\n    }\n    if (options.message !== undefined) {\n      this.modal.description(options.message)\n    }\n  }\n\n  modal = {\n    title: assignBuilderFactory(TextValueBuilder, this._config, 'modal.title'),\n    description: assignBuilderFactory(TextValueBuilder, this._config, 'modal.description'),\n    buttonText: assignBuilderFactory(TextValueBuilder, this._config, 'modal.buttonText'),\n    element: (element: InfoModalElementInput): JaInfoModalBuilder<TInput> => {\n      if (element.type === 'avatar') {\n        this._setToConfig('modal.element', {\n          type: 'avatar',\n          text: toStringOrExpression(element.text),\n          ...(element.uri !== undefined ? { uri: toStringOrExpression(element.uri) } : {}),\n        })\n      } else if (element.type === 'icon') {\n        this._setToConfig('modal.element', {\n          type: 'icon',\n          icon: toStringOrExpression(element.icon),\n          ...(element.color !== undefined ? { color: element.color } : {}),\n        })\n      } else if (element.type === 'image') {\n        this._setToConfig('modal.element', {\n          type: 'image',\n          ...(element.uri !== undefined ? { uri: toStringOrExpression(element.uri) } : {}),\n          ...(element.resizeMode !== undefined ? { resizeMode: element.resizeMode } : {}),\n        })\n      }\n\n      return this\n    },\n  }\n\n  onConfirmed = createActionInBackgroundBuildersFactory((action) => {\n    this._setToConfig('onConfirmed', action)\n  })\n}\n"]}

package/dist/action/ja.info-modal.js

@@ -0,0 +1,61 @@
+import { ACTION_TYPE, assignBuilderFactory, TextValueBuilder, toStringOrExpression, } from '../abstract/index.js';
+import { ActionBaseBuilder } from './ja.abstract.js';
+import { createActionInBackgroundBuildersFactory } from './ja.in-background.factory.js';
+export class JaInfoModalBuilder extends ActionBaseBuilder {
+    constructor(options) {
+        super(ACTION_TYPE.INFO_MODAL, options);
+        if (options.modal !== undefined) {
+            if (options.modal.title !== undefined) {
+                this.modal.title(options.modal.title);
+            }
+            if (options.modal.description !== undefined) {
+                this.modal.description(options.modal.description);
+            }
+            if (options.modal.buttonText !== undefined) {
+                this.modal.buttonText(options.modal.buttonText);
+            }
+            if (options.modal.element !== undefined) {
+                this.modal.element(options.modal.element);
+            }
+        }
+        if (options.modalTitle !== undefined) {
+            this.modal.title(options.modalTitle);
+        }
+        if (options.message !== undefined) {
+            this.modal.description(options.message);
+        }
+    }
+    modal = {
+        title: assignBuilderFactory(TextValueBuilder, this._config, 'modal.title'),
+        description: assignBuilderFactory(TextValueBuilder, this._config, 'modal.description'),
+        buttonText: assignBuilderFactory(TextValueBuilder, this._config, 'modal.buttonText'),
+        element: (element) => {
+            if (element.type === 'avatar') {
+                this._setToConfig('modal.element', {
+                    type: 'avatar',
+                    text: toStringOrExpression(element.text),
+                    ...(element.uri !== undefined ? { uri: toStringOrExpression(element.uri) } : {}),
+                });
+            }
+            else if (element.type === 'icon') {
+                this._setToConfig('modal.element', {
+                    type: 'icon',
+                    icon: toStringOrExpression(element.icon),
+                    ...(element.color !== undefined ? { color: element.color } : {}),
+                });
+            }
+            else if (element.type === 'image') {
+                this._setToConfig('modal.element', {
+                    type: 'image',
+                    ...(element.uri !== undefined ? { uri: toStringOrExpression(element.uri) } : {}),
+                    ...(element.resizeMode !== undefined ? { resizeMode: element.resizeMode } : {}),
+                });
+            }
+            return this;
+        },
+    };
+    onConfirmed = createActionInBackgroundBuildersFactory((action) => {
+        this._setToConfig('onConfirmed', action);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ja.info-modal.js","sourceRoot":"","sources":["../../src/action/ja.info-modal.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ACTION_TYPE,\n  assignBuilderFactory,\n  type Expression,\n  type StringOrExpression,\n  type TextValue,\n  TextValueBuilder,\n  toStringOrExpression,\n} from '../abstract/index.js'\nimport { ActionBaseBuilder, type ActionBaseInput } from './ja.abstract.js'\nimport { createActionInBackgroundBuildersFactory } from './ja.in-background.factory.js'\n\nexport type InfoModalElementInput =\n  | {\n      readonly type: 'avatar'\n      readonly text: StringOrExpression\n      readonly uri?: StringOrExpression\n    }\n  | {\n      readonly type: 'icon'\n      readonly icon: StringOrExpression\n      readonly color?: 'primary' | 'warning' | 'negative' | 'positive' | 'element' | Expression\n    }\n  | {\n      readonly type: 'image'\n      readonly uri?: StringOrExpression\n      readonly resizeMode?: 'center' | 'contain' | 'cover' | 'stretch'\n    }\n\nexport interface InfoModalInput {\n  readonly title?: TextValue\n  readonly description?: TextValue\n  readonly buttonText?: TextValue\n  readonly element?: InfoModalElementInput\n}\n\nexport interface InfoModalActionInput extends ActionBaseInput {\n  readonly modal?: InfoModalInput\n\n  /**\n   * Legacy alias for `modal.title`.\n   * @deprecated Use `modal.title` instead.\n   */\n  readonly modalTitle?: TextValue\n\n  /**\n   * Legacy alias for `modal.description`.\n   * @deprecated Use `modal.description` instead.\n   */\n  readonly message?: TextValue\n}\n\n/**\n * Background info-modal action - programmatic information display.\n * @alias action.info-modal\n *\n * Shows informational modals automatically after operations.\n * Used for notifications, status updates, and user guidance.\n */\nexport class JaInfoModalBuilder<\n  TInput extends InfoModalActionInput = InfoModalActionInput,\n> extends ActionBaseBuilder<InfoModalActionInput> {\n  constructor(options: TInput) {\n    super(ACTION_TYPE.INFO_MODAL, options)\n\n    if (options.modal !== undefined) {\n      if (options.modal.title !== undefined) {\n        this.modal.title(options.modal.title)\n      }\n      if (options.modal.description !== undefined) {\n        this.modal.description(options.modal.description)\n      }\n      if (options.modal.buttonText !== undefined) {\n        this.modal.buttonText(options.modal.buttonText)\n      }\n      if (options.modal.element !== undefined) {\n        this.modal.element(options.modal.element)\n      }\n    }\n\n    if (options.modalTitle !== undefined) {\n      this.modal.title(options.modalTitle)\n    }\n    if (options.message !== undefined) {\n      this.modal.description(options.message)\n    }\n  }\n\n  modal = {\n    title: assignBuilderFactory(TextValueBuilder, this._config, 'modal.title'),\n    description: assignBuilderFactory(TextValueBuilder, this._config, 'modal.description'),\n    buttonText: assignBuilderFactory(TextValueBuilder, this._config, 'modal.buttonText'),\n    element: (element: InfoModalElementInput): JaInfoModalBuilder<TInput> => {\n      if (element.type === 'avatar') {\n        this._setToConfig('modal.element', {\n          type: 'avatar',\n          text: toStringOrExpression(element.text),\n          ...(element.uri !== undefined ? { uri: toStringOrExpression(element.uri) } : {}),\n        })\n      } else if (element.type === 'icon') {\n        this._setToConfig('modal.element', {\n          type: 'icon',\n          icon: toStringOrExpression(element.icon),\n          ...(element.color !== undefined ? { color: element.color } : {}),\n        })\n      } else if (element.type === 'image') {\n        this._setToConfig('modal.element', {\n          type: 'image',\n          ...(element.uri !== undefined ? { uri: toStringOrExpression(element.uri) } : {}),\n          ...(element.resizeMode !== undefined ? { resizeMode: element.resizeMode } : {}),\n        })\n      }\n\n      return this\n    },\n  }\n\n  onConfirmed = createActionInBackgroundBuildersFactory((action) => {\n    this._setToConfig('onConfirmed', action)\n  })\n}\n"]}

package/dist/action/ja.jig-actions.d.ts

@@ -0,0 +1,16 @@
+import { type BooleanOrExpression, type Expression, type When } from '../abstract/index.js';
+export interface JigActionsBuilderInput {
+    when?: When;
+    numberOfVisibleActions?: number | Expression;
+    readonly isDisabled?: BooleanOrExpression;
+    readonly isEssential?: BooleanOrExpression;
+    readonly isDanger?: BooleanOrExpression;
+}
+export declare class JigActionsBuilder {
+    private _when?;
+    private readonly _config;
+    readonly add: import("./ja.on-button.factory.js").ActionOnButtonBuilders;
+    constructor(options?: JigActionsBuilderInput);
+    build(): Record<string, unknown>;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/action/ja.jig-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ja.jig-actions.d.ts","sourceRoot":"","sources":["../../src/action/ja.jig-actions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,mBAAmB,EAExB,KAAK,UAAU,EAEf,KAAK,IAAI,EACV,MAAM,sBAAsB,CAAA;AAG7B,MAAM,WAAW,sBAAsB;IACrC,IAAI,CAAC,EAAE,IAAI,CAAA;IACX,sBAAsB,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IAI5C,QAAQ,CAAC,UAAU,CAAC,EAAE,mBAAmB,CAAA;IAIzC,QAAQ,CAAC,WAAW,CAAC,EAAE,mBAAmB,CAAA;IAI1C,QAAQ,CAAC,QAAQ,CAAC,EAAE,mBAAmB,CAAA;CACxC;AAUD,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,KAAK,CAAC,CAAM;IACpB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA8B;IAItD,QAAQ,CAAC,GAAG,6DAGV;IAEF,YAAY,OAAO,CAAC,EAAE,sBAAsB,EAiB3C;IAED,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAK/B;CACF","sourcesContent":["import {\n  type BooleanOrExpression,\n  buildTree,\n  type Expression,\n  toWhen,\n  type When,\n} from '../abstract/index.js'\nimport { createActionOnButtonBuildersFactory } from './ja.on-button.factory.js'\n\nexport interface JigActionsBuilderInput {\n  when?: When\n  numberOfVisibleActions?: number | Expression\n  /**\n   * Whether or not actions are disabled\n   */\n  readonly isDisabled?: BooleanOrExpression\n  /**\n   * Only actions are displayed. Nothing else.\n   */\n  readonly isEssential?: BooleanOrExpression\n  /**\n   * Whether or not action is dangerous\n   */\n  readonly isDanger?: BooleanOrExpression\n}\n\n/**\n * Builder for configuring screen action buttons.\n *\n * Creates action buttons at the bottom of screens following mobile-first design.\n * Defaults to 1 visible action, supports up to 2 with additional actions in overflow menu.\n *\n * @see #/definitions/jig-actions\n */\nexport class JigActionsBuilder {\n  private _when?: When\n  private readonly _config: Record<string, unknown> = {}\n\n  // TODO: rename to addAction\n  /** Factory for creating screen actions */\n  readonly add = createActionOnButtonBuildersFactory((action) => {\n    const current: unknown[] = Array.isArray(this._config.children) ? this._config.children : []\n    this._config.children = [...current, action]\n  })\n\n  constructor(options?: JigActionsBuilderInput) {\n    if (options?.when) {\n      this._config.when = toWhen(options.when)\n    }\n\n    if (options?.numberOfVisibleActions !== undefined) {\n      this._config.numberOfVisibleActions = options.numberOfVisibleActions\n    }\n\n    const style: Record<string, unknown> = {}\n    if (options?.isDisabled !== undefined) style.isDisabled = options.isDisabled\n    if (options?.isEssential !== undefined) style.isEssential = options.isEssential\n    if (options?.isDanger !== undefined) style.isDanger = options.isDanger\n\n    if (Object.keys(style).length > 0) {\n      this._config.style = style\n    }\n  }\n\n  build(): Record<string, unknown> {\n    return {\n      when: this._when,\n      ...buildTree(this._config),\n    }\n  }\n}\n"]}

package/dist/action/ja.jig-actions.js

@@ -0,0 +1,35 @@
+import { buildTree, toWhen, } from '../abstract/index.js';
+import { createActionOnButtonBuildersFactory } from './ja.on-button.factory.js';
+export class JigActionsBuilder {
+    _when;
+    _config = {};
+    add = createActionOnButtonBuildersFactory((action) => {
+        const current = Array.isArray(this._config.children) ? this._config.children : [];
+        this._config.children = [...current, action];
+    });
+    constructor(options) {
+        if (options?.when) {
+            this._config.when = toWhen(options.when);
+        }
+        if (options?.numberOfVisibleActions !== undefined) {
+            this._config.numberOfVisibleActions = options.numberOfVisibleActions;
+        }
+        const style = {};
+        if (options?.isDisabled !== undefined)
+            style.isDisabled = options.isDisabled;
+        if (options?.isEssential !== undefined)
+            style.isEssential = options.isEssential;
+        if (options?.isDanger !== undefined)
+            style.isDanger = options.isDanger;
+        if (Object.keys(style).length > 0) {
+            this._config.style = style;
+        }
+    }
+    build() {
+        return {
+            when: this._when,
+            ...buildTree(this._config),
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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