aio-capacitor 1.0.0

package/index.d.ts

@@ -0,0 +1,143 @@
+import { type I_logItem } from 'aio-utils';
+export type NotificationItem = {
+    id: number;
+    title: string;
+    body: string;
+    fireAt: number;
+    status: 'pending' | 'scheduled' | 'done';
+};
+export type I_speak = {
+    text: string;
+    lang?: 'fa-IR' | 'en-US';
+    rate?: number;
+    pitch?: number;
+};
+type PermissionName = "CAMERA" | "ACCESS_FINE_LOCATION" | "ACCESS_COARSE_LOCATION" | "POST_NOTIFICATIONS";
+export declare class AIOCapacitor {
+    onLog: ((log: I_logItem) => void) | undefined;
+    constructor(p?: {
+        onLog?: (log: I_logItem) => void;
+    });
+    getPlatform: () => 'web' | 'android' | 'ios';
+    isNative: () => boolean;
+    addLog: (log: I_logItem) => void;
+    vibrate: (p: {
+        pattern?: number[];
+        density?: 'light' | 'medium' | 'heavy';
+    }) => Promise<void>;
+    vibratePattern: (pattern: number[]) => Promise<void>;
+    vibrateImpact: (style?: 'light' | 'medium' | 'heavy') => Promise<void>;
+    getPermissions: (permissionNames: PermissionName[]) => Promise<void>;
+    speak: (p: {
+        text: string;
+        lang?: 'fa-IR' | 'en-US';
+        rate?: number;
+        pitch?: number;
+    }) => Promise<void>;
+    getSpeakList: () => Promise<any>;
+    storageSave: (name: string, value: any) => Promise<void>;
+    storageLoad: (name: string, def: any) => Promise<any>;
+    copy: (text: string) => Promise<void>;
+    paste: () => Promise<string>;
+    readText: (file: any) => Promise<any>;
+    readPath: (path: string, type: 'text' | 'imageSrc' | 'arrayBuffer') => Promise<{
+        success: boolean;
+        result: any;
+        message?: string;
+    }>;
+    writeFile: (data: string, path: string, encoding?: boolean) => Promise<any>;
+    save: (data: string | File | Blob, path: string) => Promise<{
+        success: boolean;
+        message: any;
+    }>;
+    shareText: (text: string, title?: string) => Promise<{
+        success: boolean;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+    }>;
+    shareFile: (file: Blob | File, fileName?: string) => Promise<any>;
+    getLocation: () => Promise<{
+        success: boolean;
+        latitude?: number;
+        longitude?: number;
+        accuracy?: number;
+        source?: "gps" | "cache" | "network";
+        error?: string;
+    }>;
+    awake: (state?: boolean) => Promise<any>;
+    isAwake: () => Promise<any>;
+}
+type DB = {
+    save: (item: NotificationItem) => Promise<void>;
+    getAll: () => Promise<NotificationItem[]>;
+    update: (id: number, patch: Partial<NotificationItem>) => Promise<void>;
+};
+export declare class NotificationService {
+    private db;
+    constructor(db: DB);
+    init(): Promise<void>;
+    notifyAt(date: number, title: string, body: string): Promise<number>;
+    private schedule;
+    private fireNow;
+    resync(): Promise<void>;
+    cancel(id: number): Promise<void>;
+    list(): Promise<any>;
+}
+export declare class Tracker {
+    private watchId;
+    onSuccess: (coord: {
+        latitude: number;
+        longitude: number;
+    }) => void;
+    onFailed: (message: string) => void;
+    onLog: ((log: I_logItem) => void) | undefined;
+    constructor(p: {
+        onSuccess: (coord: {
+            latitude: number;
+            longitude: number;
+        }) => void;
+        onFailed: (message: string) => void;
+        onLog?: (log: I_logItem) => void;
+    });
+    start(): void;
+    stop(): Promise<void>;
+    isTracking(): boolean;
+}
+export type I_FileRecordType = 'image' | 'file' | 'json' | 'text';
+export type I_FileRecord = {
+    id: string;
+    name: string;
+    path: string;
+    type: I_FileRecordType;
+    createdAt: number;
+    meta?: any;
+};
+export declare class FileRegistry {
+    private store;
+    private onChange;
+    private storageKey;
+    isNative: boolean;
+    private webStorage;
+    private initialRecords;
+    constructor(p: {
+        onChange: (v: I_FileRecord[]) => void;
+        storageKey: string;
+        mock?: I_FileRecord[];
+    });
+    private init;
+    private initialLoad;
+    private save;
+    add(p: {
+        type: I_FileRecordType;
+        path: string;
+        name?: string;
+        meta?: any;
+    }): I_FileRecord;
+    rename(id: string, newName?: string): I_FileRecord;
+    remove(id: string): void;
+    list: () => I_FileRecord[];
+    getById: (id: string) => I_FileRecord | null;
+}
+export {};

package/index.js

@@ -0,0 +1,547 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Capacitor } from '@capacitor/core';
+import { Preferences } from '@capacitor/preferences';
+import { Clipboard } from '@capacitor/clipboard';
+import { Camera } from '@capacitor/camera';
+import { Geolocation } from '@capacitor/geolocation';
+import { PushNotifications } from '@capacitor/push-notifications';
+import { TextToSpeech } from '@capacitor-community/text-to-speech';
+import { Filesystem, Directory, Encoding } from '@capacitor/filesystem';
+import { Haptics, ImpactStyle } from '@capacitor/haptics';
+import { Share } from '@capacitor/share';
+import { LocalNotifications } from '@capacitor/local-notifications';
+import { FileClass, Storage } from 'aio-utils';
+import { KeepAwake } from '@capacitor-community/keep-awake';
+export class AIOCapacitor {
+    constructor(p) {
+        this.getPlatform = () => Capacitor.getPlatform();
+        this.isNative = () => ['android', 'ios'].indexOf(Capacitor.getPlatform()) !== -1;
+        this.addLog = (log) => {
+            if (!this.onLog) {
+                return;
+            }
+            this.onLog(log);
+        };
+        this.vibrate = (p) => __awaiter(this, void 0, void 0, function* () {
+            if (p.pattern) {
+                yield this.vibratePattern(p.pattern);
+            }
+            else if (p.density) {
+                this.vibrateImpact(p.density);
+            }
+        });
+        this.vibratePattern = (pattern) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                for (const duration of pattern) {
+                    yield Haptics.vibrate();
+                    yield new Promise(r => setTimeout(r, duration));
+                }
+            }
+            catch (err) {
+                console.error('Haptics pattern error:', err);
+            }
+        });
+        this.vibrateImpact = (...args_1) => __awaiter(this, [...args_1], void 0, function* (style = 'medium') {
+            try {
+                const map = {
+                    light: ImpactStyle.Light,
+                    medium: ImpactStyle.Medium,
+                    heavy: ImpactStyle.Heavy,
+                };
+                yield Haptics.impact({ style: map[style] });
+            }
+            catch (err) {
+                console.error('Haptics impact error:', err);
+            }
+        });
+        this.getPermissions = (permissionNames) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e;
+            for (const permission of permissionNames) {
+                try {
+                    switch (permission) {
+                        case "CAMERA": {
+                            yield Camera.requestPermissions();
+                            (_a = this.addLog) === null || _a === void 0 ? void 0 : _a.call(this, { message: "CAMERA permission requested", status: "success" });
+                            break;
+                        }
+                        case "ACCESS_FINE_LOCATION":
+                        case "ACCESS_COARSE_LOCATION": {
+                            yield Geolocation.requestPermissions();
+                            (_b = this.addLog) === null || _b === void 0 ? void 0 : _b.call(this, { message: "LOCATION permission requested", status: "success" });
+                            break;
+                        }
+                        case "POST_NOTIFICATIONS": {
+                            yield PushNotifications.requestPermissions();
+                            (_c = this.addLog) === null || _c === void 0 ? void 0 : _c.call(this, { message: "NOTIFICATION permission requested", status: "success" });
+                            break;
+                        }
+                        default:
+                            (_d = this.addLog) === null || _d === void 0 ? void 0 : _d.call(this, { message: `Permission not supported: ${permission}`, status: "error" });
+                    }
+                }
+                catch (err) {
+                    (_e = this.addLog) === null || _e === void 0 ? void 0 : _e.call(this, {
+                        message: `Permission error for ${permission}: ${err === null || err === void 0 ? void 0 : err.message}`,
+                        status: "error"
+                    });
+                }
+            }
+        });
+        this.speak = (p) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield TextToSpeech.speak({
+                    text: p.text, lang: p.lang || 'en-US', rate: p.rate || 1, pitch: p.pitch === undefined ? 1 : p.pitch, volume: 1, category: 'ambient'
+                });
+            }
+            catch (err) {
+                console.error('TTS error:', err);
+            }
+        });
+        this.getSpeakList = () => __awaiter(this, void 0, void 0, function* () {
+            return yield TextToSpeech.getSupportedLanguages();
+        });
+        this.storageSave = (name, value) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield Preferences.set({ key: name, value: JSON.stringify(value) });
+            }
+            catch (err) {
+                console.error('storageSave error:', err);
+            }
+        });
+        this.storageLoad = (name, def) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { value } = yield Preferences.get({ key: name });
+                if (value === null || value === undefined) {
+                    yield Preferences.set({ key: name, value: JSON.stringify(def), });
+                    return def;
+                }
+                return JSON.parse(value);
+            }
+            catch (err) {
+                console.error('storageLoad error:', err);
+                return def;
+            }
+        });
+        this.copy = (text) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield Clipboard.write({ string: text, });
+            }
+            catch (err) {
+                console.error('Clipboard copy error:', err);
+            }
+        });
+        this.paste = () => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { value } = yield Clipboard.read();
+                return value || '';
+            }
+            catch (err) {
+                console.error('Clipboard paste error:', err);
+                return '';
+            }
+        });
+        this.readText = (file) => __awaiter(this, void 0, void 0, function* () {
+            return yield new FileClass().readInput(file, 'text');
+        });
+        this.readPath = (path, type) => __awaiter(this, void 0, void 0, function* () {
+            const fs = new FileClass();
+            try {
+                const res = yield Filesystem.readFile({ path, directory: Directory.Documents });
+                if (!(res === null || res === void 0 ? void 0 : res.data)) {
+                    return { success: false, result: null, message: 'Empty file' };
+                }
+                const blobRes = fs.base64ToBlob(res.data);
+                if (!blobRes.success) {
+                    return blobRes;
+                }
+                return fs.readInput(blobRes.result, type);
+            }
+            catch (e) {
+                return { success: false, result: null, message: (e === null || e === void 0 ? void 0 : e.message) || 'Storage read failed' };
+            }
+        });
+        this.writeFile = (data, path, encoding) => __awaiter(this, void 0, void 0, function* () { return yield Filesystem.writeFile({ path, data, directory: Directory.Documents, encoding: encoding ? Encoding.UTF8 : undefined }); });
+        this.save = (data, path) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const fs = new FileClass();
+                if (typeof data === 'string' && !fs.isUrl(data)) {
+                    try {
+                        yield this.writeFile(data, path, true);
+                        return { success: true, message: '' };
+                    }
+                    catch (err) {
+                        return { success: false, message: (err === null || err === void 0 ? void 0 : err.message) || err };
+                    }
+                }
+                else {
+                    const res1 = yield fs.toDataUrl(data);
+                    if (!res1.success) {
+                        return { success: false, message: res1.message };
+                    }
+                    const res2 = yield fs.toBase64(res1.result);
+                    if (!res2.success) {
+                        return { success: false, message: res2.message };
+                    }
+                    yield this.writeFile(res2.result, path);
+                    return { success: true, message: '' };
+                }
+            }
+            catch (err) {
+                return { success: false, message: (err === null || err === void 0 ? void 0 : err.message) || err };
+            }
+        });
+        this.shareText = (text, title) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield Share.share({ title: title || 'Share', text });
+                return { success: true };
+            }
+            catch (err) {
+                return { success: false, error: (err === null || err === void 0 ? void 0 : err.message) || err };
+            }
+        });
+        this.shareFile = (file_1, ...args_2) => __awaiter(this, [file_1, ...args_2], void 0, function* (file, fileName = `file_${Date.now()}`) {
+            try {
+                const res = yield new FileClass().toDataUrl(file);
+                if (!res.success) {
+                    return res;
+                }
+                yield Share.share({ title: fileName, url: res.result, dialogTitle: 'Share File' });
+                return { success: true };
+            }
+            catch (err) {
+                return { success: false, error: (err === null || err === void 0 ? void 0 : err.message) || err };
+            }
+        });
+        this.getLocation = () => __awaiter(this, void 0, void 0, function* () {
+            try {
+                // 1. اول سریع‌ترین حالت (کش / آخرین موقعیت)
+                try {
+                    const cached = yield Geolocation.getCurrentPosition({
+                        enableHighAccuracy: false,
+                        timeout: 2000,
+                        maximumAge: 60000
+                    });
+                    if (cached === null || cached === void 0 ? void 0 : cached.coords) {
+                        return {
+                            success: true,
+                            latitude: cached.coords.latitude,
+                            longitude: cached.coords.longitude,
+                            accuracy: cached.coords.accuracy,
+                            source: "cache"
+                        };
+                    }
+                }
+                catch (_) {
+                    // ignore cache failure
+                }
+                // 2. حالت دقیق (GPS + WiFi + Cell fusion)
+                const position = yield Geolocation.getCurrentPosition({
+                    enableHighAccuracy: true,
+                    timeout: 15000,
+                    maximumAge: 0
+                });
+                return {
+                    success: true,
+                    latitude: position.coords.latitude,
+                    longitude: position.coords.longitude,
+                    accuracy: position.coords.accuracy,
+                    source: "gps"
+                };
+            }
+            catch (err) {
+                // 3. fallback نهایی (هیچ چیزی جواب نداد)
+                return {
+                    success: false,
+                    error: (err === null || err === void 0 ? void 0 : err.message) || "Location unavailable"
+                };
+            }
+        });
+        this.awake = (state) => __awaiter(this, void 0, void 0, function* () {
+            let _awake;
+            if (state === true) {
+                _awake = true;
+            }
+            else if (state === false) {
+                _awake = false;
+            }
+            else {
+                const _isAwake = yield this.isAwake();
+                _awake = !_isAwake;
+            }
+            if (_awake) {
+                yield KeepAwake.allowSleep();
+            }
+            else {
+                yield KeepAwake.keepAwake();
+            }
+            return _awake;
+        });
+        this.isAwake = () => __awaiter(this, void 0, void 0, function* () { return yield KeepAwake.isKeptAwake(); });
+        this.onLog = p === null || p === void 0 ? void 0 : p.onLog;
+    }
+}
+export class NotificationService {
+    constructor(db) { this.db = db; }
+    // -------------------------
+    // INIT (CRITICAL)
+    // -------------------------
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield LocalNotifications.requestPermissions();
+            yield this.resync();
+        });
+    }
+    // -------------------------
+    // CREATE NOTIFICATION
+    // -------------------------
+    notifyAt(date, title, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = Date.now();
+            const item = {
+                id,
+                title,
+                body,
+                fireAt: date,
+                status: 'pending'
+            };
+            yield this.db.save(item);
+            yield this.schedule(item);
+            return id;
+        });
+    }
+    // -------------------------
+    // SCHEDULE TO OS
+    // -------------------------
+    schedule(item) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (item.fireAt <= Date.now()) {
+                yield this.fireNow(item);
+                return;
+            }
+            yield LocalNotifications.schedule({
+                notifications: [
+                    {
+                        id: item.id,
+                        title: item.title,
+                        body: item.body,
+                        schedule: {
+                            at: new Date(item.fireAt)
+                        }
+                    }
+                ]
+            });
+            yield this.db.update(item.id, {
+                status: 'scheduled'
+            });
+        });
+    }
+    // -------------------------
+    // IMMEDIATE NOTIFICATION
+    // -------------------------
+    fireNow(item) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield LocalNotifications.schedule({
+                notifications: [
+                    {
+                        id: item.id,
+                        title: item.title,
+                        body: item.body,
+                        schedule: { at: new Date() }
+                    }
+                ]
+            });
+            yield this.db.update(item.id, {
+                status: 'done'
+            });
+        });
+    }
+    // -------------------------
+    // RESYNC AFTER RESTART
+    // -------------------------
+    resync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const all = yield this.db.getAll();
+            const pending = all.filter(i => i.status !== 'done');
+            for (const item of pending) {
+                yield this.schedule(item);
+            }
+        });
+    }
+    // -------------------------
+    // CANCEL
+    // -------------------------
+    cancel(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield LocalNotifications.cancel({
+                notifications: [{ id }]
+            });
+            yield this.db.update(id, {
+                status: 'done'
+            });
+        });
+    }
+    // -------------------------
+    // LIST (DEBUG)
+    // -------------------------
+    list() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield LocalNotifications.getPending();
+        });
+    }
+}
+// const notifications = new NotificationService(db);
+// await notifications.init();
+// await notifications.notifyAt(
+//   Date.now() + 10000,
+//   "Hello",
+//   "This is persistent notification"
+// );
+export class Tracker {
+    constructor(p) {
+        this.watchId = null;
+        this.onSuccess = p.onSuccess;
+        this.onFailed = p.onFailed;
+        this.onLog = p.onLog || (() => { });
+    }
+    start() {
+        if (this.watchId) {
+            return;
+        }
+        Geolocation.watchPosition({
+            enableHighAccuracy: true,
+            timeout: 10000,
+            maximumAge: 3000
+        }, (position, err) => {
+            if (err) {
+                this.onFailed(err.message || 'Location Error');
+                return;
+            }
+            if (!position) {
+                return;
+            }
+            this.onSuccess({
+                latitude: position.coords.latitude,
+                longitude: position.coords.longitude
+            });
+        }).then((id) => {
+            this.watchId = id;
+        });
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.watchId) {
+                return;
+            }
+            yield Geolocation.clearWatch({
+                id: this.watchId
+            });
+            this.watchId = null;
+        });
+    }
+    isTracking() {
+        return !!this.watchId;
+    }
+}
+export class FileRegistry {
+    constructor(p) {
+        this.store = new Map();
+        this.storageKey = '';
+        this.isNative = false;
+        this.initialRecords = [];
+        this.init = () => __awaiter(this, void 0, void 0, function* () {
+            yield this.initialLoad();
+            this.onChange(this.list());
+        });
+        this.initialLoad = () => __awaiter(this, void 0, void 0, function* () {
+            let raw;
+            if (!this.isNative) {
+                raw = this.webStorage.load('records', this.initialRecords);
+            }
+            else {
+                raw = yield new AIOCapacitor().storageLoad(this.storageKey, this.initialRecords);
+            }
+            raw = raw === null || !raw ? [] : raw;
+            this.store = new Map(raw.map((i) => [i.id, i]));
+        });
+        this.save = () => __awaiter(this, void 0, void 0, function* () {
+            const raw = this.list();
+            if (!this.isNative) {
+                this.webStorage.save('records', raw);
+            }
+            else {
+                yield new AIOCapacitor().storageSave(this.storageKey, raw);
+            }
+            this.onChange(raw);
+        });
+        this.list = () => [...this.store.values()];
+        this.getById = (id) => this.store.get(id) || null;
+        if (p.mock) {
+            this.initialRecords = p.mock;
+        }
+        const a = new AIOCapacitor();
+        this.webStorage = new Storage(p.storageKey);
+        this.isNative = a.isNative();
+        this.storageKey = p.storageKey;
+        this.onChange = p.onChange;
+        this.init();
+    }
+    add(p) {
+        const { type, path, meta } = p;
+        if (['image', 'file', 'json', 'text'].indexOf(type) === -1) {
+            alert('file type should be image or file or json or text');
+            return;
+        }
+        if (!path) {
+            alert('missing file path');
+            return;
+        }
+        const id = crypto.randomUUID();
+        const createdAt = Date.now();
+        const name = p.name || window.prompt('inter file name');
+        if (!name || name === null) {
+            return;
+        }
+        const records = this.list();
+        if (records.find((o) => o.name === name)) {
+            const res = window.confirm('a file by this name is already exist, do you want to overwrite?');
+            if (!res) {
+                return;
+            }
+        }
+        const record = { id, createdAt, name, type, path, meta };
+        this.store.set(id, record);
+        this.save();
+        return record;
+    }
+    rename(id, newName) {
+        const record = this.getById(id);
+        if (!record) {
+            return;
+        }
+        const name = newName || window.prompt('inter file new name');
+        if (!name || name === null) {
+            return;
+        }
+        const records = this.list();
+        if (records.find((o) => o.name === name)) {
+            alert('a file by this name is already exist, you cannot rename');
+            return;
+        }
+        const newRecord = Object.assign(Object.assign({}, record), { name });
+        this.store.set(id, newRecord);
+        this.save();
+        return newRecord;
+    }
+    remove(id) {
+        this.store.delete(id);
+        this.save();
+    }
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "aio-capacitor",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "aio-utils": "latest",
+    "@capacitor/core": "^8.4.0",
+    "@capacitor/preferences": "^8.0.1",
+    "@capacitor/clipboard": "^8.0.1",
+    "@capacitor/camera": "^8.2.0",
+    "@capacitor/geolocation": "^8.2.0",
+    "@capacitor/push-notifications": "^8.1.1",
+    "@capacitor-community/text-to-speech": "^8.0.0",
+    "@capacitor/filesystem": "^8.1.2",
+    "@capacitor/haptics": "^8.0.2",
+    "@capacitor/share": "^8.0.1",
+    "@capacitor/local-notifications": "^8.2.0",
+    "@capacitor-community/keep-awake": "^8.0.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mohammadFeiz/aio-capacitor.git"
+  },
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/mohammadFeiz/aio-capacitor/issues"
+  },
+  "homepage": "https://github.com/mohammadFeiz/aio-capacitor#readme"
+}