@capacitor/background-runner 2.2.0 → 3.0.0

package/ios/Tests/RunnerEngineTests/ContextTests.swift

@@ -0,0 +1,393 @@
+// swiftlint:disable all
+
+import XCTest
+import JavaScriptCore
+@testable import RunnerEngine
+
+final class ContextTests: XCTestCase {
+    func testNullEval() throws {
+        let runner = Runner()
+        let context = try runner.createContext(name: "io.backgroundrunner.nulleval")
+        guard let value = try context.execute(code: "undefined") else {
+            XCTFail("value is null")
+            return
+        }
+
+        XCTAssertTrue(value.isUndefined)
+
+        guard let value = try context.execute(code: "const test = null; test;") else {
+            XCTFail("value is null")
+            return
+        }
+
+        XCTAssertTrue(value.isNull)
+    }
+
+    func testBoolEval() throws {
+        let runner = Runner()
+        let context = try runner.createContext(name: "io.backgroundrunner.booleval")
+
+        guard let value = try context.execute(code: "let test = (1 == 1); test;") else {
+            XCTFail("value is null")
+            return
+        }
+
+        XCTAssertTrue(value.isBoolean)
+        XCTAssertTrue(value.toBool())
+
+        guard let value = try context.execute(code: "test = (100 == 200); test;") else {
+            XCTFail("value is null")
+            return
+        }
+
+        XCTAssertTrue(value.isBoolean)
+        XCTAssertFalse(value.toBool())
+    }
+
+    func testIntegerEval() throws {
+        let runner = Runner()
+        let context = try runner.createContext(name: "io.backgroundrunner.inteval")
+
+        guard let value = try context.execute(code: "1 +2;") else {
+            XCTFail("value is null")
+            return
+        }
+
+        XCTAssertTrue(value.isNumber)
+        XCTAssertEqual(3, value.toInt32())
+    }
+
+    func testFloatEval() throws {
+        let runner = Runner()
+        let context = try runner.createContext(name: "io.backgroundrunner.dbleval")
+
+        guard let value = try context.execute(code: "10.8 + 2.77;") else {
+            XCTFail("value is null")
+            return
+        }
+
+        XCTAssertTrue(value.isNumber)
+        XCTAssertEqual(13.57, value.toDouble())
+    }
+
+    func testStringEval() throws {
+        let runner = Runner()
+        let context = try runner.createContext(name: "io.backgroundrunner.stringeval")
+
+        guard let value = try context.execute(code: "'hello' + ' ' + 'world';") else {
+            XCTFail("value is null")
+            return
+        }
+
+        XCTAssertTrue(value.isString)
+        XCTAssertEqual("hello world", value.toString())
+    }
+
+    func testConsoleAPI() throws {
+        let runner = Runner()
+        let context = try runner.createContext(name: "io.backgroundrunner.consoletests")
+
+        _ = try context.execute(code: "console.log('hello world');")
+        _ = try context.execute(code: "console.info('this message is for informational purposes');")
+        _ = try context.execute(code: "console.warn('this is a warning message');")
+        _ = try context.execute(code: "console.error('a problem has occurred');")
+        _ = try context.execute(code: "console.debug('this is a debugging statement');")
+    }
+
+    func testEventListeners() throws {
+        let runner = Runner()
+        let context = try runner.createContext(name: "io.backgroundrunner.eventlistenertests")
+
+        let expectation = XCTestExpectation(description: "Run callback on event")
+        let expectation2 = XCTestExpectation(description: "Run another callback on event")
+        let expectation3 = XCTestExpectation(description: "Run another callback on event with details")
+
+        var successCallbackCalled = 0
+        var altSuccessCallbackCalled = 0
+
+        let successCallback: @convention(block) () -> Void = {
+            successCallbackCalled += 1
+            expectation.fulfill()
+        }
+        let successCallback2: @convention(block) () -> Void = {
+            altSuccessCallbackCalled += 1
+            expectation2.fulfill()
+        }
+
+        let successCallbackDetails: @convention(block) (JSValue) -> Void = {details in
+            XCTAssertTrue(details.isObject)
+
+            let detailsObj = details.toDictionary() as? [String: String]
+            XCTAssertEqual(detailsObj?["name"], "John Doe")
+
+            expectation3.fulfill()
+        }
+
+        context.jsContext.setObject(successCallback, forKeyedSubscript: "successCallback" as NSString)
+        context.jsContext.setObject(successCallback2, forKeyedSubscript: "altSuccessCallback" as NSString)
+        context.jsContext.setObject(successCallbackDetails, forKeyedSubscript: "successCallbackDetails" as NSString)
+
+        _ = try context.execute(code: "addEventListener('myEvent', () => { successCallback(); });")
+        try  context.dispatchEvent(event: "myEvent")
+
+        wait(for: [expectation], timeout: 1)
+
+        _ = try context.execute(code: "addEventListener('myEvent', () => { altSuccessCallback(); });")
+        try context.dispatchEvent(event: "myEvent")
+
+        wait(for: [expectation2], timeout: 1)
+
+        XCTAssertEqual(successCallbackCalled, 1)
+        XCTAssertEqual(altSuccessCallbackCalled, 1)
+
+        var detailsObject = [String: String]()
+        detailsObject["name"] = "John Doe"
+
+        _ = try context.execute(code: "addEventListener('myEventDetails', (details) => { successCallbackDetails(details); });")
+        try context.dispatchEvent(event: "myEventDetails", details: detailsObject)
+
+        wait(for: [expectation3], timeout: 1)
+    }
+
+    func testCryptoAPI() throws {
+        let runner = Runner()
+        let context = try runner.createContext(name: "io.backgroundrunner.cryptotests")
+
+        guard let value = try context.execute(code: "const array = new Uint32Array(10);  crypto.getRandomValues(array); array;") else {
+            XCTFail("value is null")
+            return
+        }
+        if value.isNull || value.isUndefined {
+            XCTFail("value is null")
+            return
+        }
+
+        XCTAssertTrue(value.isObject)
+        XCTAssertEqual(10, value.toDictionary().count)
+
+        guard let value = try context.execute(code: "crypto.randomUUID();") else {
+            XCTFail("value is null")
+            return
+        }
+        if value.isNull || value.isUndefined {
+            XCTFail("value is null")
+            return
+        }
+
+        XCTAssertTrue(value.isString)
+        XCTAssertEqual(36, value.toString().count)
+
+    }
+
+    func testTimeoutAPI() throws {
+        let runner = Runner()
+        let context = try runner.createContext(name: "io.backgroundrunner.timeouttests")
+
+        let expectation = XCTestExpectation(description: "Run callback set on timeout")
+        let cancelExpectation = XCTestExpectation(description: "Cancel an already set up timeout")
+
+        let successCallback: @convention(block) () -> Void = {
+            expectation.fulfill()
+        }
+
+        let failureCallback: @convention(block) () -> Void = {
+            XCTFail("callback was called and not canceled")
+        }
+
+        context.jsContext.setObject(successCallback, forKeyedSubscript: "successCallback" as NSString)
+        context.jsContext.setObject(failureCallback, forKeyedSubscript: "failureCallback" as NSString)
+
+        guard let value = try context.execute(code: "setTimeout(() => { successCallback(); }, 2000)") else {
+            XCTFail("value is null")
+            return
+        }
+
+        XCTAssertGreaterThan(value.toInt32(), 0)
+
+        wait(for: [expectation], timeout: 2.5)
+
+        guard let value = try context.execute(code: "setTimeout(() => { failureCallback(); }, 4000)") else {
+            XCTFail("value is null")
+            return
+        }
+
+        let timerId = value.toInt32()
+
+        _ = Timer.scheduledTimer(withTimeInterval: TimeInterval(4.5), repeats: false) {_ in
+            cancelExpectation.fulfill()
+        }
+
+        _ = try context.execute(code: "clearTimeout(\(timerId))")
+
+        wait(for: [cancelExpectation], timeout: 5)
+
+    }
+
+    func testIntervalAPI() throws {
+        let runner = Runner()
+        let context = try runner.createContext(name: "io.backgroundrunner.intervaltests")
+
+        var calls = 0
+
+        let expectation = XCTestExpectation(description: "Run callback set on timeout")
+
+        let timerCallback: @convention(block) () -> Void = {
+            calls += 1
+        }
+
+        context.jsContext.setObject(timerCallback, forKeyedSubscript: "timerCallback" as NSString)
+
+        guard let value = try context.execute(code: "setInterval(() => { timerCallback(); }, 2000)") else {
+            XCTFail("value is null")
+            return
+        }
+
+        let timerId = value.toInt32()
+
+        _ = Timer.scheduledTimer(withTimeInterval: TimeInterval(8), repeats: false) {_ in
+            do {
+                _ = try context.execute(code: "clearInterval(\(timerId))")
+            } catch {
+                XCTFail("\(error)")
+            }
+        }
+
+        _ = Timer.scheduledTimer(withTimeInterval: TimeInterval(11), repeats: false) {_ in
+            expectation.fulfill()
+        }
+
+        wait(for: [expectation], timeout: 12)
+
+        XCTAssertEqual(calls, 4)
+
+    }
+
+    func testTextEncoderAPI() throws {
+        let runner = Runner()
+        let context = try runner.createContext(name: "io.backgroundrunner.textencodertests")
+
+        guard let value = try context.execute(code: "const encoder = new TextEncoder(); encoder.encode('€');") else {
+            XCTFail("value is null")
+            return
+        }
+
+        XCTAssertTrue(value.isObject)
+
+        guard let arrayObject = value.toDictionary() as? [String: Int] else {
+            XCTFail("could not get array object")
+            return
+        }
+        XCTAssertEqual(226, arrayObject["0"])
+        XCTAssertEqual(130, arrayObject["1"])
+        XCTAssertEqual(172, arrayObject["2"])
+    }
+
+    func testTextDecoderAPI() throws {
+        let runner = Runner()
+        let context = try runner.createContext(name: "io.backgroundrunner.textdecodertests")
+
+        guard let value = try context.execute(code: "const win1251decoder = new TextDecoder(\"windows-1251\"); win1251decoder.decode(new Uint8Array([ 207, 240, 232, 226, 229, 242, 44, 32, 236, 232, 240, 33]));") else {
+            XCTFail("value is null")
+            return
+        }
+
+        XCTAssertTrue(value.isString)
+        XCTAssertEqual("Привет, мир!", value.toString())
+
+        guard let value = try context.execute(code: "const decoder = new TextDecoder(); decoder.decode(new Uint8Array([240, 160, 174, 183]));") else {
+            XCTFail("value is null")
+            return
+        }
+
+        XCTAssertTrue(value.isString)
+        XCTAssertEqual("𠮷", value.toString())
+    }
+
+    func testErrorHandling() throws {
+        let runner = Runner()
+        let context = try runner.createContext(name: "io.backgroundrunner.testexceptions")
+
+        XCTAssertThrowsError(try context.execute(code: "() => { throw new Error('this method has an error'); }();")) { error in
+            XCTAssertTrue(String(describing: error).contains("SyntaxError: Unexpected token"))
+        }
+
+        XCTAssertThrowsError(try context.execute(code: "addEventListener(")) { error in
+            XCTAssertTrue(String(describing: error).contains("SyntaxError: Unexpected end of script"))
+        }
+
+        _ = try context.execute(code: "addEventListener('myThrowingEvent', () => { throw new Error('this event throws an error') })")
+
+        XCTAssertThrowsError(try context.dispatchEvent(event: "myThrowingEvent")) { error in
+            XCTAssertTrue(String(describing: error).contains("this event throws an error"))
+        }
+    }
+
+    func testFetchAPI() throws {
+        let runner = Runner()
+        let context = try runner.createContext(name: "io.backgroundrunner.testfetch")
+
+        let expectation = XCTestExpectation(description: "Run callback on completed (or failed) fetch")
+        let optionsExpectation = XCTestExpectation(description: "Run callback on completed options fetch")
+        let failureExpectation = XCTestExpectation(description: "Run catch callback on failed fetch")
+
+        let successCallback: @convention(block) () -> Void = {
+            expectation.fulfill()
+        }
+
+        let failureCallback: @convention(block) () -> Void = {
+            failureExpectation.fulfill()
+        }
+
+        let optionsSuccessCallback: @convention(block) () -> Void = {
+            optionsExpectation.fulfill()
+        }
+
+        context.jsContext.setObject(successCallback, forKeyedSubscript: "successCallback" as NSString)
+        context.jsContext.setObject(optionsSuccessCallback, forKeyedSubscript: "successCallback2" as NSString)
+        context.jsContext.setObject(failureCallback, forKeyedSubscript: "failureCallback" as NSString)
+
+        let basicFetchExample = """
+            fetch('https://jsonplaceholder.typicode.com/todos/1')
+                .then(response => response.json())
+                .then(json => { console.log(JSON.stringify(json)); successCallback(); })
+                .catch(err => { console.error(err);  successCallback(); });
+            """
+
+        _ = try context.execute(code: basicFetchExample)
+
+        wait(for: [expectation], timeout: 3)
+
+        let fetchFailureExample = """
+            fetch('https://blablabla.fake/todos/1')
+                .catch(err => { console.error(err);  failureCallback(); });
+            """
+
+        _ = try context.execute(code: fetchFailureExample)
+
+        wait(for: [failureExpectation], timeout: 3)
+
+        let fetchWithOptionsExample = """
+            fetch('https://jsonplaceholder.typicode.com/posts', {
+                method: 'POST',
+                body: JSON.stringify({
+                    title: 'foo',
+                    body: 'bar',
+                    userId: 1,
+                }),
+                headers: {
+                    'Content-type': 'application/json; charset=UTF-8',
+                }
+            })
+            .catch(err => { console.error(err); })
+            .then(response => response.json())
+            .then(json => { console.log(JSON.stringify(json)); successCallback2(); })
+            """
+
+        _ = try context.execute(code: fetchWithOptionsExample)
+
+        wait(for: [optionsExpectation], timeout: 3)
+
+    }
+}
+
+// swiftlint:enable all

package/ios/Tests/RunnerEngineTests/RunnerTests.swift

@@ -0,0 +1,32 @@
+// swiftlint:disable all
+import XCTest
+@testable import RunnerEngine
+
+final class RunnerTests: XCTestCase {
+    func testMultipleContexts() throws {
+        let runner = Runner()
+
+        var calls = 0
+        let count = Int.random(in: 20..<40)
+
+        let expectation = XCTestExpectation(description: "Run callback on completed timeout callbacks")
+
+        let timeoutCallback: @convention(block) () -> Void = {
+            calls += 1
+
+            if calls >= count {
+                expectation.fulfill()
+            }
+        }
+
+        for i in 1...count {
+            let context = try runner.createContext(name: "context #\(i)")
+            context.jsContext.setObject(timeoutCallback, forKeyedSubscript: "timeoutCallback" as NSString)
+            _ = try context.execute(code: "setTimeout(() => { timeoutCallback(); }, 2000)")
+        }
+
+        wait(for: [expectation], timeout: 5)
+    }
+
+}
+// swiftlint:enable all

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capacitor/background-runner",
-  "version": "2.2.0",
+  "version": "3.0.0",
   "description": "Capacitor Background Runner",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
@@ -11,7 +11,9 @@
     "android/src/main/",
     "android/build.gradle",
     "dist/",
-    "ios/Plugin/",
+    "ios/Sources",
+    "ios/Tests",
+    "Package.swift",
     "scripts/install_libs.js",
     "CapacitorBackgroundRunner.podspec"
   ],
@@ -30,18 +32,18 @@
   ],
   "scripts": {
     "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
-    "verify:ios": "cd ios && pod install && xcodebuild -workspace Plugin.xcworkspace -scheme Plugin -destination generic/platform=iOS && cd ..",
+    "verify:ios": "xcodebuild -scheme CapacitorBackgroundRunner -destination generic/platform=iOS && xcodebuild test -scheme CapacitorBackgroundRunner -destination 'platform=iOS Simulator,OS=18.6,name=iPhone 16 Pro'",
     "verify:android": "cd android && ./gradlew clean build test && cd ..",
     "verify:web": "npm run build",
     "lint": "npm run eslint && npm run prettier -- --check && npm run swiftlint -- lint",
     "fmt": "npm run eslint -- --fix && npm run prettier -- --write && npm run swiftlint -- --fix --format",
     "eslint": "eslint . --ext ts",
-    "prettier": "prettier \"**/*.{css,html,ts,js,java}\"",
+    "prettier": "prettier \"**/*.{css,html,ts,js,java}\" --plugin=prettier-plugin-java",
     "swiftlint": "node-swiftlint",
     "docgen": "docgen --api BackgroundRunnerPlugin --output-readme README.md --output-json dist/docs.json",
     "docgen-api": "docgen --api CapacitorAPI --output-readme API.md --output-json dist/docs-api.json && node ./scripts/combine_docs.js",
     "build-sdk": "./scripts/build-native-sdks.sh",
-    "build": "npm run clean && npm run docgen && npm run docgen-api && tsc && rollup -c rollup.config.js && npm run build-sdk && ./scripts/copy-native-sdks.sh && npm pack && mv ./capacitor-background-runner-*.tgz ../../ && ./scripts/copy-readme.sh",
+    "build": "npm run clean && npm run docgen && npm run docgen-api && tsc && rollup -c rollup.config.js --bundleConfigAsCjs && npm run build-sdk && ./scripts/copy-native-sdks.sh && npm pack && mv ./capacitor-background-runner-*.tgz ../../ && ./scripts/copy-readme.sh",
     "pack": "npm run build && ./scripts/copy-native-sdks.sh && npm pack && mv ./capacitor-background-runner-*.tgz ../../",
     "clean": "rimraf ./dist",
     "watch": "tsc --watch",
@@ -49,24 +51,24 @@
     "postinstall": "node ./scripts/install_libs.js"
   },
   "devDependencies": {
-    "@capacitor/android": "^6.0.0",
-    "@capacitor/cli": "^6.0.0",
-    "@capacitor/core": "^6.0.0",
-    "@capacitor/docgen": "^0.2.2",
-    "@capacitor/ios": "^6.0.0",
-    "@ionic/eslint-config": "^0.3.0",
-    "@ionic/prettier-config": "^1.0.1",
-    "@ionic/swiftlint-config": "^1.1.2",
-    "eslint": "^7.32.0",
-    "prettier": "~2.3.2",
-    "prettier-plugin-java": "~2.1.0",
-    "rimraf": "^3.0.2",
-    "rollup": "^2.79.1",
-    "swiftlint": "^1.0.2",
-    "typescript": "^5.1.6"
+    "@capacitor/android": "^8.0.0",
+    "@capacitor/cli": "^8.0.0",
+    "@capacitor/core": "^8.0.0",
+    "@capacitor/docgen": "^0.3.0",
+    "@capacitor/ios": "^8.0.0",
+    "@ionic/eslint-config": "^0.4.0",
+    "@ionic/prettier-config": "^4.0.0",
+    "@ionic/swiftlint-config": "^2.0.0",
+    "eslint": "^8.57.1",
+    "prettier": "^3.6.2",
+    "prettier-plugin-java": "^2.7.7",
+    "rimraf": "^6.1.2",
+    "rollup": "^4.53.3",
+    "swiftlint": "^2.0.0",
+    "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@capacitor/core": "^6.0.0 || ^7.0.0"
+    "@capacitor/core": ">=8.0.0"
   },
   "prettier": "@ionic/prettier-config",
   "swiftlint": "@ionic/swiftlint-config",
@@ -81,5 +83,5 @@
       "src": "android"
     }
   },
-  "gitHead": "9bd41296af96580537f63bb51a64f37a6e76a645"
+  "gitHead": "4559cf862ec7575f579a3bc38257efebe552daaf"
 }

package/scripts/install_libs.js

@@ -22,10 +22,8 @@ if (!fs.existsSync(androidGradlePath)) {
   return;
 }
 
-const searchText =
-  "dirs '../capacitor-cordova-android-plugins/src/main/libs', 'libs'";
-const insertText =
-  "\n\t\tdirs '../../node_modules/@capacitor/background-runner/android/src/main/libs', 'libs'";
+const searchText = "dirs '../capacitor-cordova-android-plugins/src/main/libs', 'libs'";
+const insertText = "\n\t\tdirs '../../node_modules/@capacitor/background-runner/android/src/main/libs', 'libs'";
 
 let gradleFile = fs.readFileSync(androidGradlePath).toString('utf-8');
 if (gradleFile.indexOf(insertText) != -1) {
@@ -33,18 +31,12 @@ if (gradleFile.indexOf(insertText) != -1) {
 }
 
 let insertIndex = gradleFile.indexOf(searchText) + searchText.length;
-gradleFile =
-  gradleFile.substring(0, insertIndex) +
-  insertText +
-  gradleFile.substring(insertIndex);
+gradleFile = gradleFile.substring(0, insertIndex) + insertText + gradleFile.substring(insertIndex);
 
 fs.writeFileSync(androidGradlePath, gradleFile);
 
 // remove old version of aar
-const oldReleaseAARPath = path.join(
-  workingDir,
-  'android/src/main/libs/android-js-engine-release.aar',
-);
+const oldReleaseAARPath = path.join(workingDir, 'android/src/main/libs/android-js-engine-release.aar');
 if (fs.existsSync(oldReleaseAARPath)) {
   fs.rmSync(oldReleaseAARPath);
 }

package/ios/Plugin/BackgroundRunnerPlugin.h

@@ -1,10 +0,0 @@
-#import <UIKit/UIKit.h>
-
-//! Project version number for Plugin.
-FOUNDATION_EXPORT double PluginVersionNumber;
-
-//! Project version string for Plugin.
-FOUNDATION_EXPORT const unsigned char PluginVersionString[];
-
-// In this header, you should import all the public headers of your framework using statements like #import <Plugin/PublicHeader.h>
-

package/ios/Plugin/BackgroundRunnerPlugin.m

@@ -1,12 +0,0 @@
-#import <Foundation/Foundation.h>
-#import <Capacitor/Capacitor.h>
-
-// Define the plugin using the CAP_PLUGIN Macro, and
-// each method the plugin supports using the CAP_PLUGIN_METHOD macro.
-CAP_PLUGIN(BackgroundRunnerPlugin, "BackgroundRunner",
-    CAP_PLUGIN_METHOD(dispatchEvent, CAPPluginReturnPromise);
-    CAP_PLUGIN_METHOD(registerBackgroundTask, CAPPluginReturnPromise);
-    CAP_PLUGIN_METHOD(checkPermissions, CAPPluginReturnPromise);
-    CAP_PLUGIN_METHOD(requestPermissions, CAPPluginReturnPromise);
-    CAP_PLUGIN_METHOD(removeNotificationListeners, CAPPluginReturnPromise);
-)