@jigx/core-sdk 1.0.0

package/dist/application/application.sdk.d.ts

@@ -0,0 +1,84 @@
+import { type ApplicationName, BaseBuilder, type BooleanOrExpression, type Category, type Expression } from '../abstract/index.js';
+import { ActionDefinitionBuilder } from '../action/index.js';
+import { DefaultDatabaseBuilder } from '../database/index.js';
+import { SqliteDatasourceBuilder, StaticDatasourceBuilder, SystemDatasourceBuilder } from '../datasource/index.js';
+import { RestFunctionBuilder } from '../function/function.rest.js';
+import { SqlFunctionBuilder } from '../function/function.sql.js';
+import { SoapFunctionBuilder } from '../function/function.soap.js';
+import { type IconName } from '../icon/index.js';
+import { CalendarScreenBuilder, DefaultScreenBuilder, DocumentScreenBuilder, DynamicGridScreenBuilder, FullScreenBuilder, GalleryScreenBuilder, ListScreenBuilder, type ScreenBuilder, StaticGridScreenBuilder, TabsScreenBuilder, WizardScreenBuilder } from '../screen/index.js';
+import { ApplicationTabBuilder } from './application.tab.js';
+export type Application = Record<string, any>;
+export declare const RUNTIME_SCHEMA_VERSION = 7;
+export interface ApplicationInput {
+    readonly name: string | ApplicationName;
+    readonly title?: string;
+    readonly description?: string;
+    readonly category?: Category;
+    readonly type?: string;
+    readonly imageUrl?: string;
+    readonly state?: unknown;
+    readonly permissions?: unknown;
+    readonly dependencies?: unknown;
+    readonly profile?: {
+        readonly isPersonalInfoMenuItemVisible?: BooleanOrExpression;
+        readonly children: unknown[];
+    };
+}
+export declare class ApplicationBuilder extends BaseBuilder {
+    protected readonly _config: Record<string, unknown>;
+    readonly addDatasource: {
+        sqlite: (options: import("../datasource/datasource.sqlite.ts").SqliteDatasourceInput) => SqliteDatasourceBuilder;
+        static: (options: import("../datasource/datasource.static.ts").StaticDatasourceInput) => StaticDatasourceBuilder;
+        system: (options: import("../datasource/datasource.system.ts").SystemDatasourceInput) => SystemDatasourceBuilder;
+    };
+    readonly addFunction: {
+        rest: (options: import("../function/function.rest.js").RestFunctionInput) => RestFunctionBuilder;
+        sql: (options: import("../function/function.sql.js").SqlFunctionInput) => SqlFunctionBuilder;
+        soap: (options: import("../function/function.soap.js").SoapFunctionInput) => SoapFunctionBuilder;
+    };
+    readonly addScreen: {
+        calendar: (options: import("../screen/screen.abstract.ts").ScreenBaseBuilderInput) => CalendarScreenBuilder;
+        default: (options: import("../screen/screen.default.ts").DefaultScreenInput) => DefaultScreenBuilder;
+        document: (options: import("../screen/screen.abstract.ts").ScreenBaseBuilderInput) => DocumentScreenBuilder;
+        fullScreen: (options: import("../screen/screen.abstract.ts").ScreenBaseBuilderInput) => FullScreenBuilder;
+        staticGrid: (options: import("../screen/screen.abstract.ts").ScreenBaseBuilderInput) => StaticGridScreenBuilder;
+        dynamicGrid: (options: import("../screen/screen.abstract.ts").ScreenBaseBuilderInput) => DynamicGridScreenBuilder;
+        gallery: (options: import("../screen/screen.abstract.ts").ScreenBaseBuilderInput) => GalleryScreenBuilder;
+        list: (options: import("../screen/screen.list.ts").ListScreenInput) => ListScreenBuilder;
+        tabs: (options: import("../screen/screen.tabs.ts").TabsScreenInput) => TabsScreenBuilder;
+        wizard: (options: import("../screen/screen.abstract.ts").ScreenBaseBuilderInput) => WizardScreenBuilder;
+        screens: Record<string, ScreenBuilder>;
+    };
+    readonly addDatabase: {
+        default: DefaultDatabaseBuilder;
+    };
+    constructor(options: ApplicationInput);
+    with(options: Partial<Omit<ApplicationInput, 'name'>>): this;
+    expression(name: string, jsonata: string | Expression | Record<string, unknown>): this;
+    readonly addTab: (options: import("./application.tab.js").ApplicationTabInput) => ApplicationTabBuilder;
+    readonly addAction: (options: import("../action/action-definition.builder.ts").ActionDefinitionBuilderInput) => ActionDefinitionBuilder;
+    get name(): ApplicationName;
+    metadata(key: string, value: unknown): this;
+    getStateRef(key: string): string;
+    getExpressionRef(name: string): string;
+    getExpression(name: string): Expression | Record<string, unknown> | undefined;
+    script(name: string, script: unknown): this;
+    translation(locale: string, translations: unknown): this;
+    onTableChanged(listener: unknown): this;
+    themePalette(palette: unknown): this;
+    images(...images: string[]): this;
+    icons(...icons: IconName[]): this;
+    readonly onLoad: import("../action/ja.in-background.factory.js").ActionInBackgroundBuilders;
+    readonly onFocus: import("../action/ja.in-background.factory.js").ActionInBackgroundBuilders;
+    readonly onRefresh: import("../action/ja.in-background.factory.js").ActionInBackgroundBuilders;
+    _validate(): void;
+    build(): Application;
+    private registerRequiredTables;
+    toJSON(options?: {
+        indent?: number;
+        sortKeys?: boolean;
+    }): string;
+    toYAML(): string;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"application.sdk.d.ts","sourceRoot":"","sources":["../../src/application/application.sdk.ts"],"names":[],"mappings":"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","sourcesContent":["import * as YAML from 'yaml'\nimport {\n  type ApplicationName,\n  BaseBuilder,\n  type BooleanOrExpression,\n  buildTree,\n  type Category,\n  type Expression,\n  toApplicationName,\n  toExpression,\n} from '../abstract/index.js'\nimport { ActionDefinitionBuilder } from '../action/index.js'\nimport { createActionInBackgroundBuildersFactory } from '../action/ja.in-background.factory.js'\nimport { DefaultDatabaseBuilder } from '../database/index.js'\nimport {\n  SqliteDatasourceBuilder,\n  StaticDatasourceBuilder,\n  SystemDatasourceBuilder,\n} from '../datasource/index.js'\nimport { RestFunctionBuilder } from '../function/function.rest.js'\nimport { SqlFunctionBuilder } from '../function/function.sql.js'\nimport { SoapFunctionBuilder } from '../function/function.soap.js'\nimport { assignBuilderByInputFactory, createBuilderFactory } from '../abstract/sdk.types.js'\nimport { type IconName } from '../icon/index.js'\nimport {\n  CalendarScreenBuilder,\n  DefaultScreenBuilder,\n  DocumentScreenBuilder,\n  DynamicGridScreenBuilder,\n  FullScreenBuilder,\n  GalleryScreenBuilder,\n  ListScreenBuilder,\n  type ScreenBuilder,\n  StaticGridScreenBuilder,\n  TabsScreenBuilder,\n  WizardScreenBuilder,\n} from '../screen/index.js'\nimport { sortObject } from '../utils/index.js'\nimport { ApplicationTabBuilder } from './application.tab.js'\n\n/**\n * Built application output. Intentionally unstructured: `buildTree()` produces\n * plain objects, so no field-level contract is maintained here.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type Application = Record<string, any>\n\n/**\n * Current runtime schema version. Keep in sync with mobile-runtime.\n */\nexport const RUNTIME_SCHEMA_VERSION = 7\n\nexport interface ApplicationInput {\n  readonly name: string | ApplicationName\n  readonly title?: string\n  readonly description?: string\n  readonly category?: Category\n  readonly type?: string\n  readonly imageUrl?: string\n  readonly state?: unknown\n  readonly permissions?: unknown\n  readonly dependencies?: unknown\n  readonly profile?: {\n    readonly isPersonalInfoMenuItemVisible?: BooleanOrExpression\n    readonly children: unknown[]\n  }\n}\n\n/**\n * Build Jigx application configurations.\n * @alias SolutionBuilder\n * Create complete app packages with screens, data sources, functions, and databases.\n * Applications appear in Jigx app home hub.\n *\n * Required: name (lowercase, 2-50 chars), title (unique), category.\n * Components: jigs, datasources, functions, databases, tabs, expressions, actions.\n */\nexport class ApplicationBuilder extends BaseBuilder {\n  protected readonly _config: Record<string, unknown> = {\n    functions: {},\n    datasources: {},\n    databases: { default: new DefaultDatabaseBuilder() },\n    jigs: {},\n    actions: {},\n  }\n\n  /**\n   * Factory for creating datasources in Jigx applications.\n   *\n   * Datasource types:\n   * - **sqlite**: Local database, optional cloud sync\n   * - **static**: Embedded JSON at build time\n   * - **system**: Read-only system data (country flags)\n   *\n   * @see {@link SqliteDatasourceBuilder}\n   * @see {@link StaticDatasourceBuilder}\n   * @see {@link SystemDatasourceBuilder}\n   */\n  readonly addDatasource = {\n    sqlite: assignBuilderByInputFactory(\n      SqliteDatasourceBuilder,\n      'datasourceId',\n      this._config.datasources as Record<string, unknown>,\n    ),\n    static: assignBuilderByInputFactory(\n      StaticDatasourceBuilder,\n      'datasourceId',\n      this._config.datasources as Record<string, unknown>,\n    ),\n    system: assignBuilderByInputFactory(\n      SystemDatasourceBuilder,\n      'datasourceId',\n      this._config.datasources as Record<string, unknown>,\n    ),\n  }\n\n  /**\n   * Factory for creating functions in Jigx applications.\n   *\n   * Function types:\n   * - **rest**: HTTP API calls, JSON/XML, auth, pagination\n   * - **sql**: Azure SQL queries, stored procedures\n   * - **soap**: XML web services, WSDL-based\n   *\n   * @see {@link RestFunctionBuilder}\n   * @see {@link SqlFunctionBuilder}\n   * @see {@link SoapFunctionBuilder}\n   */\n  readonly addFunction = {\n    rest: assignBuilderByInputFactory(\n      RestFunctionBuilder,\n      'functionId',\n      this._config.functions as Record<string, unknown>,\n    ),\n    sql: assignBuilderByInputFactory(\n      SqlFunctionBuilder,\n      'functionId',\n      this._config.functions as Record<string, unknown>,\n    ),\n    soap: assignBuilderByInputFactory(\n      SoapFunctionBuilder,\n      'functionId',\n      this._config.functions as Record<string, unknown>,\n    ),\n  }\n\n  /**\n   * Factory for creating screens (jigs) in Jigx applications.\n   *\n   * Screen types:\n   * - **list**: Scrollable lists. Templates, sections, search\n   * - **staticGrid**: Static responsive grids\n   * - **dynamicGrid**: Data-driven responsive grids\n   * - **default**: Forms, mixed content container\n   * - **calendar**: Events. Month/week/day views\n   * - **document**: PDF/HTML viewer. Zoom, download\n   * - **fullScreen**: Maps, chat, immersive UI\n   * - **tabs**: Tab navigation between screens\n   * - **wizard**: Multi-step workflows\n   *\n   * @see {@link ListScreenBuilder}\n   * @see {@link StaticGridScreenBuilder}\n   * @see {@link DynamicGridScreenBuilder}\n   * @see {@link DefaultScreenBuilder}\n   * @see {@link CalendarScreenBuilder}\n   * @see {@link DocumentScreenBuilder}\n   * @see {@link FullScreenBuilder}\n   * @see {@link TabsScreenBuilder}\n   * @see {@link WizardScreenBuilder}\n   */\n  readonly addScreen = {\n    calendar: assignBuilderByInputFactory(\n      CalendarScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    default: assignBuilderByInputFactory(\n      DefaultScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    document: assignBuilderByInputFactory(\n      DocumentScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    fullScreen: assignBuilderByInputFactory(\n      FullScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    staticGrid: assignBuilderByInputFactory(\n      StaticGridScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    dynamicGrid: assignBuilderByInputFactory(\n      DynamicGridScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    gallery: assignBuilderByInputFactory(\n      GalleryScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    list: assignBuilderByInputFactory(\n      ListScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    tabs: assignBuilderByInputFactory(\n      TabsScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    wizard: assignBuilderByInputFactory(\n      WizardScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    screens: this._config.jigs as Record<string, ScreenBuilder>,\n  }\n\n  /**\n   * Factory for configuring the application's local SQLite database.\n   *\n   * Every application has a default database for storing local data.\n   * Use this to define tables that will be created automatically.\n   */\n  readonly addDatabase = {\n    default: (this._config.databases as { default: DefaultDatabaseBuilder }).default,\n  }\n\n  /**\n   * Create application builder with validated parameters.\n   *\n   * @param options.name - Unique identifier. Lowercase 2-50, prefer kebab-case, starts alpha, ends alphanum.\n   * @param options.title - Display title shown in Jigx home hub (defaults to name)\n   * @param options.description - Explains application purpose\n   * @param options.category - Classification for organizing solutions (defaults to 'miscellaneous')\n   *\n   * @throws {Error} When name doesn't match required pattern\n   */\n  constructor(options: ApplicationInput) {\n    super()\n    const { name } = options\n    this._config.name = toApplicationName(name)\n    this._config.title = options.title || name\n    this._config.category = 'miscellaneous'\n    this._config.runtimeSchemaVersion = RUNTIME_SCHEMA_VERSION\n    this.with(options)\n  }\n\n  /**\n   * Update application configuration fields.\n   *\n   * @param options - Partial application input (name is excluded, set only in constructor)\n   */\n  with(options: Partial<Omit<ApplicationInput, 'name'>>): this {\n    if (options.title !== undefined) this._config.title = options.title\n    if (options.description !== undefined) this._config.description = options.description\n    if (options.category !== undefined) this._config.category = options.category\n    if (options.type !== undefined) this._config.type = options.type\n    if (options.imageUrl !== undefined) this._config.imageUrl = options.imageUrl\n    if (options.state !== undefined) this._config.state = options.state\n    if (options.permissions !== undefined) this._config.permissions = options.permissions\n    if (options.dependencies !== undefined) this._config.dependencies = options.dependencies\n    if (options.profile !== undefined) this._config.profile = options.profile\n    return this\n  }\n\n  /**\n   * Add a reusable JSONata expression to the application.\n   *\n   * Expressions can be referenced throughout the application using the syntax\n   * `=@ctx.solution.expressions.{name}`. This promotes code reuse and\n   * maintainability.\n   *\n   * @param name - Expression identifier\n   * @param jsonata - JSONata expression (with or without leading =)\n   * @returns This builder for chaining\n   */\n  expression(name: string, jsonata: string | Expression | Record<string, unknown>): this {\n    if (!this._config.expressions) this._config.expressions = {}\n    const expressions = this._config.expressions as Record<\n      string,\n      Expression | Record<string, unknown>\n    >\n    if (typeof jsonata === 'object') {\n      expressions[name] = jsonata\n    } else {\n      expressions[name] = toExpression(jsonata)\n    }\n    return this\n  }\n\n  /**\n   * Configure home screen tabs for organizing content.\n   *\n   * Tabs provide navigation at the top of the application's home screen.\n   * This is the modern replacement for the deprecated widgets approach.\n   *\n   * @param options - Tab configuration\n   * @param options.screenId - Screen to navigate to when selected\n   * @param options.icon - Icon name or expression\n   * @param options.tabId - Optional tab key. Defaults to `screenId`.\n   * @param options.label - Optional label text\n   * @param options.badge - Optional badge indicator\n   * @param options.when - Optional visibility condition\n   */\n  readonly addTab = createBuilderFactory(ApplicationTabBuilder, (builder) => {\n    if (!this._config.tabs) this._config.tabs = {}\n    ;(this._config.tabs as Record<string, unknown>)[builder.tabId] = builder\n  })\n\n  /**\n   * Create **global** action definition reusable across jigs.\n   * Actions created here can be referenced throughout the application.\n   */\n  readonly addAction = assignBuilderByInputFactory(\n    ActionDefinitionBuilder,\n    'actionId',\n    this._config.actions as Record<string, unknown>,\n  )\n\n  /**\n   * Consider using @ctx.solution.name instead.\n   */\n  get name(): ApplicationName {\n    return this._config.name as ApplicationName\n  }\n\n  /**\n   * Add metadata\n   */\n  metadata(key: string, value: unknown): this {\n    if (!this._config.metadata) this._config.metadata = {}\n    ;(this._config.metadata as Record<string, unknown>)[key] = value\n    return this\n  }\n\n  getStateRef(key: string): string {\n    // TODO: validate key,  how?\n    return `@ctx.solution.state.${key}`\n  }\n\n  getExpressionRef(name: string): string {\n    // TODO: validate name, how?\n    return `@ctx.expressions.${name}`\n  }\n\n  /**\n   * Get a registered expression value by name.\n   * @param name - Expression identifier\n   * @returns The expression value, or undefined if not registered\n   */\n  getExpression(name: string): Expression | Record<string, unknown> | undefined {\n    const expressions = this._config.expressions as\n      | Record<string, Expression | Record<string, unknown>>\n      | undefined\n    return expressions?.[name]\n  }\n\n  /**\n   * Add custom script (reserved for future use)\n   * @param name - Script name/identifier\n   * @param script - Script content or configuration\n   */\n  script(name: string, script: unknown): this {\n    if (!this._config.scripts) this._config.scripts = {}\n    ;(this._config.scripts as Record<string, unknown>)[name] = script\n    return this\n  }\n\n  /**\n   * Add internationalization translation\n   * @param locale - Locale identifier (e.g., 'en', 'es', 'fr')\n   * @param translations - Translation key-value pairs\n   */\n  translation(locale: string, translations: unknown): this {\n    if (!this._config.translations) this._config.translations = {}\n    ;(this._config.translations as Record<string, unknown>)[locale] = translations\n    return this\n  }\n\n  /**\n   * Add database table change listener\n   * @param listener - Table change listener configuration\n   */\n  onTableChanged(listener: unknown): this {\n    if (!this._config.onTableChanged) this._config.onTableChanged = []\n    ;(this._config.onTableChanged as unknown[]).push(listener)\n    return this\n  }\n\n  /**\n   * Configure theme palette for the application\n   * @param palette - Color palette definition\n   */\n  themePalette(palette: unknown): this {\n    if (!this._config.assets) this._config.assets = {}\n    const assets = this._config.assets as Record<string, unknown>\n    if (!assets.theme) assets.theme = {}\n    ;(assets.theme as Record<string, unknown>).palette = palette\n    return this\n  }\n\n  /**\n   * Add image URLs to the application assets\n   * @param images - Array of image URLs\n   */\n  images(...images: string[]): this {\n    if (!this._config.assets) this._config.assets = {}\n    const assets = this._config.assets as Record<string, unknown>\n    if (!assets.images) assets.images = []\n    ;(assets.images as string[]).push(...images)\n    return this\n  }\n\n  /**\n   * Add icon references to the application assets\n   * @param icons - Array of icon names\n   */\n  icons(...icons: IconName[]): this {\n    if (!this._config.assets) this._config.assets = {}\n    const assets = this._config.assets as Record<string, unknown>\n    if (!assets.icons) assets.icons = []\n    ;(assets.icons as IconName[]).push(...icons)\n    return this\n  }\n\n  /**\n   * Action executed when application loads.\n   */\n  readonly onLoad = createActionInBackgroundBuildersFactory((action) => {\n    this._config.onLoad = action\n  })\n\n  /**\n   * Action executed when application gains focus.\n   */\n  readonly onFocus = createActionInBackgroundBuildersFactory((action) => {\n    this._config.onFocus = action\n  })\n\n  /**\n   * Action executed on pull-to-refresh.\n   */\n  readonly onRefresh = createActionInBackgroundBuildersFactory((action) => {\n    this._config.onRefresh = action\n  })\n\n  /**\n   * Validate the application configuration including all screens.\n   *\n   * This method should be called before build() to ensure the application\n   * configuration is valid. It iterates through all screens and calls their\n   * _validate() methods.\n   *\n   * @throws {Error} When validation fails\n   */\n  _validate(): void {\n    const screens = this._config.jigs as Record<string, ScreenBuilder>\n    for (const screen of Object.values(screens)) {\n      screen._validate()\n    }\n  }\n\n  /**\n   * Build and return the application configuration.\n   */\n  build(): Application {\n    this._validate()\n\n    // Register dynamic tables on default database before building\n    this.registerRequiredTables()\n\n    // Extract scripts for special transformation (scripts -> { expressions: scripts })\n    const { scripts, ...configRest } = this._config\n    const scriptOutput =\n      scripts && Object.keys(scripts as object).length > 0\n        ? { expressions: { ...(scripts as object) } }\n        : undefined\n\n    return {\n      ...buildTree(configRest),\n      ...(scriptOutput ? { scripts: scriptOutput } : {}),\n    }\n  }\n\n  /**\n   * Scan all datasources (app-level and screen-level) for dynamic sqlite\n   * entities and register their required tables on the default database.\n   */\n  private registerRequiredTables(): void {\n    const db = this.addDatabase.default\n\n    const registerFromDatasources = (datasources: Record<string, unknown>): void => {\n      for (const ds of Object.values(datasources)) {\n        if (ds instanceof SqliteDatasourceBuilder) {\n          for (const table of ds.getRequiredTables()) {\n            db.table(table)\n          }\n        }\n      }\n    }\n\n    // App-level datasources\n    registerFromDatasources(this._config.datasources as Record<string, unknown>)\n\n    // Screen-level datasources\n    const screens = this._config.jigs as Record<string, ScreenBuilder>\n    for (const screen of Object.values(screens)) {\n      for (const table of screen.collectRequiredTables()) {\n        db.table(table)\n      }\n    }\n  }\n\n  /**\n   * Convert to JSON string with formatting options\n   */\n  toJSON(options?: { indent?: number; sortKeys?: boolean }): string {\n    const { indent = 2, sortKeys = false } = options || {}\n    const obj = this.build()\n    const data = sortKeys ? sortObject(obj) : obj\n    return JSON.stringify(data, null, indent)\n  }\n\n  /**\n   * Convert to YAML string\n   */\n  toYAML(): string {\n    return YAML.stringify(this.build())\n  }\n}\n"]}

package/dist/application/application.sdk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"application.sdk.d.ts","sourceRoot":"","sources":["../../src/application/application.sdk.ts"],"names":[],"mappings":"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","sourcesContent":["import * as YAML from 'yaml'\nimport {\n  type ApplicationName,\n  BaseBuilder,\n  type BooleanOrExpression,\n  buildTree,\n  type Category,\n  type Expression,\n  toApplicationName,\n  toExpression,\n} from '../abstract/index.js'\nimport { ActionDefinitionBuilder } from '../action/index.js'\nimport { createActionInBackgroundBuildersFactory } from '../action/ja.in-background.factory.js'\nimport { DefaultDatabaseBuilder } from '../database/index.js'\nimport {\n  SqliteDatasourceBuilder,\n  StaticDatasourceBuilder,\n  SystemDatasourceBuilder,\n} from '../datasource/index.js'\nimport { RestFunctionBuilder } from '../function/function.rest.js'\nimport { SqlFunctionBuilder } from '../function/function.sql.js'\nimport { SoapFunctionBuilder } from '../function/function.soap.js'\nimport { assignBuilderByInputFactory, createBuilderFactory } from '../abstract/sdk.types.js'\nimport { type IconName } from '../icon/index.js'\nimport {\n  CalendarScreenBuilder,\n  DefaultScreenBuilder,\n  DocumentScreenBuilder,\n  DynamicGridScreenBuilder,\n  FullScreenBuilder,\n  GalleryScreenBuilder,\n  ListScreenBuilder,\n  type ScreenBuilder,\n  StaticGridScreenBuilder,\n  TabsScreenBuilder,\n  WizardScreenBuilder,\n} from '../screen/index.js'\nimport { sortObject } from '../utils/index.js'\nimport { ApplicationTabBuilder } from './application.tab.js'\n\n/**\n * Built application output. Intentionally unstructured: `buildTree()` produces\n * plain objects, so no field-level contract is maintained here.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type Application = Record<string, any>\n\n/**\n * Current runtime schema version. Keep in sync with mobile-runtime.\n */\nexport const RUNTIME_SCHEMA_VERSION = 7\n\nexport interface ApplicationInput {\n  readonly name: string | ApplicationName\n  readonly title?: string\n  readonly description?: string\n  readonly category?: Category\n  readonly type?: string\n  readonly imageUrl?: string\n  readonly state?: unknown\n  readonly permissions?: unknown\n  readonly dependencies?: unknown\n  readonly profile?: {\n    readonly isPersonalInfoMenuItemVisible?: BooleanOrExpression\n    readonly children: unknown[]\n  }\n}\n\n/**\n * Build Jigx application configurations.\n * @alias SolutionBuilder\n * Create complete app packages with screens, data sources, functions, and databases.\n * Applications appear in Jigx app home hub.\n *\n * Required: name (lowercase, 2-50 chars), title (unique), category.\n * Components: jigs, datasources, functions, databases, tabs, expressions, actions.\n */\nexport class ApplicationBuilder extends BaseBuilder {\n  protected readonly _config: Record<string, unknown> = {\n    functions: {},\n    datasources: {},\n    databases: { default: new DefaultDatabaseBuilder() },\n    jigs: {},\n    actions: {},\n  }\n\n  /**\n   * Factory for creating datasources in Jigx applications.\n   *\n   * Datasource types:\n   * - **sqlite**: Local database, optional cloud sync\n   * - **static**: Embedded JSON at build time\n   * - **system**: Read-only system data (country flags)\n   *\n   * @see {@link SqliteDatasourceBuilder}\n   * @see {@link StaticDatasourceBuilder}\n   * @see {@link SystemDatasourceBuilder}\n   */\n  readonly addDatasource = {\n    sqlite: assignBuilderByInputFactory(\n      SqliteDatasourceBuilder,\n      'datasourceId',\n      this._config.datasources as Record<string, unknown>,\n    ),\n    static: assignBuilderByInputFactory(\n      StaticDatasourceBuilder,\n      'datasourceId',\n      this._config.datasources as Record<string, unknown>,\n    ),\n    system: assignBuilderByInputFactory(\n      SystemDatasourceBuilder,\n      'datasourceId',\n      this._config.datasources as Record<string, unknown>,\n    ),\n  }\n\n  /**\n   * Factory for creating functions in Jigx applications.\n   *\n   * Function types:\n   * - **rest**: HTTP API calls, JSON/XML, auth, pagination\n   * - **sql**: Azure SQL queries, stored procedures\n   * - **soap**: XML web services, WSDL-based\n   *\n   * @see {@link RestFunctionBuilder}\n   * @see {@link SqlFunctionBuilder}\n   * @see {@link SoapFunctionBuilder}\n   */\n  readonly addFunction = {\n    rest: assignBuilderByInputFactory(\n      RestFunctionBuilder,\n      'functionId',\n      this._config.functions as Record<string, unknown>,\n    ),\n    sql: assignBuilderByInputFactory(\n      SqlFunctionBuilder,\n      'functionId',\n      this._config.functions as Record<string, unknown>,\n    ),\n    soap: assignBuilderByInputFactory(\n      SoapFunctionBuilder,\n      'functionId',\n      this._config.functions as Record<string, unknown>,\n    ),\n  }\n\n  /**\n   * Factory for creating screens (jigs) in Jigx applications.\n   *\n   * Screen types:\n   * - **list**: Scrollable lists. Templates, sections, search\n   * - **staticGrid**: Static responsive grids\n   * - **dynamicGrid**: Data-driven responsive grids\n   * - **default**: Forms, mixed content container\n   * - **calendar**: Events. Month/week/day views\n   * - **document**: PDF/HTML viewer. Zoom, download\n   * - **fullScreen**: Maps, chat, immersive UI\n   * - **tabs**: Tab navigation between screens\n   * - **wizard**: Multi-step workflows\n   *\n   * @see {@link ListScreenBuilder}\n   * @see {@link StaticGridScreenBuilder}\n   * @see {@link DynamicGridScreenBuilder}\n   * @see {@link DefaultScreenBuilder}\n   * @see {@link CalendarScreenBuilder}\n   * @see {@link DocumentScreenBuilder}\n   * @see {@link FullScreenBuilder}\n   * @see {@link TabsScreenBuilder}\n   * @see {@link WizardScreenBuilder}\n   */\n  readonly addScreen = {\n    calendar: assignBuilderByInputFactory(\n      CalendarScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    default: assignBuilderByInputFactory(\n      DefaultScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    document: assignBuilderByInputFactory(\n      DocumentScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    fullScreen: assignBuilderByInputFactory(\n      FullScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    staticGrid: assignBuilderByInputFactory(\n      StaticGridScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    dynamicGrid: assignBuilderByInputFactory(\n      DynamicGridScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    gallery: assignBuilderByInputFactory(\n      GalleryScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    list: assignBuilderByInputFactory(\n      ListScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    tabs: assignBuilderByInputFactory(\n      TabsScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    wizard: assignBuilderByInputFactory(\n      WizardScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    screens: this._config.jigs as Record<string, ScreenBuilder>,\n  }\n\n  /**\n   * Factory for configuring the application's local SQLite database.\n   *\n   * Every application has a default database for storing local data.\n   * Use this to define tables that will be created automatically.\n   */\n  readonly addDatabase = {\n    default: (this._config.databases as { default: DefaultDatabaseBuilder }).default,\n  }\n\n  /**\n   * Create application builder with validated parameters.\n   *\n   * @param options.name - Unique identifier. Lowercase 2-50, prefer kebab-case, starts alpha, ends alphanum.\n   * @param options.title - Display title shown in Jigx home hub (defaults to name)\n   * @param options.description - Explains application purpose\n   * @param options.category - Classification for organizing solutions (defaults to 'miscellaneous')\n   *\n   * @throws {Error} When name doesn't match required pattern\n   */\n  constructor(options: ApplicationInput) {\n    super()\n    const { name } = options\n    this._config.name = toApplicationName(name)\n    this._config.title = options.title || name\n    this._config.category = 'miscellaneous'\n    this._config.runtimeSchemaVersion = RUNTIME_SCHEMA_VERSION\n    this.with(options)\n  }\n\n  /**\n   * Update application configuration fields.\n   *\n   * @param options - Partial application input (name is excluded, set only in constructor)\n   */\n  with(options: Partial<Omit<ApplicationInput, 'name'>>): this {\n    if (options.title !== undefined) this._config.title = options.title\n    if (options.description !== undefined) this._config.description = options.description\n    if (options.category !== undefined) this._config.category = options.category\n    if (options.type !== undefined) this._config.type = options.type\n    if (options.imageUrl !== undefined) this._config.imageUrl = options.imageUrl\n    if (options.state !== undefined) this._config.state = options.state\n    if (options.permissions !== undefined) this._config.permissions = options.permissions\n    if (options.dependencies !== undefined) this._config.dependencies = options.dependencies\n    if (options.profile !== undefined) this._config.profile = options.profile\n    return this\n  }\n\n  /**\n   * Add a reusable JSONata expression to the application.\n   *\n   * Expressions can be referenced throughout the application using the syntax\n   * `=@ctx.solution.expressions.{name}`. This promotes code reuse and\n   * maintainability.\n   *\n   * @param name - Expression identifier\n   * @param jsonata - JSONata expression (with or without leading =)\n   * @returns This builder for chaining\n   */\n  expression(name: string, jsonata: string | Expression | Record<string, unknown>): this {\n    if (!this._config.expressions) this._config.expressions = {}\n    const expressions = this._config.expressions as Record<\n      string,\n      Expression | Record<string, unknown>\n    >\n    if (typeof jsonata === 'object') {\n      expressions[name] = jsonata\n    } else {\n      expressions[name] = toExpression(jsonata)\n    }\n    return this\n  }\n\n  /**\n   * Configure home screen tabs for organizing content.\n   *\n   * Tabs provide navigation at the top of the application's home screen.\n   * This is the modern replacement for the deprecated widgets approach.\n   *\n   * @param options - Tab configuration\n   * @param options.screenId - Screen to navigate to when selected\n   * @param options.icon - Icon name or expression\n   * @param options.tabId - Optional tab key. Defaults to `screenId`.\n   * @param options.label - Optional label text\n   * @param options.badge - Optional badge indicator\n   * @param options.when - Optional visibility condition\n   */\n  readonly addTab = createBuilderFactory(ApplicationTabBuilder, (builder) => {\n    if (!this._config.tabs) this._config.tabs = {}\n    ;(this._config.tabs as Record<string, unknown>)[builder.tabId] = builder\n  })\n\n  /**\n   * Create **global** action definition reusable across jigs.\n   * Actions created here can be referenced throughout the application.\n   */\n  readonly addAction = assignBuilderByInputFactory(\n    ActionDefinitionBuilder,\n    'actionId',\n    this._config.actions as Record<string, unknown>,\n  )\n\n  /**\n   * Consider using @ctx.solution.name instead.\n   */\n  get name(): ApplicationName {\n    return this._config.name as ApplicationName\n  }\n\n  /**\n   * Add metadata\n   */\n  metadata(key: string, value: unknown): this {\n    if (!this._config.metadata) this._config.metadata = {}\n    ;(this._config.metadata as Record<string, unknown>)[key] = value\n    return this\n  }\n\n  getStateRef(key: string): string {\n    // TODO: validate key,  how?\n    return `@ctx.solution.state.${key}`\n  }\n\n  getExpressionRef(name: string): string {\n    // TODO: validate name, how?\n    return `@ctx.expressions.${name}`\n  }\n\n  /**\n   * Get a registered expression value by name.\n   * @param name - Expression identifier\n   * @returns The expression value, or undefined if not registered\n   */\n  getExpression(name: string): Expression | Record<string, unknown> | undefined {\n    const expressions = this._config.expressions as\n      | Record<string, Expression | Record<string, unknown>>\n      | undefined\n    return expressions?.[name]\n  }\n\n  /**\n   * Add custom script (reserved for future use)\n   * @param name - Script name/identifier\n   * @param script - Script content or configuration\n   */\n  script(name: string, script: unknown): this {\n    if (!this._config.scripts) this._config.scripts = {}\n    ;(this._config.scripts as Record<string, unknown>)[name] = script\n    return this\n  }\n\n  /**\n   * Add internationalization translation\n   * @param locale - Locale identifier (e.g., 'en', 'es', 'fr')\n   * @param translations - Translation key-value pairs\n   */\n  translation(locale: string, translations: unknown): this {\n    if (!this._config.translations) this._config.translations = {}\n    ;(this._config.translations as Record<string, unknown>)[locale] = translations\n    return this\n  }\n\n  /**\n   * Add database table change listener\n   * @param listener - Table change listener configuration\n   */\n  onTableChanged(listener: unknown): this {\n    if (!this._config.onTableChanged) this._config.onTableChanged = []\n    ;(this._config.onTableChanged as unknown[]).push(listener)\n    return this\n  }\n\n  /**\n   * Configure theme palette for the application\n   * @param palette - Color palette definition\n   */\n  themePalette(palette: unknown): this {\n    if (!this._config.assets) this._config.assets = {}\n    const assets = this._config.assets as Record<string, unknown>\n    if (!assets.theme) assets.theme = {}\n    ;(assets.theme as Record<string, unknown>).palette = palette\n    return this\n  }\n\n  /**\n   * Add image URLs to the application assets\n   * @param images - Array of image URLs\n   */\n  images(...images: string[]): this {\n    if (!this._config.assets) this._config.assets = {}\n    const assets = this._config.assets as Record<string, unknown>\n    if (!assets.images) assets.images = []\n    ;(assets.images as string[]).push(...images)\n    return this\n  }\n\n  /**\n   * Add icon references to the application assets\n   * @param icons - Array of icon names\n   */\n  icons(...icons: IconName[]): this {\n    if (!this._config.assets) this._config.assets = {}\n    const assets = this._config.assets as Record<string, unknown>\n    if (!assets.icons) assets.icons = []\n    ;(assets.icons as IconName[]).push(...icons)\n    return this\n  }\n\n  /**\n   * Action executed when application loads.\n   */\n  readonly onLoad = createActionInBackgroundBuildersFactory((action) => {\n    this._config.onLoad = action\n  })\n\n  /**\n   * Action executed when application gains focus.\n   */\n  readonly onFocus = createActionInBackgroundBuildersFactory((action) => {\n    this._config.onFocus = action\n  })\n\n  /**\n   * Action executed on pull-to-refresh.\n   */\n  readonly onRefresh = createActionInBackgroundBuildersFactory((action) => {\n    this._config.onRefresh = action\n  })\n\n  /**\n   * Validate the application configuration including all screens.\n   *\n   * This method should be called before build() to ensure the application\n   * configuration is valid. It iterates through all screens and calls their\n   * _validate() methods.\n   *\n   * @throws {Error} When validation fails\n   */\n  _validate(): void {\n    const screens = this._config.jigs as Record<string, ScreenBuilder>\n    for (const screen of Object.values(screens)) {\n      screen._validate()\n    }\n  }\n\n  /**\n   * Build and return the application configuration.\n   */\n  build(): Application {\n    this._validate()\n\n    // Register dynamic tables on default database before building\n    this.registerRequiredTables()\n\n    // Extract scripts for special transformation (scripts -> { expressions: scripts })\n    const { scripts, ...configRest } = this._config\n    const scriptOutput =\n      scripts && Object.keys(scripts as object).length > 0\n        ? { expressions: { ...(scripts as object) } }\n        : undefined\n\n    return {\n      ...buildTree(configRest),\n      ...(scriptOutput ? { scripts: scriptOutput } : {}),\n    }\n  }\n\n  /**\n   * Scan all datasources (app-level and screen-level) for dynamic sqlite\n   * entities and register their required tables on the default database.\n   */\n  private registerRequiredTables(): void {\n    const db = this.addDatabase.default\n\n    const registerFromDatasources = (datasources: Record<string, unknown>): void => {\n      for (const ds of Object.values(datasources)) {\n        if (ds instanceof SqliteDatasourceBuilder) {\n          for (const table of ds.getRequiredTables()) {\n            db.table(table)\n          }\n        }\n      }\n    }\n\n    // App-level datasources\n    registerFromDatasources(this._config.datasources as Record<string, unknown>)\n\n    // Screen-level datasources\n    const screens = this._config.jigs as Record<string, ScreenBuilder>\n    for (const screen of Object.values(screens)) {\n      for (const table of screen.collectRequiredTables()) {\n        db.table(table)\n      }\n    }\n  }\n\n  /**\n   * Convert to JSON string with formatting options\n   */\n  toJSON(options?: { indent?: number; sortKeys?: boolean }): string {\n    const { indent = 2, sortKeys = false } = options || {}\n    const obj = this.build()\n    const data = sortKeys ? sortObject(obj) : obj\n    return JSON.stringify(data, null, indent)\n  }\n\n  /**\n   * Convert to YAML string\n   */\n  toYAML(): string {\n    return YAML.stringify(this.build())\n  }\n}\n"]}

package/dist/application/application.sdk.js

@@ -0,0 +1,217 @@
+import * as YAML from 'yaml';
+import { BaseBuilder, buildTree, toApplicationName, toExpression, } from '../abstract/index.js';
+import { ActionDefinitionBuilder } from '../action/index.js';
+import { createActionInBackgroundBuildersFactory } from '../action/ja.in-background.factory.js';
+import { DefaultDatabaseBuilder } from '../database/index.js';
+import { SqliteDatasourceBuilder, StaticDatasourceBuilder, SystemDatasourceBuilder, } from '../datasource/index.js';
+import { RestFunctionBuilder } from '../function/function.rest.js';
+import { SqlFunctionBuilder } from '../function/function.sql.js';
+import { SoapFunctionBuilder } from '../function/function.soap.js';
+import { assignBuilderByInputFactory, createBuilderFactory } from '../abstract/sdk.types.js';
+import { CalendarScreenBuilder, DefaultScreenBuilder, DocumentScreenBuilder, DynamicGridScreenBuilder, FullScreenBuilder, GalleryScreenBuilder, ListScreenBuilder, StaticGridScreenBuilder, TabsScreenBuilder, WizardScreenBuilder, } from '../screen/index.js';
+import { sortObject } from '../utils/index.js';
+import { ApplicationTabBuilder } from './application.tab.js';
+export const RUNTIME_SCHEMA_VERSION = 7;
+export class ApplicationBuilder extends BaseBuilder {
+    _config = {
+        functions: {},
+        datasources: {},
+        databases: { default: new DefaultDatabaseBuilder() },
+        jigs: {},
+        actions: {},
+    };
+    addDatasource = {
+        sqlite: assignBuilderByInputFactory(SqliteDatasourceBuilder, 'datasourceId', this._config.datasources),
+        static: assignBuilderByInputFactory(StaticDatasourceBuilder, 'datasourceId', this._config.datasources),
+        system: assignBuilderByInputFactory(SystemDatasourceBuilder, 'datasourceId', this._config.datasources),
+    };
+    addFunction = {
+        rest: assignBuilderByInputFactory(RestFunctionBuilder, 'functionId', this._config.functions),
+        sql: assignBuilderByInputFactory(SqlFunctionBuilder, 'functionId', this._config.functions),
+        soap: assignBuilderByInputFactory(SoapFunctionBuilder, 'functionId', this._config.functions),
+    };
+    addScreen = {
+        calendar: assignBuilderByInputFactory(CalendarScreenBuilder, 'screenId', this._config.jigs),
+        default: assignBuilderByInputFactory(DefaultScreenBuilder, 'screenId', this._config.jigs),
+        document: assignBuilderByInputFactory(DocumentScreenBuilder, 'screenId', this._config.jigs),
+        fullScreen: assignBuilderByInputFactory(FullScreenBuilder, 'screenId', this._config.jigs),
+        staticGrid: assignBuilderByInputFactory(StaticGridScreenBuilder, 'screenId', this._config.jigs),
+        dynamicGrid: assignBuilderByInputFactory(DynamicGridScreenBuilder, 'screenId', this._config.jigs),
+        gallery: assignBuilderByInputFactory(GalleryScreenBuilder, 'screenId', this._config.jigs),
+        list: assignBuilderByInputFactory(ListScreenBuilder, 'screenId', this._config.jigs),
+        tabs: assignBuilderByInputFactory(TabsScreenBuilder, 'screenId', this._config.jigs),
+        wizard: assignBuilderByInputFactory(WizardScreenBuilder, 'screenId', this._config.jigs),
+        screens: this._config.jigs,
+    };
+    addDatabase = {
+        default: this._config.databases.default,
+    };
+    constructor(options) {
+        super();
+        const { name } = options;
+        this._config.name = toApplicationName(name);
+        this._config.title = options.title || name;
+        this._config.category = 'miscellaneous';
+        this._config.runtimeSchemaVersion = RUNTIME_SCHEMA_VERSION;
+        this.with(options);
+    }
+    with(options) {
+        if (options.title !== undefined)
+            this._config.title = options.title;
+        if (options.description !== undefined)
+            this._config.description = options.description;
+        if (options.category !== undefined)
+            this._config.category = options.category;
+        if (options.type !== undefined)
+            this._config.type = options.type;
+        if (options.imageUrl !== undefined)
+            this._config.imageUrl = options.imageUrl;
+        if (options.state !== undefined)
+            this._config.state = options.state;
+        if (options.permissions !== undefined)
+            this._config.permissions = options.permissions;
+        if (options.dependencies !== undefined)
+            this._config.dependencies = options.dependencies;
+        if (options.profile !== undefined)
+            this._config.profile = options.profile;
+        return this;
+    }
+    expression(name, jsonata) {
+        if (!this._config.expressions)
+            this._config.expressions = {};
+        const expressions = this._config.expressions;
+        if (typeof jsonata === 'object') {
+            expressions[name] = jsonata;
+        }
+        else {
+            expressions[name] = toExpression(jsonata);
+        }
+        return this;
+    }
+    addTab = createBuilderFactory(ApplicationTabBuilder, (builder) => {
+        if (!this._config.tabs)
+            this._config.tabs = {};
+        this._config.tabs[builder.tabId] = builder;
+    });
+    addAction = assignBuilderByInputFactory(ActionDefinitionBuilder, 'actionId', this._config.actions);
+    get name() {
+        return this._config.name;
+    }
+    metadata(key, value) {
+        if (!this._config.metadata)
+            this._config.metadata = {};
+        this._config.metadata[key] = value;
+        return this;
+    }
+    getStateRef(key) {
+        return `@ctx.solution.state.${key}`;
+    }
+    getExpressionRef(name) {
+        return `@ctx.expressions.${name}`;
+    }
+    getExpression(name) {
+        const expressions = this._config.expressions;
+        return expressions?.[name];
+    }
+    script(name, script) {
+        if (!this._config.scripts)
+            this._config.scripts = {};
+        this._config.scripts[name] = script;
+        return this;
+    }
+    translation(locale, translations) {
+        if (!this._config.translations)
+            this._config.translations = {};
+        this._config.translations[locale] = translations;
+        return this;
+    }
+    onTableChanged(listener) {
+        if (!this._config.onTableChanged)
+            this._config.onTableChanged = [];
+        this._config.onTableChanged.push(listener);
+        return this;
+    }
+    themePalette(palette) {
+        if (!this._config.assets)
+            this._config.assets = {};
+        const assets = this._config.assets;
+        if (!assets.theme)
+            assets.theme = {};
+        assets.theme.palette = palette;
+        return this;
+    }
+    images(...images) {
+        if (!this._config.assets)
+            this._config.assets = {};
+        const assets = this._config.assets;
+        if (!assets.images)
+            assets.images = [];
+        assets.images.push(...images);
+        return this;
+    }
+    icons(...icons) {
+        if (!this._config.assets)
+            this._config.assets = {};
+        const assets = this._config.assets;
+        if (!assets.icons)
+            assets.icons = [];
+        assets.icons.push(...icons);
+        return this;
+    }
+    onLoad = createActionInBackgroundBuildersFactory((action) => {
+        this._config.onLoad = action;
+    });
+    onFocus = createActionInBackgroundBuildersFactory((action) => {
+        this._config.onFocus = action;
+    });
+    onRefresh = createActionInBackgroundBuildersFactory((action) => {
+        this._config.onRefresh = action;
+    });
+    _validate() {
+        const screens = this._config.jigs;
+        for (const screen of Object.values(screens)) {
+            screen._validate();
+        }
+    }
+    build() {
+        this._validate();
+        this.registerRequiredTables();
+        const { scripts, ...configRest } = this._config;
+        const scriptOutput = scripts && Object.keys(scripts).length > 0
+            ? { expressions: { ...scripts } }
+            : undefined;
+        return {
+            ...buildTree(configRest),
+            ...(scriptOutput ? { scripts: scriptOutput } : {}),
+        };
+    }
+    registerRequiredTables() {
+        const db = this.addDatabase.default;
+        const registerFromDatasources = (datasources) => {
+            for (const ds of Object.values(datasources)) {
+                if (ds instanceof SqliteDatasourceBuilder) {
+                    for (const table of ds.getRequiredTables()) {
+                        db.table(table);
+                    }
+                }
+            }
+        };
+        registerFromDatasources(this._config.datasources);
+        const screens = this._config.jigs;
+        for (const screen of Object.values(screens)) {
+            for (const table of screen.collectRequiredTables()) {
+                db.table(table);
+            }
+        }
+    }
+    toJSON(options) {
+        const { indent = 2, sortKeys = false } = options || {};
+        const obj = this.build();
+        const data = sortKeys ? sortObject(obj) : obj;
+        return JSON.stringify(data, null, indent);
+    }
+    toYAML() {
+        return YAML.stringify(this.build());
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"application.sdk.js","sourceRoot":"","sources":["../../src/application/application.sdk.ts"],"names":[],"mappings":"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","sourcesContent":["import * as YAML from 'yaml'\nimport {\n  type ApplicationName,\n  BaseBuilder,\n  type BooleanOrExpression,\n  buildTree,\n  type Category,\n  type Expression,\n  toApplicationName,\n  toExpression,\n} from '../abstract/index.js'\nimport { ActionDefinitionBuilder } from '../action/index.js'\nimport { createActionInBackgroundBuildersFactory } from '../action/ja.in-background.factory.js'\nimport { DefaultDatabaseBuilder } from '../database/index.js'\nimport {\n  SqliteDatasourceBuilder,\n  StaticDatasourceBuilder,\n  SystemDatasourceBuilder,\n} from '../datasource/index.js'\nimport { RestFunctionBuilder } from '../function/function.rest.js'\nimport { SqlFunctionBuilder } from '../function/function.sql.js'\nimport { SoapFunctionBuilder } from '../function/function.soap.js'\nimport { assignBuilderByInputFactory, createBuilderFactory } from '../abstract/sdk.types.js'\nimport { type IconName } from '../icon/index.js'\nimport {\n  CalendarScreenBuilder,\n  DefaultScreenBuilder,\n  DocumentScreenBuilder,\n  DynamicGridScreenBuilder,\n  FullScreenBuilder,\n  GalleryScreenBuilder,\n  ListScreenBuilder,\n  type ScreenBuilder,\n  StaticGridScreenBuilder,\n  TabsScreenBuilder,\n  WizardScreenBuilder,\n} from '../screen/index.js'\nimport { sortObject } from '../utils/index.js'\nimport { ApplicationTabBuilder } from './application.tab.js'\n\n/**\n * Built application output. Intentionally unstructured: `buildTree()` produces\n * plain objects, so no field-level contract is maintained here.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type Application = Record<string, any>\n\n/**\n * Current runtime schema version. Keep in sync with mobile-runtime.\n */\nexport const RUNTIME_SCHEMA_VERSION = 7\n\nexport interface ApplicationInput {\n  readonly name: string | ApplicationName\n  readonly title?: string\n  readonly description?: string\n  readonly category?: Category\n  readonly type?: string\n  readonly imageUrl?: string\n  readonly state?: unknown\n  readonly permissions?: unknown\n  readonly dependencies?: unknown\n  readonly profile?: {\n    readonly isPersonalInfoMenuItemVisible?: BooleanOrExpression\n    readonly children: unknown[]\n  }\n}\n\n/**\n * Build Jigx application configurations.\n * @alias SolutionBuilder\n * Create complete app packages with screens, data sources, functions, and databases.\n * Applications appear in Jigx app home hub.\n *\n * Required: name (lowercase, 2-50 chars), title (unique), category.\n * Components: jigs, datasources, functions, databases, tabs, expressions, actions.\n */\nexport class ApplicationBuilder extends BaseBuilder {\n  protected readonly _config: Record<string, unknown> = {\n    functions: {},\n    datasources: {},\n    databases: { default: new DefaultDatabaseBuilder() },\n    jigs: {},\n    actions: {},\n  }\n\n  /**\n   * Factory for creating datasources in Jigx applications.\n   *\n   * Datasource types:\n   * - **sqlite**: Local database, optional cloud sync\n   * - **static**: Embedded JSON at build time\n   * - **system**: Read-only system data (country flags)\n   *\n   * @see {@link SqliteDatasourceBuilder}\n   * @see {@link StaticDatasourceBuilder}\n   * @see {@link SystemDatasourceBuilder}\n   */\n  readonly addDatasource = {\n    sqlite: assignBuilderByInputFactory(\n      SqliteDatasourceBuilder,\n      'datasourceId',\n      this._config.datasources as Record<string, unknown>,\n    ),\n    static: assignBuilderByInputFactory(\n      StaticDatasourceBuilder,\n      'datasourceId',\n      this._config.datasources as Record<string, unknown>,\n    ),\n    system: assignBuilderByInputFactory(\n      SystemDatasourceBuilder,\n      'datasourceId',\n      this._config.datasources as Record<string, unknown>,\n    ),\n  }\n\n  /**\n   * Factory for creating functions in Jigx applications.\n   *\n   * Function types:\n   * - **rest**: HTTP API calls, JSON/XML, auth, pagination\n   * - **sql**: Azure SQL queries, stored procedures\n   * - **soap**: XML web services, WSDL-based\n   *\n   * @see {@link RestFunctionBuilder}\n   * @see {@link SqlFunctionBuilder}\n   * @see {@link SoapFunctionBuilder}\n   */\n  readonly addFunction = {\n    rest: assignBuilderByInputFactory(\n      RestFunctionBuilder,\n      'functionId',\n      this._config.functions as Record<string, unknown>,\n    ),\n    sql: assignBuilderByInputFactory(\n      SqlFunctionBuilder,\n      'functionId',\n      this._config.functions as Record<string, unknown>,\n    ),\n    soap: assignBuilderByInputFactory(\n      SoapFunctionBuilder,\n      'functionId',\n      this._config.functions as Record<string, unknown>,\n    ),\n  }\n\n  /**\n   * Factory for creating screens (jigs) in Jigx applications.\n   *\n   * Screen types:\n   * - **list**: Scrollable lists. Templates, sections, search\n   * - **staticGrid**: Static responsive grids\n   * - **dynamicGrid**: Data-driven responsive grids\n   * - **default**: Forms, mixed content container\n   * - **calendar**: Events. Month/week/day views\n   * - **document**: PDF/HTML viewer. Zoom, download\n   * - **fullScreen**: Maps, chat, immersive UI\n   * - **tabs**: Tab navigation between screens\n   * - **wizard**: Multi-step workflows\n   *\n   * @see {@link ListScreenBuilder}\n   * @see {@link StaticGridScreenBuilder}\n   * @see {@link DynamicGridScreenBuilder}\n   * @see {@link DefaultScreenBuilder}\n   * @see {@link CalendarScreenBuilder}\n   * @see {@link DocumentScreenBuilder}\n   * @see {@link FullScreenBuilder}\n   * @see {@link TabsScreenBuilder}\n   * @see {@link WizardScreenBuilder}\n   */\n  readonly addScreen = {\n    calendar: assignBuilderByInputFactory(\n      CalendarScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    default: assignBuilderByInputFactory(\n      DefaultScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    document: assignBuilderByInputFactory(\n      DocumentScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    fullScreen: assignBuilderByInputFactory(\n      FullScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    staticGrid: assignBuilderByInputFactory(\n      StaticGridScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    dynamicGrid: assignBuilderByInputFactory(\n      DynamicGridScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    gallery: assignBuilderByInputFactory(\n      GalleryScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    list: assignBuilderByInputFactory(\n      ListScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    tabs: assignBuilderByInputFactory(\n      TabsScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    wizard: assignBuilderByInputFactory(\n      WizardScreenBuilder,\n      'screenId',\n      this._config.jigs as Record<string, unknown>,\n    ),\n    screens: this._config.jigs as Record<string, ScreenBuilder>,\n  }\n\n  /**\n   * Factory for configuring the application's local SQLite database.\n   *\n   * Every application has a default database for storing local data.\n   * Use this to define tables that will be created automatically.\n   */\n  readonly addDatabase = {\n    default: (this._config.databases as { default: DefaultDatabaseBuilder }).default,\n  }\n\n  /**\n   * Create application builder with validated parameters.\n   *\n   * @param options.name - Unique identifier. Lowercase 2-50, prefer kebab-case, starts alpha, ends alphanum.\n   * @param options.title - Display title shown in Jigx home hub (defaults to name)\n   * @param options.description - Explains application purpose\n   * @param options.category - Classification for organizing solutions (defaults to 'miscellaneous')\n   *\n   * @throws {Error} When name doesn't match required pattern\n   */\n  constructor(options: ApplicationInput) {\n    super()\n    const { name } = options\n    this._config.name = toApplicationName(name)\n    this._config.title = options.title || name\n    this._config.category = 'miscellaneous'\n    this._config.runtimeSchemaVersion = RUNTIME_SCHEMA_VERSION\n    this.with(options)\n  }\n\n  /**\n   * Update application configuration fields.\n   *\n   * @param options - Partial application input (name is excluded, set only in constructor)\n   */\n  with(options: Partial<Omit<ApplicationInput, 'name'>>): this {\n    if (options.title !== undefined) this._config.title = options.title\n    if (options.description !== undefined) this._config.description = options.description\n    if (options.category !== undefined) this._config.category = options.category\n    if (options.type !== undefined) this._config.type = options.type\n    if (options.imageUrl !== undefined) this._config.imageUrl = options.imageUrl\n    if (options.state !== undefined) this._config.state = options.state\n    if (options.permissions !== undefined) this._config.permissions = options.permissions\n    if (options.dependencies !== undefined) this._config.dependencies = options.dependencies\n    if (options.profile !== undefined) this._config.profile = options.profile\n    return this\n  }\n\n  /**\n   * Add a reusable JSONata expression to the application.\n   *\n   * Expressions can be referenced throughout the application using the syntax\n   * `=@ctx.solution.expressions.{name}`. This promotes code reuse and\n   * maintainability.\n   *\n   * @param name - Expression identifier\n   * @param jsonata - JSONata expression (with or without leading =)\n   * @returns This builder for chaining\n   */\n  expression(name: string, jsonata: string | Expression | Record<string, unknown>): this {\n    if (!this._config.expressions) this._config.expressions = {}\n    const expressions = this._config.expressions as Record<\n      string,\n      Expression | Record<string, unknown>\n    >\n    if (typeof jsonata === 'object') {\n      expressions[name] = jsonata\n    } else {\n      expressions[name] = toExpression(jsonata)\n    }\n    return this\n  }\n\n  /**\n   * Configure home screen tabs for organizing content.\n   *\n   * Tabs provide navigation at the top of the application's home screen.\n   * This is the modern replacement for the deprecated widgets approach.\n   *\n   * @param options - Tab configuration\n   * @param options.screenId - Screen to navigate to when selected\n   * @param options.icon - Icon name or expression\n   * @param options.tabId - Optional tab key. Defaults to `screenId`.\n   * @param options.label - Optional label text\n   * @param options.badge - Optional badge indicator\n   * @param options.when - Optional visibility condition\n   */\n  readonly addTab = createBuilderFactory(ApplicationTabBuilder, (builder) => {\n    if (!this._config.tabs) this._config.tabs = {}\n    ;(this._config.tabs as Record<string, unknown>)[builder.tabId] = builder\n  })\n\n  /**\n   * Create **global** action definition reusable across jigs.\n   * Actions created here can be referenced throughout the application.\n   */\n  readonly addAction = assignBuilderByInputFactory(\n    ActionDefinitionBuilder,\n    'actionId',\n    this._config.actions as Record<string, unknown>,\n  )\n\n  /**\n   * Consider using @ctx.solution.name instead.\n   */\n  get name(): ApplicationName {\n    return this._config.name as ApplicationName\n  }\n\n  /**\n   * Add metadata\n   */\n  metadata(key: string, value: unknown): this {\n    if (!this._config.metadata) this._config.metadata = {}\n    ;(this._config.metadata as Record<string, unknown>)[key] = value\n    return this\n  }\n\n  getStateRef(key: string): string {\n    // TODO: validate key,  how?\n    return `@ctx.solution.state.${key}`\n  }\n\n  getExpressionRef(name: string): string {\n    // TODO: validate name, how?\n    return `@ctx.expressions.${name}`\n  }\n\n  /**\n   * Get a registered expression value by name.\n   * @param name - Expression identifier\n   * @returns The expression value, or undefined if not registered\n   */\n  getExpression(name: string): Expression | Record<string, unknown> | undefined {\n    const expressions = this._config.expressions as\n      | Record<string, Expression | Record<string, unknown>>\n      | undefined\n    return expressions?.[name]\n  }\n\n  /**\n   * Add custom script (reserved for future use)\n   * @param name - Script name/identifier\n   * @param script - Script content or configuration\n   */\n  script(name: string, script: unknown): this {\n    if (!this._config.scripts) this._config.scripts = {}\n    ;(this._config.scripts as Record<string, unknown>)[name] = script\n    return this\n  }\n\n  /**\n   * Add internationalization translation\n   * @param locale - Locale identifier (e.g., 'en', 'es', 'fr')\n   * @param translations - Translation key-value pairs\n   */\n  translation(locale: string, translations: unknown): this {\n    if (!this._config.translations) this._config.translations = {}\n    ;(this._config.translations as Record<string, unknown>)[locale] = translations\n    return this\n  }\n\n  /**\n   * Add database table change listener\n   * @param listener - Table change listener configuration\n   */\n  onTableChanged(listener: unknown): this {\n    if (!this._config.onTableChanged) this._config.onTableChanged = []\n    ;(this._config.onTableChanged as unknown[]).push(listener)\n    return this\n  }\n\n  /**\n   * Configure theme palette for the application\n   * @param palette - Color palette definition\n   */\n  themePalette(palette: unknown): this {\n    if (!this._config.assets) this._config.assets = {}\n    const assets = this._config.assets as Record<string, unknown>\n    if (!assets.theme) assets.theme = {}\n    ;(assets.theme as Record<string, unknown>).palette = palette\n    return this\n  }\n\n  /**\n   * Add image URLs to the application assets\n   * @param images - Array of image URLs\n   */\n  images(...images: string[]): this {\n    if (!this._config.assets) this._config.assets = {}\n    const assets = this._config.assets as Record<string, unknown>\n    if (!assets.images) assets.images = []\n    ;(assets.images as string[]).push(...images)\n    return this\n  }\n\n  /**\n   * Add icon references to the application assets\n   * @param icons - Array of icon names\n   */\n  icons(...icons: IconName[]): this {\n    if (!this._config.assets) this._config.assets = {}\n    const assets = this._config.assets as Record<string, unknown>\n    if (!assets.icons) assets.icons = []\n    ;(assets.icons as IconName[]).push(...icons)\n    return this\n  }\n\n  /**\n   * Action executed when application loads.\n   */\n  readonly onLoad = createActionInBackgroundBuildersFactory((action) => {\n    this._config.onLoad = action\n  })\n\n  /**\n   * Action executed when application gains focus.\n   */\n  readonly onFocus = createActionInBackgroundBuildersFactory((action) => {\n    this._config.onFocus = action\n  })\n\n  /**\n   * Action executed on pull-to-refresh.\n   */\n  readonly onRefresh = createActionInBackgroundBuildersFactory((action) => {\n    this._config.onRefresh = action\n  })\n\n  /**\n   * Validate the application configuration including all screens.\n   *\n   * This method should be called before build() to ensure the application\n   * configuration is valid. It iterates through all screens and calls their\n   * _validate() methods.\n   *\n   * @throws {Error} When validation fails\n   */\n  _validate(): void {\n    const screens = this._config.jigs as Record<string, ScreenBuilder>\n    for (const screen of Object.values(screens)) {\n      screen._validate()\n    }\n  }\n\n  /**\n   * Build and return the application configuration.\n   */\n  build(): Application {\n    this._validate()\n\n    // Register dynamic tables on default database before building\n    this.registerRequiredTables()\n\n    // Extract scripts for special transformation (scripts -> { expressions: scripts })\n    const { scripts, ...configRest } = this._config\n    const scriptOutput =\n      scripts && Object.keys(scripts as object).length > 0\n        ? { expressions: { ...(scripts as object) } }\n        : undefined\n\n    return {\n      ...buildTree(configRest),\n      ...(scriptOutput ? { scripts: scriptOutput } : {}),\n    }\n  }\n\n  /**\n   * Scan all datasources (app-level and screen-level) for dynamic sqlite\n   * entities and register their required tables on the default database.\n   */\n  private registerRequiredTables(): void {\n    const db = this.addDatabase.default\n\n    const registerFromDatasources = (datasources: Record<string, unknown>): void => {\n      for (const ds of Object.values(datasources)) {\n        if (ds instanceof SqliteDatasourceBuilder) {\n          for (const table of ds.getRequiredTables()) {\n            db.table(table)\n          }\n        }\n      }\n    }\n\n    // App-level datasources\n    registerFromDatasources(this._config.datasources as Record<string, unknown>)\n\n    // Screen-level datasources\n    const screens = this._config.jigs as Record<string, ScreenBuilder>\n    for (const screen of Object.values(screens)) {\n      for (const table of screen.collectRequiredTables()) {\n        db.table(table)\n      }\n    }\n  }\n\n  /**\n   * Convert to JSON string with formatting options\n   */\n  toJSON(options?: { indent?: number; sortKeys?: boolean }): string {\n    const { indent = 2, sortKeys = false } = options || {}\n    const obj = this.build()\n    const data = sortKeys ? sortObject(obj) : obj\n    return JSON.stringify(data, null, indent)\n  }\n\n  /**\n   * Convert to YAML string\n   */\n  toYAML(): string {\n    return YAML.stringify(this.build())\n  }\n}\n"]}

package/dist/application/application.tab.d.ts

@@ -0,0 +1,20 @@
+import { BaseBuilder, type Expression, type InstanceId, type ScreenId, type When } from '../abstract/index.js';
+import { type IconName } from '../icon/index.js';
+export interface ApplicationTabInput {
+    readonly screenId: ScreenId;
+    readonly icon: IconName | Expression;
+    readonly tabId?: InstanceId;
+    readonly label?: string | Expression;
+    readonly badge?: number | boolean | Expression;
+    readonly when?: When;
+}
+export declare class ApplicationTabBuilder extends BaseBuilder {
+    protected readonly _config: Record<string, unknown>;
+    readonly screenId: ScreenId;
+    readonly tabId: InstanceId;
+    constructor(options: ApplicationTabInput);
+    with(options: Partial<Omit<ApplicationTabInput, 'screenId' | 'icon' | 'tabId'>>): this;
+    _validate(): void;
+    build(): Record<string, unknown>;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/application/application.tab.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"application.tab.d.ts","sourceRoot":"","sources":["../../src/application/application.tab.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,KAAK,UAAU,EAEf,KAAK,UAAU,EACf,KAAK,QAAQ,EAKb,KAAK,IAAI,EACV,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,KAAK,QAAQ,EAA0B,MAAM,kBAAkB,CAAA;AAKxE,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;IAC3B,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,UAAU,CAAA;IACpC,QAAQ,CAAC,KAAK,CAAC,EAAE,UAAU,CAAA;IAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IACpC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,UAAU,CAAA;IAC9C,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,CAAA;CACrB;AA6BD,qBAAa,qBAAsB,SAAQ,WAAW;IACpD,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAK;IAGxD,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;IAG3B,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAA;IAY1B,YAAY,OAAO,EAAE,mBAAmB,EAOvC;IAOD,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,mBAAmB,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAWrF;IAED,SAAS,IAAI,IAAI,CAAG;IAEpB,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAiB/B;CACF","sourcesContent":["import {\n  BaseBuilder,\n  type Expression,\n  isExpression,\n  type InstanceId,\n  type ScreenId,\n  toExpression,\n  toInstanceId,\n  toScreenId,\n  toWhen,\n  type When,\n} from '../abstract/index.js'\nimport { type IconName, toIconNameOrExpression } from '../icon/index.js'\n\n/**\n * Input for creating an application tab.\n */\nexport interface ApplicationTabInput {\n  readonly screenId: ScreenId\n  readonly icon: IconName | Expression\n  readonly tabId?: InstanceId\n  readonly label?: string | Expression\n  readonly badge?: number | boolean | Expression\n  readonly when?: When\n}\n\n/**\n * Build application tab configurations.\n *\n * Create navigation tabs linking to screens with icons, labels, badges, and conditional visibility.\n *\n *\n * ## Advanced Usage\n *\n * ```typescript\n * // Dynamic content with expressions\n * app.addTab({ screenId: 'dashboard-screen', icon: '=@ctx.current.item.icon' })\n *   .with({ label: '=@ctx.current.item.title', badge: '=@ctx.solution.state.tasks.pending', when: '=@ctx.solution.state.isEnabled' })\n *\n * // Multiple badge types\n * app.addTab({ screenId: 'notifications', icon: 'bell', badge: 5 })          // Number badge\n * app.addTab({ screenId: 'notifications', icon: 'bell', badge: true })        // Boolean badge (shows dot)\n * app.addTab({ screenId: 'notifications', icon: 'bell', badge: '=@ctx.solution.state.alerts.count' }) // Expression badge\n * ```\n *\n * ## Badge Types\n *\n * - **Number**: Shows numeric count (e.g., `5`, `23`)\n * - **Boolean**: Shows indicator dot when `true`\n * - **Expression**: Dynamic value from JSONata expression\n *\n * ## Conditional Visibility\n */\nexport class ApplicationTabBuilder extends BaseBuilder {\n  protected readonly _config: Record<string, unknown> = {}\n\n  /** The screen ID this tab navigates to when selected */\n  readonly screenId: ScreenId\n\n  /** Tab key used in the tabs record */\n  readonly tabId: InstanceId\n\n  /**\n   * Create application tab builder.\n   * @param options - Tab configuration\n   * @param options.screenId - Screen to navigate to when selected\n   * @param options.icon - Icon name or expression\n   * @param options.tabId - Optional tab key. Defaults to `screenId`.\n   * @param options.label - Optional label text\n   * @param options.badge - Optional badge indicator\n   * @param options.when - Optional visibility condition\n   */\n  constructor(options: ApplicationTabInput) {\n    super()\n    this.screenId = toScreenId(options.screenId)\n    this.tabId = toInstanceId(options.tabId ?? this.screenId)\n    this._config.jigId = this.screenId\n    this._config.icon = toIconNameOrExpression(options.icon)\n    this.with(options)\n  }\n\n  /**\n   * Update tab configuration.\n   * @param options - Partial tab configuration to merge\n   * @returns This builder instance for method chaining\n   */\n  with(options: Partial<Omit<ApplicationTabInput, 'screenId' | 'icon' | 'tabId'>>): this {\n    if (options.label !== undefined) {\n      this._config.label = isExpression(options.label) ? toExpression(options.label) : options.label\n    }\n    if (options.badge !== undefined) {\n      this._config.badge = options.badge\n    }\n    if (options.when !== undefined) {\n      this._config.when = toWhen(options.when)\n    }\n    return this\n  }\n\n  _validate(): void {}\n\n  build(): Record<string, unknown> {\n    const result: Record<string, unknown> = {\n      jigId: this._config.jigId,\n      icon: this._config.icon,\n    }\n\n    if (this._config.label !== undefined) {\n      result.label = this._config.label\n    }\n    if (this._config.badge !== undefined) {\n      result.badge = this._config.badge\n    }\n    if (this._config.when !== undefined) {\n      result.when = this._config.when\n    }\n\n    return result\n  }\n}\n"]}

package/dist/application/application.tab.js

@@ -0,0 +1,45 @@
+import { BaseBuilder, isExpression, toExpression, toInstanceId, toScreenId, toWhen, } from '../abstract/index.js';
+import { toIconNameOrExpression } from '../icon/index.js';
+export class ApplicationTabBuilder extends BaseBuilder {
+    _config = {};
+    screenId;
+    tabId;
+    constructor(options) {
+        super();
+        this.screenId = toScreenId(options.screenId);
+        this.tabId = toInstanceId(options.tabId ?? this.screenId);
+        this._config.jigId = this.screenId;
+        this._config.icon = toIconNameOrExpression(options.icon);
+        this.with(options);
+    }
+    with(options) {
+        if (options.label !== undefined) {
+            this._config.label = isExpression(options.label) ? toExpression(options.label) : options.label;
+        }
+        if (options.badge !== undefined) {
+            this._config.badge = options.badge;
+        }
+        if (options.when !== undefined) {
+            this._config.when = toWhen(options.when);
+        }
+        return this;
+    }
+    _validate() { }
+    build() {
+        const result = {
+            jigId: this._config.jigId,
+            icon: this._config.icon,
+        };
+        if (this._config.label !== undefined) {
+            result.label = this._config.label;
+        }
+        if (this._config.badge !== undefined) {
+            result.badge = this._config.badge;
+        }
+        if (this._config.when !== undefined) {
+            result.when = this._config.when;
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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