@cloudcare/cocos-sdk 0.1.1-alpha.1 → 0.1.1-alpha.3

package/extensions/creator3/project-configuration.cjs

@@ -0,0 +1,135 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const NATIVE = ['captureFps', 'maxImageDimension', 'imagePolicy', 'touchPrivacy'];
+const WEB = ['captureFps', 'maxImageDimension', 'quality', 'maxFrameBytes', 'canvasPrivacy', 'canvasId'];
+const SAMPLING = ['sessionReplaySamplingRate', 'sessionReplayOnErrorSamplingRate'];
+function object(value, name) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error(`${name} must be an object`);
+}
+function keys(value, allowed, name) {
+  object(value, name);
+  for (const key of Object.keys(value)) if (!allowed.includes(key)) throw new Error(`Unsupported ${name}.${key}`);
+}
+function number(value, min, max, name, integer = true) {
+  if (value !== undefined && (typeof value !== 'number' || !Number.isFinite(value) || value < min || value > max || integer && !Number.isInteger(value))) {
+    throw new Error(`${name} must be ${integer ? 'an integer' : 'a number'} between ${min} and ${max}`);
+  }
+}
+function validateReplay(replay) {
+  if (replay === undefined) return;
+  keys(replay, ['enabled', ...SAMPLING, 'native', 'web'], 'replay');
+  if (replay.enabled !== undefined && typeof replay.enabled !== 'boolean') throw new Error('replay.enabled must be boolean');
+  for (const field of SAMPLING) number(replay[field], 0, 100, `replay.${field}`, false);
+  for (const platform of ['native', 'web']) {
+    const options = replay[platform];
+    if (options === undefined || options === false) continue;
+    keys(options, platform === 'native' ? NATIVE : WEB, `replay.${platform}`);
+    number(options.captureFps, 1, 5, `replay.${platform}.captureFps`);
+    number(options.maxImageDimension, 1, 2048, `replay.${platform}.maxImageDimension`);
+    if (platform === 'native') {
+      if (options.touchPrivacy !== undefined && !['hide', 'show'].includes(options.touchPrivacy)) throw new Error('replay.native.touchPrivacy must be hide or show');
+      if (options.imagePolicy !== undefined) {
+        keys(options.imagePolicy, ['quality', 'maxFrameBytes'], 'replay.native.imagePolicy');
+        if (options.imagePolicy.quality !== undefined && !['low', 'medium', 'high'].includes(options.imagePolicy.quality)) throw new Error('replay.native.imagePolicy.quality must be low, medium, or high');
+        number(options.imagePolicy.maxFrameBytes, 1024, 1048576, 'replay.native.imagePolicy.maxFrameBytes');
+      }
+    } else {
+      if (options.canvasPrivacy !== undefined && !['block', 'allow'].includes(options.canvasPrivacy)) throw new Error('replay.web.canvasPrivacy must be block or allow');
+      if (options.canvasId !== undefined && (typeof options.canvasId !== 'string' || !options.canvasId.trim())) throw new Error('replay.web.canvasId must be a nonempty string');
+      if (options.quality !== undefined && !['low', 'medium', 'high'].includes(options.quality)) number(options.quality, 0, 1, 'replay.web.quality', false);
+      number(options.maxFrameBytes, 1024, 1048576, 'replay.web.maxFrameBytes');
+    }
+  }
+}
+function unified(project) {
+  return project.configuration !== undefined || Object.keys(project.replay || {}).some(key => key !== 'enabled');
+}
+function replayOptions(project, platform) {
+  validateReplay(project.replay);
+  const replay = project.replay;
+  if (!replay?.enabled || replay[platform] === false) return undefined;
+  return {
+    sessionReplaySamplingRate: replay.sessionReplaySamplingRate ?? 100,
+    sessionReplayOnErrorSamplingRate: replay.sessionReplayOnErrorSamplingRate ?? 0,
+    ...(replay[platform] || {}),
+  };
+}
+function nativeReplayEnabled(project) { validateReplay(project.replay); return project.replay?.enabled === true && project.replay.native !== false; }
+function resolveNativeConfiguration(project) {
+  validateReplay(project.replay);
+  if (project.configuration === undefined) return undefined;
+  object(project.configuration, 'configuration');
+  const config = JSON.parse(JSON.stringify(project.configuration));
+  keys(config, ['sdk', 'rum', 'logger', 'trace', 'autoTrack'], 'configuration');
+  object(config.sdk, 'configuration.sdk');
+  const replay = replayOptions(project, 'native');
+  if (replay) {
+    if (!config.rum) throw new Error('Native Replay requires configuration.rum');
+    config.replay = replay;
+  }
+  return config;
+}
+function resolveWebConfiguration(project) {
+  validateReplay(project.replay);
+  if (project.web?.enabled !== true) return undefined;
+  const override = project.web.configuration || {};
+  object(override, 'web.configuration');
+  if (!unified(project)) return override;
+  const native = resolveNativeConfiguration(project) || {};
+  // Copy only shared Browser settings. Native endpoints and application IDs stay out of Web artifacts.
+  const fields = {
+    sdk: ['serviceName', 'env', 'globalContext'],
+    rum: ['sessionSamplingRate', 'sampleRate', 'sessionOnErrorSamplingRate', 'sessionOnErrorSampleRate', 'globalContext'],
+    logger: ['logSamplingRate', 'sampleRate', 'enableCustomLog', 'logLevelFilters', 'globalContext'],
+    trace: ['traceSamplingRate', 'sampleRate', 'traceType'],
+  };
+  const config = {};
+  for (const [group, names] of Object.entries(fields)) {
+    if (native[group] !== undefined) config[group] = Object.fromEntries(names.filter(key => native[group][key] !== undefined).map(key => [key, native[group][key]]));
+    if (override[group] !== undefined) config[group] = { ...config[group], ...override[group] };
+  }
+  if (native.autoTrack || override.autoTrack) config.autoTrack = { ...native.autoTrack, ...override.autoTrack };
+  config.web = { ...override.web };
+  if (config.web.replay !== undefined) throw new Error('Configure Replay once at replay.web; remove web.configuration.web.replay');
+  const replay = replayOptions(project, 'web');
+  if (replay) {
+    if (!config.rum) throw new Error('Web Replay requires configuration.rum or web.configuration.rum');
+    config.web.replay = { enabled: true, ...replay };
+  }
+  return config;
+}
+function readProject(extensionRoot) {
+  const file = path.resolve(extensionRoot, '..', '..', 'cocos-sdk.config.json');
+  return fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, 'utf8')) : {};
+}
+function nativeConfigurationScript(configuration) {
+  return '\n/* COCOS_PROJECT_CONFIGURATION_BEGIN */\n'
+    + '(typeof window !== "undefined" ? window : globalThis).__FT_COCOS_CONFIGURATION__ = '
+    + (configuration ? JSON.stringify(configuration).replace(/</g, '\\u003c') : 'undefined')
+    + ';\n/* COCOS_PROJECT_CONFIGURATION_END */\n';
+}
+function configureNativeBuild(buildRoot, extensionRoot) {
+  if (!buildRoot || !fs.existsSync(buildRoot)) return;
+  const config = resolveNativeConfiguration(readProject(extensionRoot));
+  let found = false;
+  function visit(directory, depth) {
+    if (depth > 12) return;
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+      if (['node_modules', '.git', 'library', 'temp', 'cocos-sdk-native'].includes(entry.name)) continue;
+      const file = path.join(directory, entry.name);
+      if (entry.isDirectory()) visit(file, depth + 1);
+      else if (entry.isFile() && entry.name.endsWith('.js')) {
+        const source = fs.readFileSync(file, 'utf8');
+        if (!source.includes('__FT_COCOS_NATIVE_FACTORY__')) continue;
+        if (config?.replay && !source.includes('__FT_COCOS_REPLAY_FACTORY__')) throw new Error('Replay was enabled after installation. Rerun the installer with --replay and rebuild.');
+        const clean = source.replace(/\n?\/\* COCOS_PROJECT_CONFIGURATION_BEGIN \*\/[\s\S]*?\/\* COCOS_PROJECT_CONFIGURATION_END \*\/\n?/g, '');
+        fs.writeFileSync(file, clean + nativeConfigurationScript(config)); found = true;
+      }
+    }
+  }
+  visit(path.resolve(buildRoot), 0);
+  if (config && !found) throw new Error('Native SDK runtime was not included in the build. Rerun the installer and rebuild.');
+}
+module.exports = { resolveNativeConfiguration, resolveWebConfiguration, nativeReplayEnabled, readProject, nativeConfigurationScript, configureNativeBuild };

package/native/android/src/main/java/com/ft/sdk/cocos/FTCocosBridge.java

@@ -29,8 +29,6 @@ import java.util.Map;
 
 /** Cocos reflection entry point. All calls and responses are JSON envelopes. */
 public final class FTCocosBridge {
-    private static final String COCOS_SDK_VERSION_KEY = "sdk_package_cocos";
-
     private FTCocosBridge() {
     }
 
@@ -61,7 +59,7 @@ public final class FTCocosBridge {
     private static Object dispatch(String method, JSONObject payload) throws Exception {
         switch (method) {
             case "hybrid.attach":
-                attachHybrid(payload);
+                ensureNativeHostInitialized();
                 return null;
             case "sdk.configure":
                 configureSdk(payload);
@@ -130,13 +128,6 @@ public final class FTCocosBridge {
         }
     }
 
-    private static void attachHybrid(JSONObject json) throws Exception {
-        ensureNativeHostInitialized();
-        if (hasText(json, "sdkVersion")) {
-            FTSdk.appendGlobalContext(COCOS_SDK_VERSION_KEY, json.getString("sdkVersion"));
-        }
-    }
-
     private static void ensureNativeHostInitialized() {
         if (FTSdk.get() == null) {
             throw new IllegalStateException(
@@ -156,6 +147,10 @@ public final class FTCocosBridge {
         if (json.has("debug")) config.setDebug(json.getBoolean("debug"));
         if (hasText(json, "env")) config.setEnv(json.getString("env"));
         if (hasText(json, "serviceName")) config.setServiceName(json.getString("serviceName"));
+        if (json.has("allowWebViewHost")) {
+            config.setAllowWebViewHost(json.isNull("allowWebViewHost")
+                    ? null : stringArray(json.getJSONArray("allowWebViewHost")));
+        }
         addStringContext(json.optJSONObject("globalContext"), new StringContextSetter() {
             @Override public void set(String key, String value) { config.addGlobalContext(key, value); }
         });
@@ -187,6 +182,7 @@ public final class FTCocosBridge {
         if (json.has("enableNativeUserAction")) config.setEnableTraceUserAction(json.getBoolean("enableNativeUserAction"));
         if (json.has("enableNativeUserView")) config.setEnableTraceUserView(json.getBoolean("enableNativeUserView"));
         if (json.has("enableNativeUserResource")) config.setEnableTraceUserResource(json.getBoolean("enableNativeUserResource"));
+        if (json.has("enableTraceWebView")) config.setEnableTraceWebView(json.getBoolean("enableTraceWebView"));
         if (json.has("enableNativeCrash")) config.setEnableTrackAppCrash(json.getBoolean("enableNativeCrash"));
         if (json.has("enableNativeAnr")) config.setEnableTrackAppANR(json.getBoolean("enableNativeAnr"));
         if (json.has("enableNativeUiBlock")) {
@@ -210,6 +206,7 @@ public final class FTCocosBridge {
         else if (json.has("sampleRate")) config.setSamplingRate((float) json.getDouble("sampleRate"));
         if (json.has("enableLinkRumData")) config.setEnableLinkRumData(json.getBoolean("enableLinkRumData"));
         if (json.has("enableCustomLog")) config.setEnableCustomLog(json.getBoolean("enableCustomLog"));
+        if (json.has("enableWebViewLog")) config.setEnableWebViewLog(json.getBoolean("enableWebViewLog"));
         if (json.has("printCustomLogToConsole")) config.setPrintCustomLogToConsole(json.getBoolean("printCustomLogToConsole"));
         if (json.has("logCacheLimitCount")) config.setLogCacheLimitCount(json.getInt("logCacheLimitCount"));
         if ("discardOldest".equals(json.optString("discardStrategy"))) config.setLogCacheDiscardStrategy(LogCacheDiscard.DISCARD_OLDEST);

package/native/ios/FTCocosBridge.m

@@ -32,10 +32,6 @@
     FTExternalDataManager *rum = [FTExternalDataManager sharedManager];
     if ([method isEqualToString:@"hybrid.attach"]) {
         [self ensureNativeHostInitialized];
-        NSString *sdkVersion = [self text:arguments[@"sdkVersion"]];
-        if (sdkVersion.length > 0) {
-            [FTMobileAgent appendGlobalContext:@{ @"sdk_package_cocos": sdkVersion }];
-        }
         return nil;
     }
     if ([method isEqualToString:@"sdk.configure"]) {
@@ -53,6 +49,10 @@
         if (arguments[@"debug"]) config.enableSDKDebugLog = [arguments[@"debug"] boolValue];
         if ([self text:arguments[@"env"]].length > 0) config.env = arguments[@"env"];
         if ([self text:arguments[@"serviceName"]].length > 0) config.service = arguments[@"serviceName"];
+        if (arguments[@"allowWebViewHost"]) {
+            config.allowWebViewHost = arguments[@"allowWebViewHost"] == [NSNull null]
+                ? nil : arguments[@"allowWebViewHost"];
+        }
         if ([arguments[@"globalContext"] isKindOfClass:NSDictionary.class]) config.globalContext = arguments[@"globalContext"];
         [FTMobileAgent startWithConfigOptions:config];
         return nil;
@@ -90,6 +90,7 @@
         if (arguments[@"enableNativeUserAction"]) config.enableTraceUserAction = [arguments[@"enableNativeUserAction"] boolValue];
         if (arguments[@"enableNativeUserView"]) config.enableTraceUserView = [arguments[@"enableNativeUserView"] boolValue];
         if (arguments[@"enableNativeUserResource"]) config.enableTraceUserResource = [arguments[@"enableNativeUserResource"] boolValue];
+        if (arguments[@"enableTraceWebView"]) config.enableTraceWebView = [arguments[@"enableTraceWebView"] boolValue];
         if (arguments[@"enableNativeCrash"]) config.enableTrackAppCrash = [arguments[@"enableNativeCrash"] boolValue];
         if (arguments[@"enableNativeAnr"]) config.enableTrackAppANR = [arguments[@"enableNativeAnr"] boolValue];
         if (arguments[@"enableNativeUiBlock"]) {
@@ -157,6 +158,7 @@
         }
         if (arguments[@"enableLinkRumData"]) config.enableLinkRumData = [arguments[@"enableLinkRumData"] boolValue];
         if (arguments[@"enableCustomLog"]) config.enableCustomLog = [arguments[@"enableCustomLog"] boolValue];
+        if (arguments[@"enableWebViewLog"]) config.enableWebViewLog = [arguments[@"enableWebViewLog"] boolValue];
         if (arguments[@"printCustomLogToConsole"]) config.printCustomLogToConsole = [arguments[@"printCustomLogToConsole"] boolValue];
         if (arguments[@"logCacheLimitCount"]) config.logCacheLimitCount = [arguments[@"logCacheLimitCount"] intValue];
         config.discardType = [[self text:arguments[@"discardStrategy"]] isEqualToString:@"discardOldest"] ? FTDiscardOldest : FTDiscard;

package/native/ios/FTCocosBridge.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name             = 'FTCocosBridge'
-  s.version          = '0.1.1-alpha.1'
+  s.version          = '0.1.1-alpha.3'
   s.summary          = 'CloudCare Mobile SDK native bridge for Cocos Creator.'
   s.homepage         = 'https://github.com/GuanceCloud/datakit-cocos'
   s.license          = { :type => 'Apache-2.0' }

package/native/jsb-errors.js

@@ -0,0 +1,266 @@
+"use strict";
+(function() {
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __commonJS = function(cb, mod) {
+    return function __require() {
+      try {
+        return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+      } catch (e) {
+        throw mod = 0, e;
+      }
+    };
+  };
+
+  // packages/cocos/dist/creator2/core/version.js
+  var require_version = __commonJS({
+    "packages/cocos/dist/creator2/core/version.js": function(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.FT_COCOS_SDK_BRIDGE_INFO = exports.FT_COCOS_SDK_BRIDGE_INFO_KEY = exports.FT_COCOS_SDK_VERSION = void 0;
+      exports.FT_COCOS_SDK_VERSION = "0.1.1-alpha.3";
+      exports.FT_COCOS_SDK_BRIDGE_INFO_KEY = "sdk_bridge_info";
+      exports.FT_COCOS_SDK_BRIDGE_INFO = JSON.stringify({
+        cocos: exports.FT_COCOS_SDK_VERSION
+      });
+    }
+  });
+
+  // packages/cocos/dist/creator2/core/platform-runtime.js
+  var require_platform_runtime = __commonJS({
+    "packages/cocos/dist/creator2/core/platform-runtime.js": function(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.platformGlobal = platformGlobal;
+      exports.existingPlatformImplementation = existingPlatformImplementation;
+      exports.platformImplementation = platformImplementation;
+      var version_js_1 = require_version();
+      function platformGlobal() {
+        return typeof window !== "undefined" ? window : globalThis;
+      }
+      function existingPlatformImplementation(context, target) {
+        var _a;
+        if (target === void 0) {
+          target = platformGlobal();
+        }
+        var previous = (_a = target.__FT_COCOS_INSTANCES__) === null || _a === void 0 ? void 0 : _a[context.engine + ":" + context.platform];
+        if (previous && previous.version !== version_js_1.FT_COCOS_SDK_VERSION)
+          throw new Error("Cocos SDK versions must match on the same page");
+        return previous === null || previous === void 0 ? void 0 : previous.sdk;
+      }
+      function platformImplementation(context, target, create) {
+        if (target === void 0) {
+          target = platformGlobal();
+        }
+        var key = context.engine + ":" + context.platform;
+        var instances = target.__FT_COCOS_INSTANCES__ || (target.__FT_COCOS_INSTANCES__ = {});
+        var previous = existingPlatformImplementation(context, target);
+        if (previous)
+          return previous;
+        var factory = context.platform === "web" ? target.__FT_COCOS_WEB_FACTORY__ : target.__FT_COCOS_NATIVE_FACTORY__;
+        if (!create && (!factory || factory.protocol !== 1 || factory.version !== version_js_1.FT_COCOS_SDK_VERSION)) {
+          throw new Error(context.platform === "web" ? "Cocos Web runtime is missing or incompatible. Run the installer with --web and rebuild, or load /web/bootstrap before game scripts." : "Cocos native runtime is missing or incompatible. Rerun the SDK installer and rebuild the project.");
+        }
+        var sdk = create ? create() : factory.create(context, target);
+        instances[key] = { version: version_js_1.FT_COCOS_SDK_VERSION, sdk: sdk };
+        return sdk;
+      }
+    }
+  });
+
+  // packages/cocos/dist/creator2/core/observation.js
+  var require_observation = __commonJS({
+    "packages/cocos/dist/creator2/core/observation.js": function(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.FTObservationQueue = void 0;
+      exports.observationState = observationState;
+      function observationState(target) {
+        return target.__FT_COCOS_OBSERVATION_STATE__ || (target.__FT_COCOS_OBSERVATION_STATE__ = { reporting: 0 });
+      }
+      var FTObservationQueue = (
+        /** @class */
+        (function() {
+          function FTObservationQueue2(target) {
+            this.target = target;
+            this.pending = [];
+            this.size = 0;
+            this.generation = 0;
+            this.dropped = 0;
+            this.state = observationState(target);
+          }
+          FTObservationQueue2.prototype.enqueue = function(run, size) {
+            var _this = this;
+            if (size === void 0) {
+              size = 0;
+            }
+            if (this.state.reporting)
+              return false;
+            if (this.pending.length >= 128 || this.size + size > 1024 * 1024) {
+              this.dropped++;
+              return false;
+            }
+            this.pending.push({ run: run, size: size });
+            this.size += size;
+            if (this.timer !== void 0)
+              return true;
+            var generation = this.generation;
+            try {
+              var schedule = this.target.setTimeout || (typeof setTimeout === "function" ? setTimeout : void 0);
+              var cancel = this.target.clearTimeout || (typeof clearTimeout === "function" ? clearTimeout : void 0);
+              if (!schedule) {
+                this.dropped += this.pending.length;
+                this.pending = [];
+                this.size = 0;
+                return false;
+              }
+              this.cancel = cancel === null || cancel === void 0 ? void 0 : cancel.bind(this.target);
+              this.timer = schedule.call(this.target, function() {
+                _this.timer = void 0;
+                if (generation !== _this.generation)
+                  return;
+                var batch = _this.pending;
+                _this.pending = [];
+                _this.size = 0;
+                _this.state.reporting++;
+                try {
+                  for (var _i = 0, batch_1 = batch; _i < batch_1.length; _i++) {
+                    var task = batch_1[_i];
+                    if (generation !== _this.generation)
+                      break;
+                    try {
+                      task.run();
+                    } catch (_a) {
+                    }
+                  }
+                } finally {
+                  _this.state.reporting--;
+                }
+              }, 0);
+              return true;
+            } catch (_a) {
+              this.dropped += this.pending.length;
+              this.pending = [];
+              this.size = 0;
+              return false;
+            }
+          };
+          FTObservationQueue2.prototype.stop = function() {
+            var _a;
+            this.generation++;
+            this.pending = [];
+            this.size = 0;
+            if (this.timer !== void 0) {
+              try {
+                (_a = this.cancel) === null || _a === void 0 ? void 0 : _a.call(this, this.timer);
+              } catch (_b) {
+              }
+              this.timer = void 0;
+            }
+          };
+          return FTObservationQueue2;
+        })()
+      );
+      exports.FTObservationQueue = FTObservationQueue;
+    }
+  });
+
+  // packages/cocos/dist/creator2/native/jsb-errors.js
+  var require_jsb_errors = __commonJS({
+    "packages/cocos/dist/creator2/native/jsb-errors.js": function(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.installJsbErrorSource = installJsbErrorSource;
+      var observation_js_1 = require_observation();
+      function installJsbErrorSource(target) {
+        var jsb = target.jsb;
+        if (!(jsb === null || jsb === void 0 ? void 0 : jsb.onError) || target.__FT_COCOS_JSB_ERRORS__)
+          return;
+        var register = jsb.onError;
+        var handler;
+        var state = (0, observation_js_1.observationState)(target);
+        var observing = 0;
+        var subscribers = [];
+        var dispatch = function(location, message, stack) {
+          var _a;
+          var observations = [];
+          try {
+            if (!state.reporting && !observing) {
+              observing++;
+              try {
+                var timestampMs = Date.now();
+                for (var _i = 0, _b = subscribers.slice(); _i < _b.length; _i++) {
+                  var subscriber = _b[_i];
+                  try {
+                    observations.push({ subscriber: subscriber, observation: { timestampMs: timestampMs, context: (_a = subscriber.captureContext) === null || _a === void 0 ? void 0 : _a.call(subscriber) } });
+                  } catch (_c) {
+                  }
+                }
+              } finally {
+                observing--;
+              }
+            }
+          } catch (_d) {
+          }
+          try {
+            return handler === null || handler === void 0 ? void 0 : handler.call(this, location, message, stack);
+          } finally {
+            for (var _e = 0, observations_1 = observations; _e < observations_1.length; _e++) {
+              var _f = observations_1[_e], subscriber = _f.subscriber, observation = _f.observation;
+              if (!subscriber.active)
+                continue;
+              observing++;
+              try {
+                subscriber.callback(location, message, stack, observation);
+              } catch (_g) {
+              } finally {
+                observing--;
+              }
+            }
+          }
+        };
+        jsb.onError = function() {
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
+          if (args.length !== 1 || typeof args[0] !== "function")
+            return register.apply(this, args);
+          var callback = args[0];
+          var result = register.call(this, subscribers.length ? dispatch : callback);
+          handler = callback;
+          return result;
+        };
+        target.__FT_COCOS_JSB_ERRORS__ = {
+          protocol: 2,
+          subscribe: function(callback, captureContext) {
+            if (subscribers.length === 0)
+              register.call(jsb, dispatch);
+            var subscriber = { callback: callback, captureContext: captureContext, active: true };
+            subscribers.push(subscriber);
+            return function() {
+              if (!subscriber.active)
+                return;
+              subscriber.active = false;
+              var index = subscribers.indexOf(subscriber);
+              if (index >= 0)
+                subscribers.splice(index, 1);
+              if (subscribers.length === 0 && handler)
+                register.call(jsb, handler);
+            };
+          }
+        };
+      }
+    }
+  });
+
+  // packages/cocos/dist/creator2/native/error-bootstrap.js
+  var require_error_bootstrap = __commonJS({
+    "packages/cocos/dist/creator2/native/error-bootstrap.js": function(exports) {
+      Object.defineProperty(exports, "__esModule", { value: true });
+      var platform_runtime_js_1 = require_platform_runtime();
+      var jsb_errors_js_1 = require_jsb_errors();
+      (0, jsb_errors_js_1.installJsbErrorSource)((0, platform_runtime_js_1.platformGlobal)());
+    }
+  });
+  require_error_bootstrap();
+})();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cloudcare/cocos-sdk",
-  "version": "0.1.1-alpha.1",
-  "description": "Observability SDK integration for Cocos Creator 2.4 and 3.x",
+  "version": "0.1.1-alpha.3",
+  "description": "Observability SDK integration for Cocos Creator 2.4 and 3.x on Android, iOS, and Web",
   "license": "Apache-2.0",
   "author": "Guance Cloud",
   "repository": {
@@ -36,6 +36,20 @@
       "import": "./dist/creator3/core/plugin-api.js",
       "require": "./dist/creator2/core/plugin-api.js",
       "default": "./dist/creator2/core/plugin-api.js"
+    },
+    "./web/creator2": {
+      "types": "./dist/creator2/web/creator2.d.ts",
+      "default": "./dist/creator2/web/creator2.js"
+    },
+    "./web/creator3": {
+      "types": "./dist/creator3/web/creator3.d.ts",
+      "default": "./dist/creator3/web/creator3.js"
+    },
+    "./web/bootstrap": {
+      "types": "./dist/creator2/web/bootstrap.d.ts",
+      "import": "./dist/creator3/web/bootstrap.js",
+      "require": "./dist/creator2/web/bootstrap.js",
+      "default": "./dist/creator2/web/bootstrap.js"
     }
   },
   "files": [
@@ -48,7 +62,9 @@
     "README.md",
     "LICENSE",
     "THIRD_PARTY_NOTICES",
-    "plugin-api"
+    "plugin-api",
+    "web",
+    "runtime"
   ],
   "bin": {
     "guance-cocos": "bin/cli.cjs"