@simplysm/capacitor-plugin-intent 12.16.41

package/dist/src/Intent.d.ts

@@ -0,0 +1,64 @@
+import { IActivityResult, IIntentResult, IStartActivityForResultOptions } from "./IIntentPlugin";
+/**
+ * Android Intent 송수신 플러그인
+ * - 산업용 장치(바코드 스캐너, PDA 등) 연동용
+ */
+export declare abstract class Intent {
+    /**
+     * Intent 수신 등록
+     * @returns 해제 함수
+     *
+     * @example
+     * ```ts
+     * const unsub = await Intent.subscribe(
+     *   ["com.symbol.datawedge.api.RESULT_ACTION"],
+     *   (result) => console.log(result.extras)
+     * );
+     *
+     * // 해제
+     * unsub();
+     * ```
+     */
+    static subscribe(filters: string[], callback: (result: IIntentResult) => void): Promise<() => Promise<void>>;
+    /**
+     * 모든 Intent 수신기 해제
+     */
+    static unsubscribeAll(): Promise<void>;
+    /**
+     * Intent 전송
+     *
+     * @example
+     * ```ts
+     * await Intent.send({
+     *   action: "com.symbol.datawedge.api.ACTION",
+     *   extras: {
+     *     "com.symbol.datawedge.api.SOFT_SCAN_TRIGGER": "TOGGLE_SCANNING"
+     *   }
+     * });
+     * ```
+     */
+    static send(options: {
+        action: string;
+        extras?: Record<string, unknown>;
+    }): Promise<void>;
+    /**
+     * 앱 시작 Intent 가져오기
+     */
+    static getLaunchIntent(): Promise<IIntentResult>;
+    /**
+     * Activity 시작 후 결과 수신
+     *
+     * @example
+     * ```ts
+     * const result = await Intent.startActivityForResult({
+     *   action: "android.intent.action.GET_CONTENT",
+     *   type: "image/*",
+     * });
+     *
+     * if (result.resultCode === -1) { // RESULT_OK
+     *   console.log("Selected:", result.data);
+     * }
+     * ```
+     */
+    static startActivityForResult(options: IStartActivityForResultOptions): Promise<IActivityResult>;
+}

package/dist/src/Intent.js

@@ -0,0 +1,80 @@
+import { registerPlugin } from "@capacitor/core";
+const IntentPlugin = registerPlugin("Intent", {
+    web: async () => {
+        const { IntentWeb } = await import("./web/IntentWeb");
+        return new IntentWeb();
+    },
+});
+/**
+ * Android Intent 송수신 플러그인
+ * - 산업용 장치(바코드 스캐너, PDA 등) 연동용
+ */
+export class Intent {
+    /**
+     * Intent 수신 등록
+     * @returns 해제 함수
+     *
+     * @example
+     * ```ts
+     * const unsub = await Intent.subscribe(
+     *   ["com.symbol.datawedge.api.RESULT_ACTION"],
+     *   (result) => console.log(result.extras)
+     * );
+     *
+     * // 해제
+     * unsub();
+     * ```
+     */
+    static async subscribe(filters, callback) {
+        const { id } = await IntentPlugin.subscribe({ filters }, callback);
+        return async () => {
+            await IntentPlugin.unsubscribe({ id });
+        };
+    }
+    /**
+     * 모든 Intent 수신기 해제
+     */
+    static async unsubscribeAll() {
+        await IntentPlugin.unsubscribeAll();
+    }
+    /**
+     * Intent 전송
+     *
+     * @example
+     * ```ts
+     * await Intent.send({
+     *   action: "com.symbol.datawedge.api.ACTION",
+     *   extras: {
+     *     "com.symbol.datawedge.api.SOFT_SCAN_TRIGGER": "TOGGLE_SCANNING"
+     *   }
+     * });
+     * ```
+     */
+    static async send(options) {
+        await IntentPlugin.send(options);
+    }
+    /**
+     * 앱 시작 Intent 가져오기
+     */
+    static async getLaunchIntent() {
+        return await IntentPlugin.getLaunchIntent();
+    }
+    /**
+     * Activity 시작 후 결과 수신
+     *
+     * @example
+     * ```ts
+     * const result = await Intent.startActivityForResult({
+     *   action: "android.intent.action.GET_CONTENT",
+     *   type: "image/*",
+     * });
+     *
+     * if (result.resultCode === -1) { // RESULT_OK
+     *   console.log("Selected:", result.data);
+     * }
+     * ```
+     */
+    static async startActivityForResult(options) {
+        return await IntentPlugin.startActivityForResult(options);
+    }
+}

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./IIntentPlugin";
+export * from "./Intent";

package/dist/src/index.js

@@ -0,0 +1,2 @@
+export * from "./IIntentPlugin";
+export * from "./Intent";

package/dist/src/web/IntentWeb.d.ts

@@ -0,0 +1,19 @@
+import { WebPlugin } from "@capacitor/core";
+import { IActivityResult, IIntentPlugin, IIntentResult, IStartActivityForResultOptions } from "../IIntentPlugin";
+export declare class IntentWeb extends WebPlugin implements IIntentPlugin {
+    subscribe(_options: {
+        filters: string[];
+    }, _callback: (result: IIntentResult) => void): Promise<{
+        id: string;
+    }>;
+    unsubscribe(_options: {
+        id: string;
+    }): Promise<void>;
+    unsubscribeAll(): Promise<void>;
+    send(_options: {
+        action: string;
+        extras?: Record<string, unknown>;
+    }): Promise<void>;
+    getLaunchIntent(): Promise<IIntentResult>;
+    startActivityForResult(_options: IStartActivityForResultOptions): Promise<IActivityResult>;
+}

package/dist/src/web/IntentWeb.js

@@ -0,0 +1,24 @@
+import { WebPlugin } from "@capacitor/core";
+export class IntentWeb extends WebPlugin {
+    async subscribe(_options, _callback) {
+        alert("[Intent] 웹 환경에서는 Intent를 지원하지 않습니다.");
+        return await Promise.resolve({ id: "web-stub" });
+    }
+    async unsubscribe(_options) {
+        await Promise.resolve();
+    }
+    async unsubscribeAll() {
+        await Promise.resolve();
+    }
+    async send(_options) {
+        alert("[Intent] 웹 환경에서는 Intent를 지원하지 않습니다.");
+        await Promise.resolve();
+    }
+    async getLaunchIntent() {
+        return await Promise.resolve({});
+    }
+    async startActivityForResult(_options) {
+        alert("[Intent] 웹 환경에서는 startActivityForResult를 지원하지 않습니다.");
+        return await Promise.resolve({ resultCode: 0 });
+    }
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@simplysm/capacitor-plugin-intent",
+  "version": "12.16.41",
+  "description": "심플리즘 패키지 - Capacitor Intent Plugin",
+  "author": "김석래",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kslhunter/simplysm.git",
+    "directory": "packages/capacitor-plugin-intent"
+  },
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "capacitor": {
+    "android": {
+      "src": "android"
+    }
+  },
+  "peerDependencies": {
+    "@capacitor/core": "^7.4.4"
+  },
+  "devDependencies": {
+    "@capacitor/core": "^7.6.0"
+  }
+}

package/src/IIntentPlugin.ts

@@ -0,0 +1,65 @@
+export interface IIntentResult {
+  /** Intent action */
+  action?: string;
+  /** Extra data */
+  extras?: Record<string, unknown>;
+}
+
+export interface IStartActivityForResultOptions {
+  /** Intent action */
+  action: string;
+  /** Data URI */
+  uri?: string;
+  /** Extra data */
+  extras?: Record<string, unknown>;
+  /** Target package name */
+  package?: string;
+  /** Target component class name */
+  component?: string;
+  /** MIME type */
+  type?: string;
+}
+
+export interface IActivityResult {
+  /** Activity result code (RESULT_OK = -1, RESULT_CANCELED = 0) */
+  resultCode: number;
+  /** Result data URI */
+  data?: string;
+  /** Result extras */
+  extras?: Record<string, unknown>;
+}
+
+export interface IIntentPlugin {
+  /**
+   * Intent 수신기 등록
+   */
+  subscribe(
+    options: { filters: string[] },
+    callback: (result: IIntentResult) => void,
+  ): Promise<{ id: string }>;
+
+  /**
+   * 특정 Intent 수신기 해제
+   */
+  unsubscribe(options: { id: string }): Promise<void>;
+
+  /**
+   * 모든 Intent 수신기 해제
+   */
+  unsubscribeAll(): Promise<void>;
+
+  /**
+   * Intent 전송
+   */
+  send(options: { action: string; extras?: Record<string, unknown> }): Promise<void>;
+
+  /**
+   * 앱 시작 Intent 가져오기
+   */
+  getLaunchIntent(): Promise<IIntentResult>;
+
+  /**
+   * Activity 시작 후 결과 수신
+   */
+  startActivityForResult(options: IStartActivityForResultOptions): Promise<IActivityResult>;
+}

package/src/Intent.ts

@@ -0,0 +1,90 @@
+import { registerPlugin } from "@capacitor/core";
+import { IActivityResult, IIntentPlugin, IIntentResult, IStartActivityForResultOptions } from "./IIntentPlugin";
+
+const IntentPlugin = registerPlugin<IIntentPlugin>("Intent", {
+  web: async () => {
+    const { IntentWeb } = await import("./web/IntentWeb");
+    return new IntentWeb();
+  },
+});
+
+/**
+ * Android Intent 송수신 플러그인
+ * - 산업용 장치(바코드 스캐너, PDA 등) 연동용
+ */
+export abstract class Intent {
+  /**
+   * Intent 수신 등록
+   * @returns 해제 함수
+   *
+   * @example
+   * ```ts
+   * const unsub = await Intent.subscribe(
+   *   ["com.symbol.datawedge.api.RESULT_ACTION"],
+   *   (result) => console.log(result.extras)
+   * );
+   *
+   * // 해제
+   * unsub();
+   * ```
+   */
+  static async subscribe(
+    filters: string[],
+    callback: (result: IIntentResult) => void,
+  ): Promise<() => Promise<void>> {
+    const { id } = await IntentPlugin.subscribe({ filters }, callback);
+    return async () => {
+      await IntentPlugin.unsubscribe({ id });
+    };
+  }
+
+  /**
+   * 모든 Intent 수신기 해제
+   */
+  static async unsubscribeAll(): Promise<void> {
+    await IntentPlugin.unsubscribeAll();
+  }
+
+  /**
+   * Intent 전송
+   *
+   * @example
+   * ```ts
+   * await Intent.send({
+   *   action: "com.symbol.datawedge.api.ACTION",
+   *   extras: {
+   *     "com.symbol.datawedge.api.SOFT_SCAN_TRIGGER": "TOGGLE_SCANNING"
+   *   }
+   * });
+   * ```
+   */
+  static async send(options: { action: string; extras?: Record<string, unknown> }): Promise<void> {
+    await IntentPlugin.send(options);
+  }
+
+  /**
+   * 앱 시작 Intent 가져오기
+   */
+  static async getLaunchIntent(): Promise<IIntentResult> {
+    return await IntentPlugin.getLaunchIntent();
+  }
+
+  /**
+   * Activity 시작 후 결과 수신
+   *
+   * @example
+   * ```ts
+   * const result = await Intent.startActivityForResult({
+   *   action: "android.intent.action.GET_CONTENT",
+   *   type: "image/*",
+   * });
+   *
+   * if (result.resultCode === -1) { // RESULT_OK
+   *   console.log("Selected:", result.data);
+   * }
+   * ```
+   */
+  static async startActivityForResult(options: IStartActivityForResultOptions): Promise<IActivityResult> {
+    return await IntentPlugin.startActivityForResult(options);
+  }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./IIntentPlugin";
+export * from "./Intent";

package/src/web/IntentWeb.ts

@@ -0,0 +1,34 @@
+import { WebPlugin } from "@capacitor/core";
+import { IActivityResult, IIntentPlugin, IIntentResult, IStartActivityForResultOptions } from "../IIntentPlugin";
+
+export class IntentWeb extends WebPlugin implements IIntentPlugin {
+  async subscribe(
+    _options: { filters: string[] },
+    _callback: (result: IIntentResult) => void,
+  ): Promise<{ id: string }> {
+    alert("[Intent] 웹 환경에서는 Intent를 지원하지 않습니다.");
+    return await Promise.resolve({ id: "web-stub" });
+  }
+
+  async unsubscribe(_options: { id: string }): Promise<void> {
+    await Promise.resolve();
+  }
+
+  async unsubscribeAll(): Promise<void> {
+    await Promise.resolve();
+  }
+
+  async send(_options: { action: string; extras?: Record<string, unknown> }): Promise<void> {
+    alert("[Intent] 웹 환경에서는 Intent를 지원하지 않습니다.");
+    await Promise.resolve();
+  }
+
+  async getLaunchIntent(): Promise<IIntentResult> {
+    return await Promise.resolve({});
+  }
+
+  async startActivityForResult(_options: IStartActivityForResultOptions): Promise<IActivityResult> {
+    alert("[Intent] 웹 환경에서는 startActivityForResult를 지원하지 않습니다.");
+    return await Promise.resolve({ resultCode: 0 });
+  }
+}

package/tests/slice1-directory-and-config.spec.ts

@@ -0,0 +1,50 @@
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+
+const pkgRoot = resolve(import.meta.dirname, "..");
+const monoRoot = resolve(pkgRoot, "../..");
+
+describe("Slice 1: 디렉토리 이동 및 설정 파일 변경", () => {
+  // Scenario: 디렉토리 이동
+  test("패키지가 packages/capacitor-plugin-intent/ 경로에 존재한다", () => {
+    expect(existsSync(resolve(monoRoot, "packages/capacitor-plugin-intent"))).toBe(true);
+  });
+
+  test("packages/capacitor-plugin-broadcast/ 경로는 존재하지 않는다", () => {
+    expect(existsSync(resolve(monoRoot, "packages/capacitor-plugin-broadcast"))).toBe(false);
+  });
+
+  // Scenario: npm 패키지명 변경
+  test("package.json의 name이 @simplysm/capacitor-plugin-intent이다", () => {
+    const pkg = JSON.parse(readFileSync(resolve(pkgRoot, "package.json"), "utf-8"));
+    expect(pkg.name).toBe("@simplysm/capacitor-plugin-intent");
+  });
+
+  // Scenario: package.json 메타데이터 갱신
+  test("package.json의 description에 Intent가 포함된다", () => {
+    const pkg = JSON.parse(readFileSync(resolve(pkgRoot, "package.json"), "utf-8"));
+    expect(pkg.description).toContain("Intent");
+  });
+
+  test("package.json의 repository.directory가 packages/capacitor-plugin-intent이다", () => {
+    const pkg = JSON.parse(readFileSync(resolve(pkgRoot, "package.json"), "utf-8"));
+    expect(pkg.repository.directory).toBe("packages/capacitor-plugin-intent");
+  });
+
+  // Scenario: simplysm.js 설정 키 변경
+  test("simplysm.js에서 capacitor-plugin-intent 키로 패키지가 등록되어 있다", async () => {
+    const config = (await import(resolve(monoRoot, "simplysm.js"))).default();
+    expect(config.packages["capacitor-plugin-intent"]).toBeDefined();
+  });
+
+  test("simplysm.js에서 capacitor-plugin-broadcast 키는 존재하지 않는다", async () => {
+    const config = (await import(resolve(monoRoot, "simplysm.js"))).default();
+    expect(config.packages["capacitor-plugin-broadcast"]).toBeUndefined();
+  });
+
+  // Scenario: build.gradle namespace 변경
+  test("build.gradle namespace가 kr.co.simplysm.capacitor.intent이다", () => {
+    const gradle = readFileSync(resolve(pkgRoot, "android/build.gradle"), "utf-8");
+    expect(gradle).toContain('namespace "kr.co.simplysm.capacitor.intent"');
+  });
+});

package/tests/slice2-java-renaming.spec.ts

@@ -0,0 +1,34 @@
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+
+const pkgRoot = resolve(import.meta.dirname, "..");
+const javaBase = resolve(pkgRoot, "android/src/main/java/kr/co/simplysm/capacitor");
+
+describe("Slice 2: Java 소스 리네이밍", () => {
+  // Scenario: Java 패키지 경로 변경
+  test("IntentPlugin.java가 intent/ 경로에 존재한다", () => {
+    expect(existsSync(resolve(javaBase, "intent/IntentPlugin.java"))).toBe(true);
+  });
+
+  test("이전 broadcast/ 디렉토리는 존재하지 않는다", () => {
+    expect(existsSync(resolve(javaBase, "broadcast"))).toBe(false);
+  });
+
+  // Scenario: Java 패키지 선언 변경
+  test("package 선언이 kr.co.simplysm.capacitor.intent이다", () => {
+    const java = readFileSync(resolve(javaBase, "intent/IntentPlugin.java"), "utf-8");
+    expect(java).toContain("package kr.co.simplysm.capacitor.intent;");
+  });
+
+  // Scenario: Java 클래스명 변경
+  test("클래스명이 IntentPlugin이다", () => {
+    const java = readFileSync(resolve(javaBase, "intent/IntentPlugin.java"), "utf-8");
+    expect(java).toContain("public class IntentPlugin extends Plugin");
+  });
+
+  // Scenario: Capacitor 플러그인 등록명 변경
+  test('@CapacitorPlugin(name = "Intent")로 등록된다', () => {
+    const java = readFileSync(resolve(javaBase, "intent/IntentPlugin.java"), "utf-8");
+    expect(java).toContain('@CapacitorPlugin(name = "Intent")');
+  });
+});

package/tests/slice3-typescript-renaming.spec.ts

@@ -0,0 +1,76 @@
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+
+const pkgRoot = resolve(import.meta.dirname, "..");
+const srcDir = resolve(pkgRoot, "src");
+
+describe("Slice 3: TypeScript 소스 리네이밍", () => {
+  // Scenario: 메인 클래스 파일 및 클래스명 변경
+  test("Intent.ts에 abstract class Intent가 존재한다", () => {
+    expect(existsSync(resolve(srcDir, "Intent.ts"))).toBe(true);
+    const content = readFileSync(resolve(srcDir, "Intent.ts"), "utf-8");
+    expect(content).toContain("abstract class Intent");
+  });
+
+  test('registerPlugin<IIntentPlugin>("Intent", ...) 호출이 존재한다', () => {
+    const content = readFileSync(resolve(srcDir, "Intent.ts"), "utf-8");
+    expect(content).toContain('registerPlugin<IIntentPlugin>("Intent"');
+  });
+
+  // Scenario: 플러그인 인터페이스 파일 및 타입명 변경
+  test("IIntentPlugin.ts에 IIntentPlugin, IIntentResult 인터페이스가 존재한다", () => {
+    expect(existsSync(resolve(srcDir, "IIntentPlugin.ts"))).toBe(true);
+    const content = readFileSync(resolve(srcDir, "IIntentPlugin.ts"), "utf-8");
+    expect(content).toContain("interface IIntentPlugin");
+    expect(content).toContain("interface IIntentResult");
+  });
+
+  // Scenario: Web stub 파일 및 클래스명 변경
+  test("IntentWeb.ts에 class IntentWeb extends WebPlugin implements IIntentPlugin이 존재한다", () => {
+    expect(existsSync(resolve(srcDir, "web/IntentWeb.ts"))).toBe(true);
+    const content = readFileSync(resolve(srcDir, "web/IntentWeb.ts"), "utf-8");
+    expect(content).toContain("class IntentWeb extends WebPlugin implements IIntentPlugin");
+  });
+
+  // Scenario: index.ts export 경로 갱신
+  test('index.ts에 export * from "./Intent"와 export * from "./IIntentPlugin"이 존재한다', () => {
+    const content = readFileSync(resolve(srcDir, "index.ts"), "utf-8");
+    expect(content).toContain('export * from "./Intent"');
+    expect(content).toContain('export * from "./IIntentPlugin"');
+  });
+
+  // Scenario: subscribe API 보존
+  test("Intent.subscribe API가 존재하고 함수를 반환한다", async () => {
+    const mod = await import(resolve(srcDir, "Intent.ts"));
+    expect(typeof mod.Intent.subscribe).toBe("function");
+  });
+
+  // Scenario: send API 보존
+  test("Intent.send API가 존재한다", async () => {
+    const mod = await import(resolve(srcDir, "Intent.ts"));
+    expect(typeof mod.Intent.send).toBe("function");
+  });
+
+  // Scenario: getLaunchIntent API 보존
+  test("Intent.getLaunchIntent API가 존재한다", async () => {
+    const mod = await import(resolve(srcDir, "Intent.ts"));
+    expect(typeof mod.Intent.getLaunchIntent).toBe("function");
+  });
+
+  // Scenario: unsubscribeAll API 보존
+  test("Intent.unsubscribeAll API가 존재한다", async () => {
+    const mod = await import(resolve(srcDir, "Intent.ts"));
+    expect(typeof mod.Intent.unsubscribeAll).toBe("function");
+  });
+
+  // Scenario: Web 환경에서 stub 동작
+  test("IntentWeb이 IIntentPlugin의 모든 메서드를 구현한다", async () => {
+    const mod = await import(resolve(srcDir, "web/IntentWeb.ts"));
+    const web = new mod.IntentWeb();
+    expect(typeof web.subscribe).toBe("function");
+    expect(typeof web.unsubscribe).toBe("function");
+    expect(typeof web.unsubscribeAll).toBe("function");
+    expect(typeof web.send).toBe("function");
+    expect(typeof web.getLaunchIntent).toBe("function");
+  });
+});

package/tests/slice4-docs-and-deprecation.spec.ts

@@ -0,0 +1,31 @@
+import { readFileSync } from "fs";
+import { resolve } from "path";
+
+const pkgRoot = resolve(import.meta.dirname, "..");
+const monoRoot = resolve(pkgRoot, "../..");
+
+describe("Slice 4: 문서 갱신 및 npm deprecated", () => {
+  // Scenario: 패키지 README 갱신
+  test("패키지 README.md에 @simplysm/capacitor-plugin-intent 설치 안내가 있다", () => {
+    const readme = readFileSync(resolve(pkgRoot, "README.md"), "utf-8");
+    expect(readme).toContain("@simplysm/capacitor-plugin-intent");
+  });
+
+  test("패키지 README.md에 broadcast/Broadcast 문자열이 존재하지 않는다", () => {
+    const readme = readFileSync(resolve(pkgRoot, "README.md"), "utf-8");
+    // BroadcastReceiver는 Android API 용어이므로 제외하지 않음 — 여기서는 플러그인 이름 참조만 검사
+    expect(readme).not.toMatch(/capacitor-plugin-broadcast/);
+    expect(readme).not.toMatch(/\bBroadcast\b/);
+  });
+
+  // Scenario: 루트 README 갱신
+  test("루트 README.md에 capacitor-plugin-intent 항목이 존재한다", () => {
+    const readme = readFileSync(resolve(monoRoot, "README.md"), "utf-8");
+    expect(readme).toContain("capacitor-plugin-intent");
+  });
+
+  test("루트 README.md에 capacitor-plugin-broadcast 항목은 존재하지 않는다", () => {
+    const readme = readFileSync(resolve(monoRoot, "README.md"), "utf-8");
+    expect(readme).not.toContain("capacitor-plugin-broadcast");
+  });
+});