@table-js/platform 0.0.3 → 0.0.5

package/README.md

@@ -18,13 +18,17 @@ table build --platform all
 table build --platform tizen
 table build --platform webos
 table build --platform android
+
+# Build Android as a native Kotlin + Compose TV project
+table build --platform android --mode native
 ```
 
 ## Supported Platforms
 
 - **Tizen** - Samsung Smart TV (.wgt)
 - **webOS** - LG Smart TV (.ipk)
-- **Android TV** - Android TV (.apk)
+- **Android TV** - Android TV WebView (.apk / Gradle project)
+- **Android TV Native** - Kotlin + Compose for TV project (`--mode native`)
 
 ## License
 

package/dist/cli.mjs

@@ -6,6 +6,7 @@ import chalk from "chalk";
 import ora from "ora";
 
 // src/builder.ts
+import fs4 from "fs-extra";
 import { build as viteBuild } from "vite";
 
 // src/adapters/tizen.ts
@@ -16,18 +17,17 @@ import { createWriteStream } from "fs";
 var TizenAdapter = class {
   name = "Tizen (Samsung)";
   async build(options) {
-    const distDir = `${options.outDir}/tizen`;
-    await this.createConfig(distDir);
+    await this.createConfig(options.dir);
   }
-  async package(distDir) {
-    const outputPath = path.join(distDir, "..", "app.wgt");
+  async package(options) {
+    const outputPath = path.join(options.dir, "..", "app.wgt");
     await new Promise((resolve, reject) => {
       const output = createWriteStream(outputPath);
       const archive = archiver("zip", { zlib: { level: 9 } });
       output.on("close", () => resolve());
       archive.on("error", reject);
       archive.pipe(output);
-      archive.directory(distDir, false);
+      archive.directory(options.dir, false);
       archive.finalize();
     });
     return outputPath;
@@ -83,18 +83,17 @@ import { createWriteStream as createWriteStream2 } from "fs";
 var WebOSAdapter = class {
   name = "webOS (LG)";
   async build(options) {
-    const distDir = `${options.outDir}/webos`;
-    await this.createAppInfo(distDir);
+    await this.createAppInfo(options.dir);
   }
-  async package(distDir) {
-    const outputPath = path2.join(distDir, "..", "app.ipk");
+  async package(options) {
+    const outputPath = path2.join(options.dir, "..", "app.ipk");
     await new Promise((resolve, reject) => {
       const output = createWriteStream2(outputPath);
       const archive = archiver2("tar", { gzip: true });
       output.on("close", () => resolve());
       archive.on("error", reject);
       archive.pipe(output);
-      archive.directory(distDir, false);
+      archive.directory(options.dir, false);
       archive.finalize();
     });
     return outputPath;
@@ -142,49 +141,106 @@ import { execa } from "execa";
 var AndroidAdapter = class {
   name = "Android TV";
   async build(options) {
-    const distDir = `${options.outDir}/android`;
-    await this.createWebViewProject(distDir);
+    if (options.mode === "native") {
+      await this.native(options.dir);
+      return;
+    }
+    await this.web(options.dir);
   }
-  async package(distDir) {
-    const projectDir = path3.join(distDir, "android-project");
+  async package(options) {
+    const proj = path3.join(options.dir, "project");
+    const cmd = await this.cmd(proj);
+    if (!cmd) {
+      return proj;
+    }
     try {
-      await execa("./gradlew", ["assembleRelease"], {
-        cwd: projectDir,
+      await execa(cmd, ["assembleRelease"], {
+        cwd: proj,
         stdio: "inherit"
       });
-      const apkPath = path3.join(projectDir, "app/build/outputs/apk/release/app-release.apk");
-      const outputPath = path3.join(distDir, "..", "app.apk");
-      await fs3.copy(apkPath, outputPath);
-      return outputPath;
-    } catch (error) {
-      throw new Error("Android build failed. Make sure Android SDK is installed.");
+      const apk = path3.join(proj, "app/build/outputs/apk/release/app-release.apk");
+      const out2 = path3.join(options.dir, "..", this.apk(options));
+      await fs3.copy(apk, out2);
+      return out2;
+    } catch {
+      throw new Error("Android build failed. Install the Android SDK and Gradle, or add a Gradle wrapper.");
     }
   }
-  async createWebViewProject(distDir) {
-    const pkg = await this.readPackageJson();
-    const projectDir = path3.join(distDir, "android-project");
-    await fs3.ensureDir(projectDir);
-    await fs3.copy(distDir, path3.join(projectDir, "app/src/main/assets/www"));
-    await this.createManifest(projectDir, pkg);
-    await this.createGradleFiles(projectDir, pkg);
-    await this.createMainActivity(projectDir, pkg);
+  async web(dir2) {
+    const pkg = await this.pkg();
+    const proj = path3.join(dir2, "project");
+    await fs3.remove(proj);
+    await this.root(proj, pkg);
+    await this.man(proj, pkg, true);
+    await this.app(proj, pkg, false);
+    await this.res(proj);
+    await this.webKt(proj, pkg);
+    await fs3.copy(path3.join(dir2, "www"), path3.join(proj, "app/src/main/assets/www"));
   }
-  async createManifest(projectDir, pkg) {
+  async native(dir2) {
+    const pkg = await this.pkg();
+    const proj = path3.join(dir2, "project");
+    await fs3.remove(proj);
+    await this.root(proj, pkg);
+    await this.man(proj, pkg, false);
+    await this.app(proj, pkg, true);
+    await this.res(proj);
+    await this.nativeKt(proj, pkg);
+  }
+  async root(proj, pkg) {
+    const settings = `pluginManagement {
+    repositories {
+        google()
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+
+dependencyResolutionManagement {
+    repositoriesMode.set(org.gradle.api.initialization.resolve.RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
+rootProject.name = "${this.safe(pkg.name)}"
+include(":app")
+`;
+    const build2 = `plugins {
+    id("com.android.application") version "9.1.0" apply false
+    id("org.jetbrains.kotlin.android") version "2.3.10" apply false
+    id("org.jetbrains.kotlin.plugin.compose") version "2.3.10" apply false
+}
+`;
+    const props = `org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
+android.useAndroidX=true
+kotlin.code.style=official
+`;
+    await fs3.ensureDir(proj);
+    await fs3.ensureDir(path3.join(proj, "app"));
+    await fs3.writeFile(path3.join(proj, "settings.gradle.kts"), settings);
+    await fs3.writeFile(path3.join(proj, "build.gradle.kts"), build2);
+    await fs3.writeFile(path3.join(proj, "gradle.properties"), props);
+    await fs3.writeFile(path3.join(proj, "app/proguard-rules.pro"), "");
+  }
+  async man(proj, pkg, web2) {
+    const net = web2 ? '<uses-permission android:name="android.permission.INTERNET" />\n' : "";
+    const clear = web2 ? '        android:usesCleartextTraffic="true"\n' : "";
     const manifest = `<?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="${pkg.id || "com.example.app"}">
 
-    <uses-permission android:name="android.permission.INTERNET" />
-    <uses-feature android:name="android.software.leanback" android:required="true" />
+    ${net}    <uses-feature android:name="android.software.leanback" android:required="true" />
     <uses-feature android:name="android.hardware.touchscreen" android:required="false" />
 
     <application
         android:allowBackup="true"
-        android:icon="@mipmap/ic_launcher"
-        android:label="${pkg.name}"
         android:banner="@drawable/banner"
-        android:theme="@style/Theme.Leanback">
-        
+        android:icon="@android:drawable/sym_def_app_icon"
+        android:label="${pkg.name}"
+${clear}        android:theme="@android:style/Theme.DeviceDefault.NoActionBar">
+
         <activity
             android:name=".MainActivity"
             android:exported="true"
@@ -196,79 +252,215 @@ var AndroidAdapter = class {
         </activity>
     </application>
 </manifest>`;
-    const manifestPath = path3.join(projectDir, "app/src/main/AndroidManifest.xml");
-    await fs3.ensureDir(path3.dirname(manifestPath));
-    await fs3.writeFile(manifestPath, manifest);
+    const file = path3.join(proj, "app/src/main/AndroidManifest.xml");
+    await fs3.ensureDir(path3.dirname(file));
+    await fs3.writeFile(file, manifest);
   }
-  async createGradleFiles(projectDir, pkg) {
-    const buildGradle = `plugins {
-    id 'com.android.application'
-}
+  async app(proj, pkg, native) {
+    const plugins = native ? `plugins {
+    id("com.android.application")
+    id("org.jetbrains.kotlin.android")
+    id("org.jetbrains.kotlin.plugin.compose")
+}` : `plugins {
+    id("com.android.application")
+    id("org.jetbrains.kotlin.android")
+}`;
+    const flags = native ? `
+    buildFeatures {
+        compose = true
+    }` : "";
+    const deps = native ? `dependencies {
+    val bom = platform("androidx.compose:compose-bom:2026.02.01")
+
+    implementation(bom)
+    androidTestImplementation(bom)
 
+    implementation("androidx.activity:activity-compose:1.12.4")
+    implementation("androidx.compose.foundation:foundation")
+    implementation("androidx.compose.ui:ui")
+    implementation("androidx.compose.ui:ui-tooling-preview")
+    implementation("androidx.tv:tv-material:1.0.0")
+    debugImplementation("androidx.compose.ui:ui-tooling")
+}` : `dependencies {
+    implementation("androidx.leanback:leanback:1.0.0")
+}`;
+    const build2 = `${plugins}
 android {
-    namespace '${pkg.id || "com.example.app"}'
-    compileSdk 34
+    namespace = "${pkg.id || "com.example.app"}"
+    compileSdk = 34
 
     defaultConfig {
-        applicationId "${pkg.id || "com.example.app"}"
-        minSdk 21
-        targetSdk 34
-        versionCode 1
-        versionName "${pkg.version}"
+        applicationId = "${pkg.id || "com.example.app"}"
+        minSdk = 21
+        targetSdk = 34
+        versionCode = 1
+        versionName = "${pkg.version}"
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
     }
 
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+${flags}
+
     buildTypes {
         release {
-            minifyEnabled true
-            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt')
+            isMinifyEnabled = true
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro",
+            )
         }
     }
 }
 
-dependencies {
-    implementation 'androidx.leanback:leanback:1.0.0'
-}`;
-    await fs3.writeFile(path3.join(projectDir, "app/build.gradle"), buildGradle);
+${deps}
+`;
+    await fs3.writeFile(path3.join(proj, "app/build.gradle.kts"), build2);
+  }
+  async res(proj) {
+    const banner = `<shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="rectangle">
+    <solid android:color="#10151E" />
+    <corners android:radius="18dp" />
+</shape>
+`;
+    const file = path3.join(proj, "app/src/main/res/drawable/banner.xml");
+    await fs3.ensureDir(path3.dirname(file));
+    await fs3.writeFile(file, banner);
   }
-  async createMainActivity(projectDir, pkg) {
-    const packageName = pkg.id || "com.example.app";
-    const activity = `package ${packageName};
+  async webKt(proj, pkg) {
+    const id = pkg.id || "com.example.app";
+    const main = `package ${id}
 
-import android.app.Activity;
-import android.os.Bundle;
-import android.webkit.WebView;
-import android.webkit.WebSettings;
+import android.app.Activity
+import android.os.Bundle
+import android.webkit.WebSettings
+import android.webkit.WebView
 
-public class MainActivity extends Activity {
-    private WebView webView;
+class MainActivity : Activity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
 
-    @Override
-    protected void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        
-        webView = new WebView(this);
-        setContentView(webView);
-        
-        WebSettings settings = webView.getSettings();
-        settings.setJavaScriptEnabled(true);
-        settings.setDomStorageEnabled(true);
-        settings.setAllowFileAccess(true);
-        
-        webView.loadUrl("file:///android_asset/www/index.html");
+        val web = WebView(this)
+        setContentView(web)
+
+        val set: WebSettings = web.settings
+        set.javaScriptEnabled = true
+        set.domStorageEnabled = true
+        set.allowFileAccess = true
+
+        web.loadUrl("file:///android_asset/www/index.html")
     }
-}`;
-    const activityPath = path3.join(
-      projectDir,
-      `app/src/main/java/${packageName.replace(/\./g, "/")}/MainActivity.java`
-    );
-    await fs3.ensureDir(path3.dirname(activityPath));
-    await fs3.writeFile(activityPath, activity);
+}
+`;
+    const file = path3.join(proj, `app/src/main/java/${id.replace(/\./g, "/")}/MainActivity.kt`);
+    await fs3.ensureDir(path3.dirname(file));
+    await fs3.writeFile(file, main);
   }
-  async readPackageJson() {
+  async nativeKt(proj, pkg) {
+    const id = pkg.id || "com.example.app";
+    const main = `package ${id}
+
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.tv.material3.Button
+import androidx.tv.material3.MaterialTheme
+import androidx.tv.material3.Surface
+import androidx.tv.material3.Text
+
+class MainActivity : ComponentActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContent {
+            MaterialTheme {
+                Surface(modifier = Modifier.fillMaxSize()) {
+                    Box(
+                        modifier = Modifier
+                            .fillMaxSize()
+                            .background(Color(0xFF05070A))
+                            .padding(48.dp),
+                        contentAlignment = Alignment.Center,
+                    ) {
+                        Column(
+                            modifier = Modifier
+                                .fillMaxWidth()
+                                .background(Color(0xFF10151E), RoundedCornerShape(28.dp))
+                                .padding(32.dp),
+                            horizontalAlignment = Alignment.CenterHorizontally,
+                            verticalArrangement = Arrangement.spacedBy(20.dp),
+                        ) {
+                            Text(
+                                text = "${pkg.name}",
+                                style = MaterialTheme.typography.displayMedium,
+                                textAlign = TextAlign.Center,
+                            )
+                            Text(
+                                text = "Android native mode uses Kotlin and Compose for TV instead of WebView.",
+                                style = MaterialTheme.typography.bodyLarge,
+                                textAlign = TextAlign.Center,
+                                color = Color(0xFFD4D7DD),
+                            )
+                            Button(onClick = {}) {
+                                Text("Ready")
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+`;
+    const file = path3.join(proj, `app/src/main/java/${id.replace(/\./g, "/")}/MainActivity.kt`);
+    await fs3.ensureDir(path3.dirname(file));
+    await fs3.writeFile(file, main);
+  }
+  async cmd(proj) {
+    if (await fs3.pathExists(path3.join(proj, "gradlew"))) {
+      return "./gradlew";
+    }
+    if (await this.has("gradle")) {
+      return "gradle";
+    }
+    return null;
+  }
+  async has(cmd) {
+    try {
+      await execa(cmd, ["--version"]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  apk(options) {
+    return options.mode === "native" ? "app-native.apk" : "app.apk";
+  }
+  safe(name) {
+    return name.replace(/[^a-z0-9._-]/gi, "-");
+  }
+  async pkg() {
     try {
       const pkg = await fs3.readJson("package.json");
       return {
-        id: pkg.androidAppId || pkg.name.replace(/[^a-z0-9]/gi, ".").toLowerCase(),
+        id: pkg.androidAppId || this.id(pkg.name),
         name: pkg.name,
         version: pkg.version,
         description: pkg.description
@@ -281,13 +473,17 @@ public class MainActivity extends Activity {
       };
     }
   }
+  id(name) {
+    const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, ".").replace(/^\.+|\.+$/g, "").replace(/\.\.+/g, ".");
+    return `com.tablejs.${slug || "app"}`;
+  }
 };
 
 // src/builder.ts
 async function build(platform, options = {}) {
   const opts = {
-    platform,
     outDir: options.outDir || "dist",
+    mode: options.mode || "webview",
     minify: options.minify ?? true,
     sourcemap: options.sourcemap ?? false
   };
@@ -301,21 +497,30 @@ async function build(platform, options = {}) {
   }
   await buildPlatform(platform, opts);
 }
-async function buildPlatform(platform, options) {
+async function buildPlatform(platform, base) {
+  const options = {
+    ...base,
+    dir: out(base.outDir, platform, base.mode),
+    platform
+  };
   const adapter = getAdapter(platform);
-  await viteBuild({
-    build: {
-      outDir: `${options.outDir}/${platform}`,
-      minify: options.minify,
-      sourcemap: options.sourcemap,
-      emptyOutDir: true
-    },
-    define: {
-      __TABLE_PLATFORM__: JSON.stringify(platform)
-    }
-  });
+  if (web(platform, options.mode)) {
+    await viteBuild({
+      build: {
+        outDir: dir(options),
+        minify: options.minify,
+        sourcemap: options.sourcemap,
+        emptyOutDir: true
+      },
+      define: {
+        __TABLE_PLATFORM__: JSON.stringify(platform)
+      }
+    });
+  } else {
+    await fs4.emptyDir(options.dir);
+  }
   await adapter.build(options);
-  const packagePath = await adapter.package(`${options.outDir}/${platform}`);
+  const packagePath = await adapter.package(options);
   console.log(`\u2713 ${adapter.name} package created: ${packagePath}`);
 }
 function getAdapter(platform) {
@@ -330,11 +535,26 @@ function getAdapter(platform) {
       throw new Error(`Unknown platform: ${platform}`);
   }
 }
+function out(root, platform, mode) {
+  if (platform === "android" && mode === "native") {
+    return `${root}/android-native`;
+  }
+  return `${root}/${platform}`;
+}
+function dir(options) {
+  if (options.platform === "android") {
+    return `${options.dir}/www`;
+  }
+  return options.dir;
+}
+function web(platform, mode) {
+  return platform !== "android" || mode === "webview";
+}
 
 // src/cli.ts
 var program = new Command();
 program.name("table").description("Table.js build tool for Smart TV platforms").version("0.0.1");
-program.command("build").description("Build for target platform").option("-p, --platform <platform>", "Target platform (tizen, webos, android, all)", "all").option("-o, --out <dir>", "Output directory", "dist").option("--no-minify", "Disable minification").option("--sourcemap", "Generate sourcemaps").action(async (options) => {
+program.command("build").description("Build for target platform").option("-p, --platform <platform>", "Target platform (tizen, webos, android, all)", "all").option("-m, --mode <mode>", "Android mode (webview, native)", "webview").option("-o, --out <dir>", "Output directory", "dist").option("--no-minify", "Disable minification").option("--sourcemap", "Generate sourcemaps").action(async (options) => {
   const platform = options.platform;
   console.log();
   console.log(chalk.bold("  table.js") + chalk.dim(" \u2014 Building for Smart TV"));
@@ -343,6 +563,7 @@ program.command("build").description("Build for target platform").option("-p, --
   try {
     await build(platform, {
       outDir: options.out,
+      mode: options.mode,
       minify: options.minify,
       sourcemap: options.sourcemap
     });

package/dist/index.d.mts

@@ -1,14 +1,18 @@
 type Platform = 'tizen' | 'webos' | 'android' | 'all';
+type Target = Exclude<Platform, 'all'>;
+type Mode = 'webview' | 'native';
 interface BuildOptions {
-    platform: Platform;
+    platform: Target;
     outDir: string;
+    dir: string;
     minify: boolean;
+    mode: Mode;
     sourcemap: boolean;
 }
 interface PlatformAdapter {
     name: string;
     build(options: BuildOptions): Promise<void>;
-    package(distDir: string): Promise<string>;
+    package(options: BuildOptions): Promise<string>;
 }
 interface ManifestBase {
     id: string;
@@ -23,7 +27,7 @@ declare function build(platform: Platform, options?: Partial<BuildOptions>): Pro
 declare class TizenAdapter implements PlatformAdapter {
     name: string;
     build(options: BuildOptions): Promise<void>;
-    package(distDir: string): Promise<string>;
+    package(options: BuildOptions): Promise<string>;
     private createConfig;
     private readPackageJson;
 }
@@ -31,7 +35,7 @@ declare class TizenAdapter implements PlatformAdapter {
 declare class WebOSAdapter implements PlatformAdapter {
     name: string;
     build(options: BuildOptions): Promise<void>;
-    package(distDir: string): Promise<string>;
+    package(options: BuildOptions): Promise<string>;
     private createAppInfo;
     private readPackageJson;
 }
@@ -39,12 +43,21 @@ declare class WebOSAdapter implements PlatformAdapter {
 declare class AndroidAdapter implements PlatformAdapter {
     name: string;
     build(options: BuildOptions): Promise<void>;
-    package(distDir: string): Promise<string>;
-    private createWebViewProject;
-    private createManifest;
-    private createGradleFiles;
-    private createMainActivity;
-    private readPackageJson;
+    package(options: BuildOptions): Promise<string>;
+    private web;
+    private native;
+    private root;
+    private man;
+    private app;
+    private res;
+    private webKt;
+    private nativeKt;
+    private cmd;
+    private has;
+    private apk;
+    private safe;
+    private pkg;
+    private id;
 }
 
-export { AndroidAdapter, type BuildOptions, type ManifestBase, type Platform, type PlatformAdapter, TizenAdapter, WebOSAdapter, build };
+export { AndroidAdapter, type BuildOptions, type ManifestBase, type Mode, type Platform, type PlatformAdapter, type Target, TizenAdapter, WebOSAdapter, build };