@table-js/platform 0.0.3 → 0.0.5

package/dist/index.d.ts

@@ -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 };

package/dist/index.js

@@ -38,6 +38,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/builder.ts
+var import_fs_extra4 = __toESM(require("fs-extra"));
 var import_vite = require("vite");
 
 // src/adapters/tizen.ts
@@ -48,18 +49,17 @@ var import_fs = require("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 = import_path.default.join(distDir, "..", "app.wgt");
+  async package(options) {
+    const outputPath = import_path.default.join(options.dir, "..", "app.wgt");
     await new Promise((resolve, reject) => {
       const output = (0, import_fs.createWriteStream)(outputPath);
       const archive = (0, import_archiver.default)("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;
@@ -115,18 +115,17 @@ var import_fs2 = require("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 = import_path2.default.join(distDir, "..", "app.ipk");
+  async package(options) {
+    const outputPath = import_path2.default.join(options.dir, "..", "app.ipk");
     await new Promise((resolve, reject) => {
       const output = (0, import_fs2.createWriteStream)(outputPath);
       const archive = (0, import_archiver2.default)("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;
@@ -174,49 +173,106 @@ var import_execa = require("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 = import_path3.default.join(distDir, "android-project");
+  async package(options) {
+    const proj = import_path3.default.join(options.dir, "project");
+    const cmd = await this.cmd(proj);
+    if (!cmd) {
+      return proj;
+    }
     try {
-      await (0, import_execa.execa)("./gradlew", ["assembleRelease"], {
-        cwd: projectDir,
+      await (0, import_execa.execa)(cmd, ["assembleRelease"], {
+        cwd: proj,
         stdio: "inherit"
       });
-      const apkPath = import_path3.default.join(projectDir, "app/build/outputs/apk/release/app-release.apk");
-      const outputPath = import_path3.default.join(distDir, "..", "app.apk");
-      await import_fs_extra3.default.copy(apkPath, outputPath);
-      return outputPath;
-    } catch (error) {
-      throw new Error("Android build failed. Make sure Android SDK is installed.");
+      const apk = import_path3.default.join(proj, "app/build/outputs/apk/release/app-release.apk");
+      const out2 = import_path3.default.join(options.dir, "..", this.apk(options));
+      await import_fs_extra3.default.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 = import_path3.default.join(distDir, "android-project");
-    await import_fs_extra3.default.ensureDir(projectDir);
-    await import_fs_extra3.default.copy(distDir, import_path3.default.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 = import_path3.default.join(dir2, "project");
+    await import_fs_extra3.default.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 import_fs_extra3.default.copy(import_path3.default.join(dir2, "www"), import_path3.default.join(proj, "app/src/main/assets/www"));
+  }
+  async native(dir2) {
+    const pkg = await this.pkg();
+    const proj = import_path3.default.join(dir2, "project");
+    await import_fs_extra3.default.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 import_fs_extra3.default.ensureDir(proj);
+    await import_fs_extra3.default.ensureDir(import_path3.default.join(proj, "app"));
+    await import_fs_extra3.default.writeFile(import_path3.default.join(proj, "settings.gradle.kts"), settings);
+    await import_fs_extra3.default.writeFile(import_path3.default.join(proj, "build.gradle.kts"), build2);
+    await import_fs_extra3.default.writeFile(import_path3.default.join(proj, "gradle.properties"), props);
+    await import_fs_extra3.default.writeFile(import_path3.default.join(proj, "app/proguard-rules.pro"), "");
   }
-  async createManifest(projectDir, pkg) {
+  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"
@@ -228,79 +284,215 @@ var AndroidAdapter = class {
         </activity>
     </application>
 </manifest>`;
-    const manifestPath = import_path3.default.join(projectDir, "app/src/main/AndroidManifest.xml");
-    await import_fs_extra3.default.ensureDir(import_path3.default.dirname(manifestPath));
-    await import_fs_extra3.default.writeFile(manifestPath, manifest);
+    const file = import_path3.default.join(proj, "app/src/main/AndroidManifest.xml");
+    await import_fs_extra3.default.ensureDir(import_path3.default.dirname(file));
+    await import_fs_extra3.default.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 import_fs_extra3.default.writeFile(import_path3.default.join(projectDir, "app/build.gradle"), buildGradle);
+${deps}
+`;
+    await import_fs_extra3.default.writeFile(import_path3.default.join(proj, "app/build.gradle.kts"), build2);
   }
-  async createMainActivity(projectDir, pkg) {
-    const packageName = pkg.id || "com.example.app";
-    const activity = `package ${packageName};
+  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 = import_path3.default.join(proj, "app/src/main/res/drawable/banner.xml");
+    await import_fs_extra3.default.ensureDir(import_path3.default.dirname(file));
+    await import_fs_extra3.default.writeFile(file, banner);
+  }
+  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.WebSettings
+import android.webkit.WebView
+
+class MainActivity : Activity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
 
-import android.app.Activity;
-import android.os.Bundle;
-import android.webkit.WebView;
-import android.webkit.WebSettings;
+        val web = WebView(this)
+        setContentView(web)
 
-public class MainActivity extends Activity {
-    private WebView webView;
+        val set: WebSettings = web.settings
+        set.javaScriptEnabled = true
+        set.domStorageEnabled = true
+        set.allowFileAccess = true
 
-    @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");
+        web.loadUrl("file:///android_asset/www/index.html")
     }
-}`;
-    const activityPath = import_path3.default.join(
-      projectDir,
-      `app/src/main/java/${packageName.replace(/\./g, "/")}/MainActivity.java`
-    );
-    await import_fs_extra3.default.ensureDir(import_path3.default.dirname(activityPath));
-    await import_fs_extra3.default.writeFile(activityPath, activity);
+}
+`;
+    const file = import_path3.default.join(proj, `app/src/main/java/${id.replace(/\./g, "/")}/MainActivity.kt`);
+    await import_fs_extra3.default.ensureDir(import_path3.default.dirname(file));
+    await import_fs_extra3.default.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 = import_path3.default.join(proj, `app/src/main/java/${id.replace(/\./g, "/")}/MainActivity.kt`);
+    await import_fs_extra3.default.ensureDir(import_path3.default.dirname(file));
+    await import_fs_extra3.default.writeFile(file, main);
+  }
+  async cmd(proj) {
+    if (await import_fs_extra3.default.pathExists(import_path3.default.join(proj, "gradlew"))) {
+      return "./gradlew";
+    }
+    if (await this.has("gradle")) {
+      return "gradle";
+    }
+    return null;
+  }
+  async has(cmd) {
+    try {
+      await (0, import_execa.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 import_fs_extra3.default.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
@@ -313,13 +505,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
   };
@@ -333,21 +529,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 (0, import_vite.build)({
-    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 (0, import_vite.build)({
+      build: {
+        outDir: dir(options),
+        minify: options.minify,
+        sourcemap: options.sourcemap,
+        emptyOutDir: true
+      },
+      define: {
+        __TABLE_PLATFORM__: JSON.stringify(platform)
+      }
+    });
+  } else {
+    await import_fs_extra4.default.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) {
@@ -362,6 +567,21 @@ 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";
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AndroidAdapter,