@depup/react-native-worklets 0.11.3-depup.0

package/apple/worklets/apple/PlatformLogger.mm

@@ -0,0 +1,31 @@
+#import <Foundation/Foundation.h>
+#import <worklets/Tools/PlatformLogger.h>
+
+namespace worklets {
+
+void PlatformLogger::log(const char *str)
+{
+  NSLog(@"%@", [NSString stringWithCString:str encoding:[NSString defaultCStringEncoding]]);
+}
+
+void PlatformLogger::log(const std::string &str)
+{
+  log(str.c_str());
+}
+
+void PlatformLogger::log(const double d)
+{
+  NSLog(@"%lf", d);
+}
+
+void PlatformLogger::log(const int i)
+{
+  NSLog(@"%i", i);
+}
+
+void PlatformLogger::log(const bool b)
+{
+  log(b ? "true" : "false");
+}
+
+} // namespace worklets

package/apple/worklets/apple/SlowAnimations.h

@@ -0,0 +1,8 @@
+#import <Foundation/Foundation.h>
+
+namespace worklets {
+
+CGFloat getUIAnimationDragCoefficient(void);
+CFTimeInterval calculateTimestampWithSlowAnimations(CFTimeInterval currentTimestamp);
+
+} // namespace worklets

package/apple/worklets/apple/SlowAnimations.mm

@@ -0,0 +1,45 @@
+#import <QuartzCore/QuartzCore.h>
+
+#import <worklets/apple/SlowAnimations.h>
+
+#if TARGET_IPHONE_SIMULATOR
+#import <dlfcn.h>
+#endif
+
+namespace worklets {
+
+CGFloat getUIAnimationDragCoefficient(void)
+{
+  static float (*UIAnimationDragCoefficient)(void) = NULL;
+#if TARGET_IPHONE_SIMULATOR
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    UIAnimationDragCoefficient = reinterpret_cast<float (*)(void)>(dlsym(RTLD_DEFAULT, "UIAnimationDragCoefficient"));
+  });
+#endif
+  return UIAnimationDragCoefficient ? UIAnimationDragCoefficient() : 1.f;
+}
+
+CFTimeInterval calculateTimestampWithSlowAnimations(CFTimeInterval currentTimestamp)
+{
+  static const auto MILLISECONDS_IN_SECOND = 1000;
+#if TARGET_IPHONE_SIMULATOR
+  static CFTimeInterval dragCoefChangedTimestamp = CACurrentMediaTime();
+  static CGFloat previousDragCoef = getUIAnimationDragCoefficient();
+
+  const CGFloat dragCoef = getUIAnimationDragCoefficient();
+  if (previousDragCoef != dragCoef) {
+    previousDragCoef = dragCoef;
+    dragCoefChangedTimestamp = CACurrentMediaTime();
+  }
+
+  const bool areSlowAnimationsEnabled = dragCoef != 1.f;
+  if (areSlowAnimationsEnabled) {
+    currentTimestamp = (dragCoefChangedTimestamp + (currentTimestamp - dragCoefChangedTimestamp) / dragCoef);
+  }
+#endif // TARGET_IPHONE_SIMULATOR
+  currentTimestamp *= MILLISECONDS_IN_SECOND;
+  return currentTimestamp;
+}
+
+} // namespace worklets

package/apple/worklets/apple/WorkletsDisplayLink.h

@@ -0,0 +1,21 @@
+#if TARGET_OS_OSX
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#import <React/RCTPlatformDisplayLink.h>
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+typedef RCTPlatformDisplayLink WorkletsDisplayLink;
+
+#else // TARGET_OS_OSX
+
+#import <QuartzCore/CADisplayLink.h>
+
+typedef CADisplayLink WorkletsDisplayLink;
+
+#endif // TARGET_OS_OSX

package/apple/worklets/apple/WorkletsModule.h

@@ -0,0 +1,28 @@
+#import <React/RCTCallInvokerModule.h>
+#import <React/RCTEventEmitter.h>
+#import <React/RCTInvalidating.h>
+
+#import <rnworklets/rnworklets.h>
+
+#import <worklets/NativeModules/WorkletsModuleProxy.h>
+
+#if __has_include(<React/RCTBundleConsumer.h>)
+// Bundle mode
+#import <React/NSBigStringBuffer.h>
+#import <React/RCTBundleConsumer.h>
+#endif // __has_include(<React/RCTBundleConsumer.h>)
+
+@interface WorkletsModule : RCTEventEmitter <
+                                NativeWorkletsModuleSpec,
+                                RCTCallInvokerModule,
+                                RCTInvalidating
+#if __has_include(<React/RCTBundleConsumer.h>)
+                                // Bundle mode
+                                ,
+                                RCTBundleConsumer
+#endif // __has_include(<React/RCTBundleConsumer.h>)
+                                >
+
+- (std::shared_ptr<worklets::WorkletsModuleProxy>)getWorkletsModuleProxy;
+
+@end

package/apple/worklets/apple/WorkletsModule.mm

@@ -0,0 +1,177 @@
+#import <worklets/NativeModules/JSIWorkletsModuleProxy.h>
+#import <worklets/Tools/RNRuntimeStatus.h>
+#import <worklets/Tools/ScriptBuffer.h>
+#import <worklets/Tools/SingleInstanceChecker.h>
+#import <worklets/WorkletRuntime/RNRuntimeWorkletDecorator.h>
+#import <worklets/apple/AnimationFrameQueue.h>
+#import <worklets/apple/AssertJavaScriptQueue.h>
+#import <worklets/apple/AssertTurboModuleManagerQueue.h>
+#import <worklets/apple/IOSUIScheduler.h>
+#import <worklets/apple/WorkletsModule.h>
+
+#import <React/RCTBridge+Private.h>
+#import <React/RCTCallInvoker.h>
+
+#ifdef WORKLETS_FETCH_PREVIEW_ENABLED
+#import <React/RCTNetworking.h>
+#import <ReactCommon/RCTTurboModule.h>
+#import <worklets/apple/Networking/WorkletsNetworking.h>
+#endif // WORKLETS_FETCH_PREVIEW_ENABLED
+
+using namespace worklets;
+
+@interface RCTBridge (JSIRuntime)
+- (void *)runtime;
+@end
+
+@implementation WorkletsModule {
+  AnimationFrameQueue *animationFrameQueue_;
+  std::shared_ptr<WorkletsModuleProxy> workletsModuleProxy_;
+  std::shared_ptr<RNRuntimeStatus> rnRuntimeStatus_;
+#ifdef WORKLETS_FETCH_PREVIEW_ENABLED
+  WorkletsNetworking *workletsNetworking_;
+#endif // WORKLETS_FETCH_PREVIEW_ENABLED
+#ifndef NDEBUG
+  SingleInstanceChecker<WorkletsModule> singleInstanceChecker_;
+#endif // NDEBUG
+}
+
+- (std::shared_ptr<WorkletsModuleProxy>)getWorkletsModuleProxy
+{
+  AssertJavaScriptQueue();
+  return workletsModuleProxy_;
+}
+
+@synthesize bundleManager = bundleManager_;
+@synthesize callInvoker = callInvoker_;
+#ifdef WORKLETS_FETCH_PREVIEW_ENABLED
+@synthesize moduleRegistry = moduleRegistry_;
+#endif // WORKLETS_FETCH_PREVIEW_ENABLED
+
+RCT_EXPORT_MODULE(WorkletsModule);
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(installTurboModule : (BOOL)bundleModeEnabled)
+{
+  react_native_assert(self.bridge != nullptr);
+  react_native_assert(self.bridge.runtime != nullptr);
+
+  AssertJavaScriptQueue();
+
+  jsi::Runtime &rnRuntime = *reinterpret_cast<facebook::jsi::Runtime *>(self.bridge.runtime);
+
+  std::string sourceURL = "";
+  std::shared_ptr<const ScriptBuffer> script = nullptr;
+
+  if (bundleModeEnabled) {
+    NSURL *url = bundleManager_.bundleURL;
+    script = [self getScript:url];
+    sourceURL = [[url absoluteString] UTF8String];
+  }
+
+#ifdef WORKLETS_FETCH_PREVIEW_ENABLED
+  id networkingModule = [moduleRegistry_ moduleForClass:RCTNetworking.class];
+  workletsNetworking_ = [[WorkletsNetworking alloc] init:networkingModule];
+#endif // WORKLETS_FETCH_PREVIEW_ENABLED
+
+  auto jsCallInvoker = callInvoker_.callInvoker;
+  auto uiScheduler = std::make_shared<IOSUIScheduler>();
+  auto isJavaScriptQueue = []() -> bool {
+    return IsJavaScriptQueue();
+  };
+  animationFrameQueue_ = [AnimationFrameQueue new];
+  auto runtimeBindings = [self getRuntimeBindings:rnRuntime bundleModeEnabled:bundleModeEnabled];
+  rnRuntimeStatus_ = std::make_shared<RNRuntimeStatus>();
+
+  workletsModuleProxy_ = std::make_shared<WorkletsModuleProxy>(
+      rnRuntime,
+      jsCallInvoker,
+      uiScheduler,
+      std::move(isJavaScriptQueue),
+      runtimeBindings,
+      BundleModeConfig{.enabled = static_cast<bool>(bundleModeEnabled), .script = script, .sourceURL = sourceURL},
+      rnRuntimeStatus_);
+
+  return @YES;
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(start)
+{
+  AssertJavaScriptQueue();
+  workletsModuleProxy_->start();
+  return @YES;
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(toggleSlowAnimationsOnUIRuntime)
+{
+  throw std::runtime_error("[Worklets] toggleSlowAnimationsOnUIRuntime is not supported on iOS.");
+}
+
+- (void)invalidate
+{
+  AssertTurboModuleManagerQueue();
+
+  [animationFrameQueue_ invalidate];
+
+  if (rnRuntimeStatus_) {
+    rnRuntimeStatus_->setDead();
+  }
+  workletsModuleProxy_.reset();
+
+  [super invalidate];
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  AssertJavaScriptQueue();
+  return std::make_shared<facebook::react::NativeWorkletsModuleSpecJSI>(params);
+}
+
+- (std::shared_ptr<const ScriptBuffer>)getScript:(NSURL *)url
+{
+  NSData *data = [NSData dataWithContentsOfURL:url];
+
+  if (!data) [[unlikely]] {
+    NSString *errorMsg = [NSString stringWithFormat:@"[Worklets] Failed to load worklets bundle from URL: %@", url];
+    NSLog(@"%@", errorMsg);
+    throw std::runtime_error([errorMsg UTF8String]);
+  }
+
+  auto str = std::string(reinterpret_cast<const char *>([data bytes]), [data length]);
+  auto bigString = std::make_shared<const JSBigStdString>(str);
+  return std::make_shared<const ScriptBuffer>(bigString);
+}
+
+- (std::shared_ptr<RuntimeBindings>)getRuntimeBindings:(jsi::Runtime &)rnRuntime
+                                     bundleModeEnabled:(BOOL)bundleModeEnabled
+{
+  return std::make_shared<RuntimeBindings>(RuntimeBindings{
+      .requestAnimationFrame = [animationFrameQueue =
+                                    animationFrameQueue_](std::function<void(const double)> &&callback) -> void {
+        [animationFrameQueue requestAnimationFrame:callback];
+      },
+      .nativeLoggingHook =
+          bundleModeEnabled ? extractNativeLoggingHookFromRNRuntime(rnRuntime) : RuntimeBindings::NativeLoggingHook{}
+#ifdef WORKLETS_FETCH_PREVIEW_ENABLED
+      ,
+      .abortRequest =
+          [workletsNetworking = workletsNetworking_](jsi::Runtime &rt, const jsi::Value &requestID) {
+            [workletsNetworking jsiAbortRequest:requestID.asNumber()];
+            return jsi::Value::undefined();
+          },
+      .clearCookies =
+          [workletsNetworking = workletsNetworking_](jsi::Runtime &rt, jsi::Function &&responseSender) {
+            [workletsNetworking jsiClearCookies:rt responseSender:(std::move(responseSender))];
+            return jsi::Value::undefined();
+          },
+      .sendRequest =
+          [workletsNetworking = workletsNetworking_](
+              jsi::Runtime &rt, const jsi::Value &query, jsi::Function &&responseSender) {
+            [workletsNetworking jsiSendRequest:rt jquery:query responseSender:(std::move(responseSender))];
+            return jsi::Value::undefined();
+          }
+#endif // WORKLETS_FETCH_PREVIEW_ENABLED
+  });
+}
+
+@end

package/bundleMode/index.d.ts

@@ -0,0 +1,6 @@
+declare module 'react-native-worklets/bundleMode' {
+  /** Use in React Native Community projects. */
+  export const bundleModeMetroConfig: any;
+  /** Use in Expo projects. */
+  export function getBundleModeMetroConfig(): any;
+}

package/bundleMode/index.js

@@ -0,0 +1,182 @@
+const path = require('path');
+
+const workletsPackageParentDir = path.resolve(__dirname, '../..');
+const reactNativeShimPath = path.join(__dirname, 'shims', 'reactNativeShim.js');
+const turboModuleRegistryShimPath = path.join(
+  __dirname,
+  'shims',
+  'turboModuleRegistryShim.js'
+);
+const turboModuleRegistryModuleName =
+  'react-native/Libraries/TurboModule/TurboModuleRegistry';
+const turboModuleRegistryFileSuffix = path.join(
+  'react-native',
+  'Libraries',
+  'TurboModule',
+  'TurboModuleRegistry.js'
+);
+
+function isResolvedTurboModuleRegistry(/** @type {any} */ result) {
+  return (
+    result?.type === 'sourceFile' &&
+    typeof result.filePath === 'string' &&
+    result.filePath.endsWith(turboModuleRegistryFileSuffix)
+  );
+}
+
+const workletsPackageName = 'react-native-worklets';
+const workletsDirPath = path.posix.join(workletsPackageName, '.worklets');
+const workletsSrcEntryPath = path.posix.join(
+  workletsPackageName,
+  'src',
+  'index.ts'
+);
+const workletsLibEntryPath = path.posix.join(
+  workletsPackageName,
+  'lib',
+  'module',
+  'index.js'
+);
+
+function bundleModeResolveRequest(
+  /** @type {any} */ context,
+  /** @type {string} */ moduleName,
+  /** @type {any} */ platform,
+  /** @type {any} */ userConfigResolveRequest
+) {
+  if (moduleName.startsWith(workletsDirPath)) {
+    const fullModuleName = path.join(workletsPackageParentDir, moduleName);
+    return { type: 'sourceFile', filePath: fullModuleName };
+  }
+  if (
+    moduleName === 'react-native' &&
+    context.originModulePath !== reactNativeShimPath
+  ) {
+    return { type: 'sourceFile', filePath: reactNativeShimPath };
+  }
+  if (
+    moduleName === turboModuleRegistryModuleName &&
+    context.originModulePath !== turboModuleRegistryShimPath
+  ) {
+    return { type: 'sourceFile', filePath: turboModuleRegistryShimPath };
+  }
+  const resolved = (userConfigResolveRequest || context.resolveRequest)(
+    context,
+    moduleName,
+    platform
+  );
+  if (
+    context.originModulePath !== turboModuleRegistryShimPath &&
+    isResolvedTurboModuleRegistry(resolved)
+  ) {
+    return { type: 'sourceFile', filePath: turboModuleRegistryShimPath };
+  }
+  return resolved;
+}
+
+/** Use in React Native Community projects. */
+const bundleModeMetroConfig = {
+  serializer: {
+    createModuleIdFactory: bundleModeCreateModuleIdFactory,
+  },
+  resolver: {
+    resolveRequest: (
+      /** @type {any} */ context,
+      /** @type {string} */ moduleName,
+      /** @type {any} */ platform
+    ) => {
+      if (moduleName.startsWith(workletsDirPath)) {
+        const fullModuleName = path.join(workletsPackageParentDir, moduleName);
+        return { type: 'sourceFile', filePath: fullModuleName };
+      }
+      if (
+        moduleName === 'react-native' &&
+        context.originModulePath !== reactNativeShimPath
+      ) {
+        return { type: 'sourceFile', filePath: reactNativeShimPath };
+      }
+      if (
+        moduleName === turboModuleRegistryModuleName &&
+        context.originModulePath !== turboModuleRegistryShimPath
+      ) {
+        return { type: 'sourceFile', filePath: turboModuleRegistryShimPath };
+      }
+      const resolved = context.resolveRequest(context, moduleName, platform);
+      if (
+        context.originModulePath !== turboModuleRegistryShimPath &&
+        isResolvedTurboModuleRegistry(resolved)
+      ) {
+        return { type: 'sourceFile', filePath: turboModuleRegistryShimPath };
+      }
+      return resolved;
+    },
+  },
+};
+
+// eslint-disable-next-line jsdoc/require-param, jsdoc/require-returns
+/** Use in Expo projects. */
+function getBundleModeMetroConfig(/** @type {any} */ config) {
+  config.serializer.createModuleIdFactory = bundleModeCreateModuleIdFactory;
+
+  const currentResolveRequest = config?.resolver?.resolveRequest;
+  config.resolver.resolveRequest = (
+    /** @type {any} */ context,
+    /** @type {string} */ moduleName,
+    /** @type {any} */ platform
+  ) =>
+    bundleModeResolveRequest(
+      context,
+      moduleName,
+      platform,
+      currentResolveRequest
+    );
+
+  const currentGetTransformOptions = config?.transformer?.getTransformOptions;
+  config.transformer.getTransformOptions = async (...args) => {
+    const options = currentGetTransformOptions
+      ? await currentGetTransformOptions(...args)
+      : {};
+    return {
+      ...options,
+      transform: {
+        ...options.transform,
+        inlineRequires: true,
+      },
+    };
+  };
+
+  return config;
+}
+
+function bundleModeCreateModuleIdFactory() {
+  let nextId = 0;
+  const idFileMap = new Map();
+  return (/** @type {string} */ moduleNameRaw) => {
+    const moduleName = moduleNameRaw.replace(/\\/g, '/');
+    if (idFileMap.has(moduleName)) {
+      return idFileMap.get(moduleName);
+    }
+    if (moduleName.includes(workletsPackageName)) {
+      if (
+        moduleName.endsWith(workletsSrcEntryPath) ||
+        moduleName.endsWith(workletsLibEntryPath)
+      ) {
+        const entryPointId = -2;
+        idFileMap.set(moduleName, entryPointId);
+        return entryPointId;
+      } else if (moduleName.includes(workletsDirPath)) {
+        const base = path.basename(moduleName, '.js');
+        const id = Number(base);
+        idFileMap.set(moduleName, id);
+        return id;
+      }
+    }
+    idFileMap.set(moduleName, nextId++);
+    return idFileMap.get(moduleName);
+  };
+}
+
+module.exports = {
+  getBundleModeMetroConfig,
+  bundleModeMetroConfig,
+};

package/bundleMode/shims/reactNativeShim.js

@@ -0,0 +1,21 @@
+'use strict';
+
+if (
+  globalThis.__RUNTIME_KIND === undefined ||
+  globalThis.__RUNTIME_KIND === 1
+) {
+  globalThis.__RUNTIME_KIND = 1;
+} else if (__DEV__) {
+  globalThis.__fbBatchedBridgeConfig = new Proxy(
+    {},
+    {
+      get() {
+        throw new Error(
+          '[Worklets] Accessing __fbBatchedBridgeConfig is not allowed on Worklet Runtimes. Perhaps you tried to access a Turbo Module?'
+        );
+      },
+    }
+  );
+}
+
+module.exports = require('react-native');

package/bundleMode/shims/turboModuleRegistryShim.js

@@ -0,0 +1,47 @@
+'use strict';
+
+/** @type {((name: string) => unknown) | undefined} */
+let get;
+/** @type {((name: string) => unknown) | undefined} */
+let getEnforcing;
+
+if (
+  globalThis.__RUNTIME_KIND === undefined ||
+  globalThis.__RUNTIME_KIND === 1
+) {
+  globalThis.__RUNTIME_KIND = 1;
+
+  const TurboModuleRegistry = require('react-native/Libraries/TurboModule/TurboModuleRegistry');
+
+  get = TurboModuleRegistry.get;
+  getEnforcing = TurboModuleRegistry.getEnforcing;
+} else {
+  /** @type {Map<string, unknown> | undefined} */
+  let TurboModulesPolyfill;
+
+  if (
+    globalThis.__workletsModuleProxy.getStaticFeatureFlag(
+      'FETCH_PREVIEW_ENABLED'
+    )
+  ) {
+    TurboModulesPolyfill = new Map();
+    TurboModulesPolyfill.set('Networking', {});
+
+    globalThis.TurboModules = TurboModulesPolyfill;
+  }
+
+  function getPolyfill(/** @type {string} */ name) {
+    if (__DEV__ && !TurboModulesPolyfill?.has(name)) {
+      throw new Error(
+        `[Worklets] Accessing TurboModules is not allowed on Worklet Runtimes. Requested: "${String(name)}".`
+      );
+    } else {
+      return TurboModulesPolyfill?.get(name);
+    }
+  }
+
+  get = getPolyfill;
+  getEnforcing = getPolyfill;
+}
+
+export { get, getEnforcing };

package/changes.json

@@ -0,0 +1,58 @@
+{
+  "bumped": {
+    "@babel/generator": {
+      "from": "^7.27.1",
+      "to": "^8.0.0"
+    },
+    "@babel/plugin-transform-arrow-functions": {
+      "from": "^7.27.1",
+      "to": "^8.0.1"
+    },
+    "@babel/plugin-transform-class-properties": {
+      "from": "^7.28.6",
+      "to": "^8.0.1"
+    },
+    "@babel/plugin-transform-classes": {
+      "from": "^7.28.6",
+      "to": "^8.0.1"
+    },
+    "@babel/plugin-transform-nullish-coalescing-operator": {
+      "from": "^7.28.6",
+      "to": "^8.0.1"
+    },
+    "@babel/plugin-transform-optional-chaining": {
+      "from": "^7.28.6",
+      "to": "^8.0.1"
+    },
+    "@babel/plugin-transform-shorthand-properties": {
+      "from": "^7.27.1",
+      "to": "^8.0.1"
+    },
+    "@babel/plugin-transform-template-literals": {
+      "from": "^7.27.1",
+      "to": "^8.0.1"
+    },
+    "@babel/plugin-transform-unicode-regex": {
+      "from": "^7.27.1",
+      "to": "^8.0.1"
+    },
+    "@babel/preset-typescript": {
+      "from": "^7.28.5",
+      "to": "^8.0.1"
+    },
+    "@babel/traverse": {
+      "from": "^7.27.1",
+      "to": "^8.0.4"
+    },
+    "@babel/types": {
+      "from": "^7.27.1",
+      "to": "^8.0.4"
+    },
+    "semver": {
+      "from": "^7.7.4",
+      "to": "^7.8.5"
+    }
+  },
+  "timestamp": "2026-07-26T00:57:50.717Z",
+  "totalUpdated": 13
+}

package/compatibility.json

@@ -0,0 +1,29 @@
+{
+  "nightly": {
+    "react-native": ["0.83", "0.84", "0.85", "0.86"]
+  },
+  "0.11.x": {
+    "react-native": ["0.83", "0.84", "0.85", "0.86"]
+  },
+  "0.10.x": {
+    "react-native": ["0.83", "0.84", "0.85", "0.86"]
+  },
+  "0.9.x": {
+    "react-native": ["0.83", "0.84", "0.85", "0.86"]
+  },
+  "0.8.x": {
+    "react-native": ["0.81", "0.82", "0.83", "0.84", "0.85"]
+  },
+  "0.7.x": {
+    "react-native": ["0.79", "0.80", "0.81", "0.82", "0.83", "0.84"]
+  },
+  "0.6.x": {
+    "react-native": ["0.78", "0.79", "0.80", "0.81", "0.82"]
+  },
+  "0.5.x": {
+    "react-native": ["0.78", "0.79", "0.80", "0.81"]
+  },
+  "0.4.x": {
+    "react-native": ["0.78", "0.79", "0.80", "0.81"]
+  }
+}

package/jest/pluginTestUtils.ts

@@ -0,0 +1,16 @@
+export function countOccurrences(haystack: string, needle: string): number {
+  if (!needle) {
+    return 0;
+  }
+  let count = 0;
+  let from = 0;
+  while (true) {
+    const idx = haystack.indexOf(needle, from);
+    if (idx === -1) {
+      break;
+    }
+    count++;
+    from = idx + needle.length;
+  }
+  return count;
+}