asterisk-voice-sdk 0.0.1

package/README.md

@@ -0,0 +1,82 @@
+# asterisk-voice-sdk
+
+SDK SIP cấp cao cho Asterisk/FreePBX trên React Native (wrapper `react-native-pjsip`).
+
+## Cài đặt
+
+```bash
+npm i asterisk-voice-sdk
+```
+
+## Peer dependencies
+
+- `react` (>= 18)
+- `react-native` (>= 0.73)
+ 
+## Dependencies (tự được cài kèm)
+
+- `react-native-pjsip` (>= 2.7.0)
+
+## Ví dụ sử dụng
+
+```ts
+import { VoiceClient } from 'asterisk-voice-sdk';
+
+const client = new VoiceClient();
+
+await client.initialize();
+
+client.on('registration', (s) => {
+  console.log('registration', s);
+});
+
+await client.register({
+  name: 'RN Test',
+  username: '1000',
+  domain: 'pbx.example.com',
+  password: 'secret',
+});
+
+const callId = await client.startCall('1001');
+// await client.hangup(callId);
+```
+
+## Build SDK & publish lên npm
+
+### Build (ra `dist/`)
+
+```bash
+cd "E:\VTS VOICE\packages\asterisk-voice-sdk"
+npm run build
+```
+
+### Kiểm tra gói trước khi publish (khuyến nghị)
+
+```bash
+cd "E:\VTS VOICE\packages\asterisk-voice-sdk"
+npm pack --dry-run
+```
+
+### Tăng version
+
+```bash
+cd "E:\VTS VOICE\packages\asterisk-voice-sdk"
+npm version patch
+# hoặc: npm version minor
+# hoặc: npm version major
+```
+
+### Publish
+
+```bash
+cd "E:\VTS VOICE\packages\asterisk-voice-sdk"
+npm login
+npm publish --access public
+```
+
+Nếu package là private (hoặc org của bạn mặc định private) thì dùng:
+
+```bash
+npm publish
+```
+

package/dist/TypedEmitter.d.ts

@@ -0,0 +1,14 @@
+export type Listener<T> = (payload: T) => void;
+/**
+ * Emitter nhỏ gọn cho React Native, tránh phụ thuộc Node `events`.
+ * - `on/off/once` kiểu-safe theo payload
+ * - Không dựa vào polyfill Node runtime
+ */
+export declare class TypedEmitter<EventMap extends Record<string, unknown>> {
+    private listeners;
+    on<K extends keyof EventMap>(event: K, listener: Listener<EventMap[K]>): this;
+    off<K extends keyof EventMap>(event: K, listener: Listener<EventMap[K]>): this;
+    once<K extends keyof EventMap>(event: K, listener: Listener<EventMap[K]>): this;
+    emit<K extends keyof EventMap>(event: K, payload: EventMap[K]): void;
+    removeAllListeners(): void;
+}

package/dist/TypedEmitter.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypedEmitter = void 0;
+/**
+ * Emitter nhỏ gọn cho React Native, tránh phụ thuộc Node `events`.
+ * - `on/off/once` kiểu-safe theo payload
+ * - Không dựa vào polyfill Node runtime
+ */
+class TypedEmitter {
+    constructor() {
+        this.listeners = new Map();
+    }
+    on(event, listener) {
+        let set = this.listeners.get(event);
+        if (!set) {
+            set = new Set();
+            this.listeners.set(event, set);
+        }
+        set.add(listener);
+        return this;
+    }
+    off(event, listener) {
+        var _a;
+        (_a = this.listeners.get(event)) === null || _a === void 0 ? void 0 : _a.delete(listener);
+        return this;
+    }
+    once(event, listener) {
+        const wrapped = (payload) => {
+            this.off(event, wrapped);
+            listener(payload);
+        };
+        this.on(event, wrapped);
+        return this;
+    }
+    emit(event, payload) {
+        const set = this.listeners.get(event);
+        if (!set || set.size === 0)
+            return;
+        for (const l of [...set]) {
+            l(payload);
+        }
+    }
+    removeAllListeners() {
+        this.listeners.clear();
+    }
+}
+exports.TypedEmitter = TypedEmitter;

package/dist/VoiceClient.d.ts

@@ -0,0 +1,79 @@
+import type { AsteriskRegistrationConfig, CallInfo, SipRegistrationState, VoiceSdkEventMap, VoiceSdkEventName } from './types';
+/**
+ * VoiceClient là lớp façade duy nhất đối tác cần dùng:
+ * - Che giấu chi tiết `Endpoint` / `Account` / `Call` của react-native-pjsip
+ * - Chuẩn hoá sự kiện (registration / incoming / callUpdated / callEnded)
+ * - Gom lookup cuộc gọi theo `callId` để API hangup/mute không cần object native
+ *
+ * Dùng composition với `EventEmitter` (thay vì kế thừa) để TypeScript suy luận kiểu ổn định trên mọi phiên bản `@types/node` / RN.
+ *
+ * Luồng khởi tạo bắt buộc:
+ * 1) `await client.initialize()` — nạp native PJSIP, đăng ký listener nền
+ * 2) `await client.register(credentials)` — tạo SIP account + REGISTER
+ * 3) `await client.startCall(destination)` hoặc chờ sự kiện `incoming` rồi `answerCall`
+ *
+ * Lý do tách bước (1) và (2): khi app Android ở background, JS có thể bị suspend
+ * nhưng native PJSIP vẫn chạy; khi user mở lại app cần `initialize()` để đồng bộ
+ * accounts/calls hiện có (theo khuyến nghị của tác giả react-native-pjsip).
+ */
+export declare class VoiceClient {
+    private readonly emitter;
+    private EndpointClass;
+    private endpoint;
+    /** Account SIP hiện tại (một client demo 1 account; có thể mở rộng map) */
+    private account;
+    /** Map callId -> instance Call mới nhất (PJSIP có thể emit object mới cùng id) */
+    private calls;
+    private boundRegistration?;
+    private boundCallReceived?;
+    private boundCallChanged?;
+    private boundCallTerminated?;
+    private boundConnectivity?;
+    private initialized;
+    on<K extends VoiceSdkEventName>(event: K, listener: (payload: VoiceSdkEventMap[K]) => void): this;
+    once<K extends VoiceSdkEventName>(event: K, listener: (payload: VoiceSdkEventMap[K]) => void): this;
+    off<K extends VoiceSdkEventName>(event: K, listener: (payload: VoiceSdkEventMap[K]) => void): this;
+    private emit;
+    /**
+     * Nạp module native và khởi động PJSIP.
+     * Phải gọi trước mọi thao tác SIP khác.
+     */
+    initialize(): Promise<void>;
+    private requireEndpoint;
+    private wireEndpointEvents;
+    private emitRegistrationSnapshot;
+    private toCallInfo;
+    /**
+     * Tạo account PJSIP và gửi REGISTER tới PBX.
+     * Với FreePBX: username thường là số máy nhánh, domain là domain SIP của endpoint.
+     */
+    register(config: AsteriskRegistrationConfig): Promise<void>;
+    /**
+     * Gỡ REGISTER và xoá account khỏi stack (không destroy Endpoint).
+     */
+    unregister(): Promise<void>;
+    /**
+     * Gọi ra: destination có thể là "1001" hoặc "sip:1001@domain".
+     * Thư viện sẽ chuẩn hoá URI dựa trên account.
+     */
+    startCall(destination: string, sipHeaders?: Record<string, string>): Promise<number>;
+    answerCall(callId: number): Promise<void>;
+    hangup(callId: number): Promise<void>;
+    hold(callId: number): Promise<void>;
+    unhold(callId: number): Promise<void>;
+    /** Tắt mic gửi đi (khác hold — không gửi re-INVITE hold SDP) */
+    mute(callId: number): Promise<void>;
+    unmute(callId: number): Promise<void>;
+    sendDtmf(callId: number, digits: string): Promise<void>;
+    useSpeaker(callId: number): Promise<void>;
+    useEarpiece(callId: number): Promise<void>;
+    getSnapshot(): {
+        registration: SipRegistrationState | null;
+        calls: CallInfo[];
+    };
+    private resolveCall;
+    /**
+     * Huỷ listener và giải phóng tài nguyên SIP (dùng khi logout user).
+     */
+    dispose(): Promise<void>;
+}

package/dist/VoiceClient.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoiceClient = void 0;
+const errors_1 = require("./errors");
+const TypedEmitter_1 = require("./TypedEmitter");
+/**
+ * VoiceClient là lớp façade duy nhất đối tác cần dùng:
+ * - Che giấu chi tiết `Endpoint` / `Account` / `Call` của react-native-pjsip
+ * - Chuẩn hoá sự kiện (registration / incoming / callUpdated / callEnded)
+ * - Gom lookup cuộc gọi theo `callId` để API hangup/mute không cần object native
+ *
+ * Dùng composition với `EventEmitter` (thay vì kế thừa) để TypeScript suy luận kiểu ổn định trên mọi phiên bản `@types/node` / RN.
+ *
+ * Luồng khởi tạo bắt buộc:
+ * 1) `await client.initialize()` — nạp native PJSIP, đăng ký listener nền
+ * 2) `await client.register(credentials)` — tạo SIP account + REGISTER
+ * 3) `await client.startCall(destination)` hoặc chờ sự kiện `incoming` rồi `answerCall`
+ *
+ * Lý do tách bước (1) và (2): khi app Android ở background, JS có thể bị suspend
+ * nhưng native PJSIP vẫn chạy; khi user mở lại app cần `initialize()` để đồng bộ
+ * accounts/calls hiện có (theo khuyến nghị của tác giả react-native-pjsip).
+ */
+class VoiceClient {
+    constructor() {
+        this.emitter = new TypedEmitter_1.TypedEmitter();
+        this.EndpointClass = null;
+        this.endpoint = null;
+        /** Account SIP hiện tại (một client demo 1 account; có thể mở rộng map) */
+        this.account = null;
+        /** Map callId -> instance Call mới nhất (PJSIP có thể emit object mới cùng id) */
+        this.calls = new Map();
+        this.initialized = false;
+    }
+    on(event, listener) {
+        this.emitter.on(event, listener);
+        return this;
+    }
+    once(event, listener) {
+        this.emitter.once(event, listener);
+        return this;
+    }
+    off(event, listener) {
+        this.emitter.off(event, listener);
+        return this;
+    }
+    emit(event, payload) {
+        this.emitter.emit(event, payload);
+    }
+    /**
+     * Nạp module native và khởi động PJSIP.
+     * Phải gọi trước mọi thao tác SIP khác.
+     */
+    async initialize() {
+        var _a;
+        if (this.initialized) {
+            throw new errors_1.VoiceSdkError('ALREADY_INITIALIZED', 'VoiceClient đã được initialize().');
+        }
+        let EndpointClass;
+        try {
+            // require động: tránh crash khi import SDK trong môi trường không có native (vd: web tests)
+            EndpointClass = require('react-native-pjsip').Endpoint;
+        }
+        catch (e) {
+            throw new errors_1.VoiceSdkError('MISSING_NATIVE', 'Không load được react-native-pjsip. Hãy cài dependency và rebuild app native.', { cause: e });
+        }
+        this.EndpointClass = EndpointClass;
+        this.endpoint = new EndpointClass();
+        const state = await this.endpoint.start();
+        /**
+         * Khi JS restart nhưng service Android vẫn giữ stack SIP, `start()` trả về
+         * accounts/calls hiện có — ta hydrate lại map để hangup/mute vẫn hoạt động.
+         */
+        for (const c of (_a = state.calls) !== null && _a !== void 0 ? _a : []) {
+            this.calls.set(c.getId(), c);
+        }
+        this.wireEndpointEvents();
+        this.initialized = true;
+    }
+    requireEndpoint() {
+        if (!this.endpoint) {
+            throw new errors_1.VoiceSdkError('NOT_INITIALIZED', 'Gọi initialize() trước.');
+        }
+        return this.endpoint;
+    }
+    wireEndpointEvents() {
+        const ep = this.requireEndpoint();
+        this.boundRegistration = (acc) => {
+            if (this.account && acc.getUsername() === this.account.getUsername()) {
+                this.emitRegistrationSnapshot(acc);
+            }
+        };
+        this.boundCallReceived = (call) => {
+            this.calls.set(call.getId(), call);
+            this.emit('incoming', this.toCallInfo(call));
+        };
+        this.boundCallChanged = (call) => {
+            this.calls.set(call.getId(), call);
+            this.emit('callUpdated', this.toCallInfo(call));
+        };
+        this.boundCallTerminated = (call) => {
+            const id = call.getId();
+            this.calls.delete(id);
+            this.emit('callEnded', { id });
+        };
+        this.boundConnectivity = (online) => {
+            this.emit('connectivity', { online });
+        };
+        ep.addListener('registration_changed', this.boundRegistration);
+        ep.addListener('call_received', this.boundCallReceived);
+        ep.addListener('call_changed', this.boundCallChanged);
+        ep.addListener('call_terminated', this.boundCallTerminated);
+        ep.addListener('connectivity_changed', this.boundConnectivity);
+    }
+    emitRegistrationSnapshot(account) {
+        const reg = account.getRegistration();
+        const payload = {
+            active: reg.isActive(),
+            statusText: reg.getStatus(),
+        };
+        this.emit('registration', payload);
+    }
+    toCallInfo(call) {
+        return {
+            id: call.getId(),
+            remoteLabel: call.getRemoteFormattedNumber(),
+            remoteUri: call.getRemoteUri(),
+            state: call.getState(),
+            stateText: call.getStateText(),
+        };
+    }
+    /**
+     * Tạo account PJSIP và gửi REGISTER tới PBX.
+     * Với FreePBX: username thường là số máy nhánh, domain là domain SIP của endpoint.
+     */
+    async register(config) {
+        var _a, _b, _c, _d;
+        const ep = this.requireEndpoint();
+        if (this.account) {
+            await ep.deleteAccount(this.account);
+            this.account = null;
+        }
+        const account = await ep.createAccount({
+            name: config.name,
+            username: config.username,
+            domain: config.domain,
+            password: config.password,
+            proxy: (_a = config.proxy) !== null && _a !== void 0 ? _a : null,
+            regServer: (_b = config.regServer) !== null && _b !== void 0 ? _b : null,
+            transport: (_c = config.transport) !== null && _c !== void 0 ? _c : null,
+            regTimeout: (_d = config.regTimeout) !== null && _d !== void 0 ? _d : null,
+            regHeaders: config.regHeaders,
+            regContactParams: config.regContactParams,
+        });
+        this.account = account;
+        this.emitRegistrationSnapshot(account);
+    }
+    /**
+     * Gỡ REGISTER và xoá account khỏi stack (không destroy Endpoint).
+     */
+    async unregister() {
+        const ep = this.requireEndpoint();
+        if (!this.account) {
+            return;
+        }
+        await ep.registerAccount(this.account, false);
+        await ep.deleteAccount(this.account);
+        this.account = null;
+    }
+    /**
+     * Gọi ra: destination có thể là "1001" hoặc "sip:1001@domain".
+     * Thư viện sẽ chuẩn hoá URI dựa trên account.
+     */
+    async startCall(destination, sipHeaders) {
+        const ep = this.requireEndpoint();
+        if (!this.account) {
+            throw new errors_1.VoiceSdkError('NO_ACCOUNT', 'Chưa register SIP. Gọi register() trước.');
+        }
+        const call = await ep.makeCall(this.account, destination, {}, sipHeaders ? { headers: sipHeaders } : {});
+        this.calls.set(call.getId(), call);
+        this.emit('callUpdated', this.toCallInfo(call));
+        return call.getId();
+    }
+    async answerCall(callId) {
+        const ep = this.requireEndpoint();
+        const call = this.resolveCall(callId);
+        await ep.answerCall(call);
+    }
+    async hangup(callId) {
+        const ep = this.requireEndpoint();
+        const call = this.resolveCall(callId);
+        await ep.hangupCall(call);
+    }
+    async hold(callId) {
+        const ep = this.requireEndpoint();
+        await ep.holdCall(this.resolveCall(callId));
+    }
+    async unhold(callId) {
+        const ep = this.requireEndpoint();
+        await ep.unholdCall(this.resolveCall(callId));
+    }
+    /** Tắt mic gửi đi (khác hold — không gửi re-INVITE hold SDP) */
+    async mute(callId) {
+        const ep = this.requireEndpoint();
+        await ep.muteCall(this.resolveCall(callId));
+    }
+    async unmute(callId) {
+        const ep = this.requireEndpoint();
+        await ep.unMuteCall(this.resolveCall(callId));
+    }
+    async sendDtmf(callId, digits) {
+        const ep = this.requireEndpoint();
+        await ep.dtmfCall(this.resolveCall(callId), digits);
+    }
+    async useSpeaker(callId) {
+        const ep = this.requireEndpoint();
+        await ep.useSpeaker(this.resolveCall(callId));
+    }
+    async useEarpiece(callId) {
+        const ep = this.requireEndpoint();
+        await ep.useEarpiece(this.resolveCall(callId));
+    }
+    getSnapshot() {
+        const registration = this.account === null
+            ? null
+            : {
+                active: this.account.getRegistration().isActive(),
+                statusText: this.account.getRegistration().getStatus(),
+            };
+        const calls = [...this.calls.values()].map((c) => this.toCallInfo(c));
+        return { registration, calls };
+    }
+    resolveCall(callId) {
+        const call = this.calls.get(callId);
+        if (!call) {
+            throw new errors_1.VoiceSdkError('CALL_NOT_FOUND', `Không tìm thấy cuộc gọi id=${callId}`, {
+                details: { knownIds: [...this.calls.keys()] },
+            });
+        }
+        return call;
+    }
+    /**
+     * Huỷ listener và giải phóng tài nguyên SIP (dùng khi logout user).
+     */
+    async dispose() {
+        var _a, _b, _c, _d, _e;
+        if (!this.endpoint) {
+            return;
+        }
+        const ep = this.endpoint;
+        if (this.boundRegistration) {
+            (_a = ep.removeListener) === null || _a === void 0 ? void 0 : _a.call(ep, 'registration_changed', this.boundRegistration);
+        }
+        if (this.boundCallReceived) {
+            (_b = ep.removeListener) === null || _b === void 0 ? void 0 : _b.call(ep, 'call_received', this.boundCallReceived);
+        }
+        if (this.boundCallChanged) {
+            (_c = ep.removeListener) === null || _c === void 0 ? void 0 : _c.call(ep, 'call_changed', this.boundCallChanged);
+        }
+        if (this.boundCallTerminated) {
+            (_d = ep.removeListener) === null || _d === void 0 ? void 0 : _d.call(ep, 'call_terminated', this.boundCallTerminated);
+        }
+        if (this.boundConnectivity) {
+            (_e = ep.removeListener) === null || _e === void 0 ? void 0 : _e.call(ep, 'connectivity_changed', this.boundConnectivity);
+        }
+        for (const c of [...this.calls.values()]) {
+            try {
+                await ep.hangupCall(c);
+            }
+            catch {
+                /* noop: có thể đã kết thúc */
+            }
+        }
+        this.calls.clear();
+        if (this.account) {
+            try {
+                await ep.deleteAccount(this.account);
+            }
+            catch {
+                /* noop */
+            }
+            this.account = null;
+        }
+        this.endpoint = null;
+        this.EndpointClass = null;
+        this.initialized = false;
+        this.emitter.removeAllListeners();
+    }
+}
+exports.VoiceClient = VoiceClient;

package/dist/errors.d.ts

@@ -0,0 +1,12 @@
+export type VoiceSdkErrorCode = 'NOT_INITIALIZED' | 'ALREADY_INITIALIZED' | 'MISSING_NATIVE' | 'NO_ACCOUNT' | 'CALL_NOT_FOUND' | 'SIP_ERROR';
+/**
+ * Lỗi có cấu trúc để app đối tác map sang toast / logging / analytics.
+ */
+export declare class VoiceSdkError extends Error {
+    readonly code: VoiceSdkErrorCode;
+    readonly details?: unknown;
+    constructor(code: VoiceSdkErrorCode, message: string, options?: {
+        cause?: unknown;
+        details?: unknown;
+    });
+}

package/dist/errors.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoiceSdkError = void 0;
+/**
+ * Lỗi có cấu trúc để app đối tác map sang toast / logging / analytics.
+ */
+class VoiceSdkError extends Error {
+    constructor(code, message, options) {
+        super(message);
+        this.name = 'VoiceSdkError';
+        this.code = code;
+        this.details = options === null || options === void 0 ? void 0 : options.details;
+        if ((options === null || options === void 0 ? void 0 : options.cause) !== undefined) {
+            this.cause = options.cause;
+        }
+    }
+}
+exports.VoiceSdkError = VoiceSdkError;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { VoiceClient } from './VoiceClient';
+export { VoiceSdkError } from './errors';
+export type { VoiceSdkErrorCode } from './errors';
+export type { AsteriskRegistrationConfig, CallInfo, SipRegistrationState, VoiceSdkEventMap, VoiceSdkEventName, } from './types';

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoiceSdkError = exports.VoiceClient = void 0;
+var VoiceClient_1 = require("./VoiceClient");
+Object.defineProperty(exports, "VoiceClient", { enumerable: true, get: function () { return VoiceClient_1.VoiceClient; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "VoiceSdkError", { enumerable: true, get: function () { return errors_1.VoiceSdkError; } });

package/dist/types.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Thông tin đăng ký SIP lên Asterisk/FreePBX (PJSIP).
+ *
+ * Với topo VIP của bạn (UDP 5060 / TLS 5061):
+ * - UDP: transport = 'UDP', proxy/regServer trỏ tới `sip:asterisk.example.com:5060`
+ * - TLS: transport = 'TLS', proxy/regServer trỏ tới `sip:asterisk.example.com:5061`
+ *
+ * `domain` thường là domain nội bộ PBX (vd: pbx.local) — phải khớp cấu hình
+ * auth trên FreePBX; nếu PBX chỉ dùng IP, nhiều site vẫn đặt domain = IP.
+ *
+ * (Không import type từ `react-native-pjsip` ở đây để file types.ts tách biệt hoàn toàn
+ * với native module — tiện cho tooling/IDE khi package chưa được cài.)
+ */
+export type AsteriskRegistrationConfig = {
+    name: string;
+    username: string;
+    domain: string;
+    password: string;
+    /** Ví dụ: sip:asterisk.example.com:5061 — quyết định đường đi thực tế tới tổng đài */
+    proxy?: string | null;
+    /** Máy chủ REGISTER (thường trùng proxy) */
+    regServer?: string | null;
+    transport?: 'UDP' | 'TCP' | 'TLS' | string | null;
+    regTimeout?: number | null;
+    regHeaders?: Record<string, string>;
+    regContactParams?: string;
+};
+export type SipRegistrationState = {
+    /** true khi session REGISTER đang active (theo isActive() của thư viện) */
+    active: boolean;
+    /** Chuỗi trạng thái từ PJSIP (phụ thuộc bản build native) */
+    statusText: string;
+};
+export type CallInfo = {
+    id: number;
+    /** Chuỗi hiển thị thân thiện nếu native cung cấp */
+    remoteLabel: string;
+    /** SIP URI đầu xa */
+    remoteUri: string;
+    /** Trạng thái PJSIP (RINGING, CONFIRMED, ...) */
+    state: string;
+    stateText: string;
+};
+export type VoiceSdkEventMap = {
+    /** Sau mỗi lần REGISTER/refresh thay đổi */
+    registration: SipRegistrationState;
+    /** Cuộc gọi đến (INVITE) */
+    incoming: CallInfo;
+    /** Mọi thay đổi trạng thái cuộc (re-INVITE, media, ...) */
+    callUpdated: CallInfo;
+    /** Cuộc kết thúc (BYE/CANCEL/fail) */
+    callEnded: {
+        id: number;
+    };
+    /** Mạng thiết bị (wifi/lte) đổi — có thể cần refresh registration */
+    connectivity: {
+        online: boolean;
+    };
+    /** Lỗi không map được sang Promise rejection (tuỳ bản native) */
+    error: {
+        message: string;
+        raw?: unknown;
+    };
+};
+export type VoiceSdkEventName = keyof VoiceSdkEventMap;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,36 @@
+{
+	"name": "asterisk-voice-sdk",
+	"version": "0.0.1",
+	"description": "SDK SIP cấp cao cho Asterisk/FreePBX trên React Native (wrapper react-native-pjsip)",
+	"license": "MIT",
+	"author": "hoanbv",
+	"keywords": ["asterisk", "voip", "sdk"],
+	"publishConfig": {
+		"access": "public"
+	},
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"react-native": "dist/index.js",
+	"files": [
+		"dist",
+		"README.md"
+	],
+	"scripts": {
+		"build": "tsc -p tsconfig.build.json",
+		"prepublishOnly": "npm run build",
+		"typecheck": "tsc -p tsconfig.json --noEmit"
+	},
+	"dependencies": {
+		"react-native-pjsip": ">=2.7.0"
+	},
+	"peerDependencies": {
+		"react": ">=18",
+		"react-native": ">=0.73"
+	},
+	"devDependencies": {
+		"@types/node": "^22.13.0",
+		"react": "19.2.3",
+		"react-native": "0.85.1",
+		"typescript": "^5.8.3"
+	}
+}