@momo-kits/anti-screenshot 0.1.0

package/AntiScreenshot.podspec

@@ -0,0 +1,43 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "AntiScreenshot"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://www.npmjs.com/.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm}"
+  s.private_header_files = "ios/**/*.h"
+
+
+  # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
+  # See https://github.com/facebook/react-native/blob/febf6b7f33fdb4904669f99d795eba4c0f95d7bf/scripts/cocoapods/new_architecture.rb#L79.
+  if respond_to?(:install_modules_dependencies, true)
+    install_modules_dependencies(s)
+  else
+    s.dependency "React-Core"
+
+    # Don't install the dependencies when we run `pod install` in the old architecture.
+    if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
+      s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
+      s.pod_target_xcconfig    = {
+          "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
+          "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
+          "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
+      }
+      s.dependency "React-RCTFabric"
+      s.dependency "React-Codegen"
+      s.dependency "RCT-Folly"
+      s.dependency "RCTRequired"
+      s.dependency "RCTTypeSafety"
+      s.dependency "ReactCommon/turbomodule/core"
+    end
+  end
+end

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2025 dung.pham2
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,45 @@
+# @momo-kits/anti-screenshot
+
+A React Native component that protects content from screenshots and screen recordings.
+
+## Installation
+
+```bash
+yarn add @momo-kits/anti-screenshot
+```
+
+## Usage
+
+```tsx
+import { AntiScreenshotView } from '@momo-kits/anti-screenshot';
+
+function SecureScreen() {
+  return (
+    <AntiScreenshotView style={{ flex: 1 }}>
+      <Text>This content is protected from screenshots</Text>
+      <Text>It will appear blank/black in screenshots and screen recordings</Text>
+    </AntiScreenshotView>
+  );
+}
+```
+
+## How it works
+
+### Android
+Uses a secure `SurfaceView` with `setSecure(true)` combined with bitmap rendering. Child views are rendered to a bitmap, which is then drawn onto the secure surface. Screenshots only capture the secure surface (which appears black).
+
+### iOS
+Uses the secure `UITextField` trick. When `secureTextEntry` is enabled, UITextField uses an internal view that prevents screenshot capture. The component extracts this internal view and uses it as a container for the protected content.
+
+## Props
+
+| Prop | Type | Description |
+|------|------|-------------|
+| `style` | `StyleProp<ViewStyle>` | Style for the container view |
+| `children` | `React.ReactNode` | Content to be protected from screenshots |
+
+All standard `View` props are also supported.
+
+## License
+
+MIT

package/android/build.gradle

@@ -0,0 +1,83 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['AntiScreenshot_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["AntiScreenshot_" + name]).toInteger()
+}
+
+android {
+  namespace "com.momokits.antiscreenshot"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+}
+
+react {
+  jsRootDir = file("../src/")
+  libraryName = "AntiScreenshotView"
+  codegenJavaPackageName = "com.momokits.antiscreenshot"
+}

package/android/gradle.properties

@@ -0,0 +1,4 @@
+AntiScreenshot_kotlinVersion=1.9.25
+AntiScreenshot_minSdkVersion=24
+AntiScreenshot_targetSdkVersion=35
+AntiScreenshot_compileSdkVersion=35

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/momokits/antiscreenshot/AntiScreenshotPackage.kt

@@ -0,0 +1,16 @@
+package com.momokits.antiscreenshot
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class AntiScreenshotPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return emptyList()
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return listOf(AntiScreenshotViewManager())
+    }
+}

package/android/src/main/java/com/momokits/antiscreenshot/AntiScreenshotView.kt

@@ -0,0 +1,284 @@
+package com.momokits.antiscreenshot
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.PixelFormat
+import android.graphics.PorterDuff
+import android.os.Handler
+import android.os.Looper
+import android.util.AttributeSet
+import android.view.SurfaceHolder
+import android.view.SurfaceView
+import android.view.View
+import android.view.ViewGroup
+import android.view.ViewTreeObserver
+import android.widget.FrameLayout
+
+/**
+ * AntiScreenshotView - A ViewGroup that protects its content from screenshots.
+ *
+ * Content inside this view will appear as black/blank in screenshots and screen recordings,
+ * while displaying normally on the device screen.
+ *
+ * How it works:
+ * 1. Child views are added to a hidden container
+ * 2. The container is rendered to a Bitmap
+ * 3. The Bitmap is drawn onto a secure SurfaceView
+ * 4. Screenshots only capture the secure surface (which appears black)
+ */
+class AntiScreenshotView @JvmOverloads constructor(
+    context: Context,
+    attrs: AttributeSet? = null,
+    defStyleAttr: Int = 0
+) : FrameLayout(context, attrs, defStyleAttr) {
+
+    private var secureSurface: SurfaceView? = null
+    private var contentContainer: FrameLayout? = null
+    private var isSurfaceReady = false
+    private val handler = Handler(Looper.getMainLooper())
+    private var redrawRunnable: Runnable? = null
+    private var contentBitmap: Bitmap? = null
+    private var isFirstDraw = true
+
+    private val surfaceCallback = object : SurfaceHolder.Callback {
+        override fun surfaceCreated(holder: SurfaceHolder) {
+            isSurfaceReady = true
+            scheduleRedraw()
+        }
+
+        override fun surfaceChanged(holder: SurfaceHolder, format: Int, width: Int, height: Int) {
+            scheduleRedraw()
+        }
+
+        override fun surfaceDestroyed(holder: SurfaceHolder) {
+            isSurfaceReady = false
+        }
+    }
+
+    private val globalLayoutListener = ViewTreeObserver.OnGlobalLayoutListener {
+        scheduleRedraw()
+    }
+
+    init {
+        initializeViews()
+    }
+
+    private fun initializeViews() {
+        // 1. Create content container - Initially VISIBLE for layout/measure
+        contentContainer = FrameLayout(context).apply {
+            layoutParams = LayoutParams(
+                LayoutParams.MATCH_PARENT,
+                LayoutParams.WRAP_CONTENT
+            )
+            visibility = View.VISIBLE
+        }
+
+        // 2. Create secure SurfaceView
+        secureSurface = SurfaceView(context).apply {
+            layoutParams = LayoutParams(
+                LayoutParams.MATCH_PARENT,
+                LayoutParams.MATCH_PARENT
+            )
+            setZOrderOnTop(true)
+            holder.setFormat(PixelFormat.TRANSLUCENT)
+            holder.addCallback(surfaceCallback)
+            setSecure(true)
+        }
+
+        // Add content container first (will be hidden after first render)
+        super.addView(contentContainer, -1, contentContainer!!.layoutParams)
+        // Add secure surface on top
+        super.addView(secureSurface, -1, secureSurface!!.layoutParams)
+
+        // Listen for layout changes
+        viewTreeObserver.addOnGlobalLayoutListener(globalLayoutListener)
+    }
+
+    private fun scheduleRedraw() {
+        redrawRunnable?.let { handler.removeCallbacks(it) }
+        redrawRunnable = Runnable { redrawContent() }
+        // Delay to ensure content is laid out
+        handler.postDelayed(redrawRunnable!!, if (isFirstDraw) 100 else 16)
+    }
+
+    /**
+     * Redraws the content onto the secure surface.
+     */
+    private fun redrawContent() {
+        if (!isSurfaceReady) return
+
+        val container = contentContainer ?: return
+        val surface = secureSurface ?: return
+        val holder = surface.holder
+
+        // Ensure content is visible and laid out before capturing
+        if (container.visibility != View.VISIBLE) {
+            container.visibility = View.VISIBLE
+            handler.postDelayed({ redrawContent() }, 50)
+            return
+        }
+
+        if (container.width <= 0 || container.height <= 0) {
+            // Wait for layout
+            handler.postDelayed({ redrawContent() }, 50)
+            return
+        }
+
+        try {
+            // Create or recreate bitmap if needed
+            val bitmapWidth = container.width
+            val bitmapHeight = container.height
+
+            if (contentBitmap == null ||
+                contentBitmap?.width != bitmapWidth ||
+                contentBitmap?.height != bitmapHeight ||
+                contentBitmap?.isRecycled == true
+            ) {
+                contentBitmap?.recycle()
+                contentBitmap = Bitmap.createBitmap(
+                    bitmapWidth,
+                    bitmapHeight,
+                    Bitmap.Config.ARGB_8888
+                )
+            }
+
+            val bitmap = contentBitmap ?: return
+
+            // Draw content to bitmap
+            val bitmapCanvas = Canvas(bitmap)
+            bitmapCanvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR)
+            container.draw(bitmapCanvas)
+
+            // Draw bitmap to secure surface
+            val canvas = holder.lockCanvas()
+            if (canvas != null) {
+                try {
+                    canvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR)
+                    canvas.drawBitmap(bitmap, 0f, 0f, null)
+                } finally {
+                    holder.unlockCanvasAndPost(canvas)
+                }
+            }
+
+            // Hide original content after drawing to surface
+            container.visibility = View.INVISIBLE
+            isFirstDraw = false
+
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+    }
+
+    /**
+     * Force redraw - makes content visible briefly to capture updates.
+     */
+    fun forceRedraw() {
+        contentContainer?.visibility = View.VISIBLE
+        scheduleRedraw()
+    }
+
+    // Override addView to redirect children to content container
+    override fun addView(child: View?) {
+        if (contentContainer != null && child != secureSurface && child != contentContainer) {
+            contentContainer?.addView(child)
+            setupChildListener(child)
+            forceRedraw()
+        } else {
+            super.addView(child)
+        }
+    }
+
+    override fun addView(child: View?, index: Int) {
+        if (contentContainer != null && child != secureSurface && child != contentContainer) {
+            contentContainer?.addView(child, index)
+            setupChildListener(child)
+            forceRedraw()
+        } else {
+            super.addView(child, index)
+        }
+    }
+
+    override fun addView(child: View?, params: ViewGroup.LayoutParams?) {
+        if (contentContainer != null && child != secureSurface && child != contentContainer) {
+            contentContainer?.addView(child, params)
+            setupChildListener(child)
+            forceRedraw()
+        } else {
+            super.addView(child, params)
+        }
+    }
+
+    override fun addView(child: View?, index: Int, params: ViewGroup.LayoutParams?) {
+        if (contentContainer != null && child != secureSurface && child != contentContainer) {
+            contentContainer?.addView(child, index, params)
+            setupChildListener(child)
+            forceRedraw()
+        } else {
+            super.addView(child, index, params)
+        }
+    }
+
+    override fun addView(child: View?, width: Int, height: Int) {
+        if (contentContainer != null && child != secureSurface && child != contentContainer) {
+            contentContainer?.addView(child, width, height)
+            setupChildListener(child)
+            forceRedraw()
+        } else {
+            super.addView(child, width, height)
+        }
+    }
+
+    private fun setupChildListener(child: View?) {
+        child?.addOnLayoutChangeListener { _, _, _, _, _, _, _, _, _ ->
+            forceRedraw()
+        }
+    }
+
+    override fun removeView(view: View?) {
+        if (view != secureSurface && view != contentContainer) {
+            contentContainer?.removeView(view)
+            forceRedraw()
+        } else {
+            super.removeView(view)
+        }
+    }
+
+    override fun removeViewAt(index: Int) {
+        contentContainer?.removeViewAt(index)
+        forceRedraw()
+    }
+
+    override fun removeAllViews() {
+        contentContainer?.removeAllViews()
+        forceRedraw()
+    }
+
+    override fun onDetachedFromWindow() {
+        super.onDetachedFromWindow()
+        redrawRunnable?.let { handler.removeCallbacks(it) }
+        contentBitmap?.recycle()
+        contentBitmap = null
+        secureSurface?.holder?.removeCallback(surfaceCallback)
+        try {
+            viewTreeObserver.removeOnGlobalLayoutListener(globalLayoutListener)
+        } catch (e: Exception) {
+            // Ignore
+        }
+    }
+
+    /**
+     * Gets the actual child count (excluding internal views).
+     */
+    fun getContentChildCount(): Int {
+        return contentContainer?.childCount ?: 0
+    }
+
+    /**
+     * Gets a child view at the specified index.
+     */
+    fun getContentChildAt(index: Int): View? {
+        return contentContainer?.getChildAt(index)
+    }
+}

package/android/src/main/java/com/momokits/antiscreenshot/AntiScreenshotViewManager.kt

@@ -0,0 +1,19 @@
+package com.momokits.antiscreenshot
+
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+
+@ReactModule(name = AntiScreenshotViewManager.NAME)
+class AntiScreenshotViewManager : ViewGroupManager<AntiScreenshotView>() {
+
+    override fun getName(): String = NAME
+
+    override fun createViewInstance(reactContext: ThemedReactContext): AntiScreenshotView {
+        return AntiScreenshotView(reactContext)
+    }
+
+    companion object {
+        const val NAME = "RNAntiScreenshot"
+    }
+}

package/ios/AntiScreenshotView.h

@@ -0,0 +1,12 @@
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// A UIView that protects its content from being captured in screenshots or
+/// screen recordings. It uses a secure UITextField's internal view as a
+/// container for the content.
+@interface AntiScreenshotView : UIView
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/AntiScreenshotView.m

@@ -0,0 +1,84 @@
+#import "AntiScreenshotView.h"
+
+@interface AntiScreenshotView ()
+
+@property(nonatomic, strong) UITextField *secureTextField;
+@property(nonatomic, strong) UIView *secureContainerView;
+
+@end
+
+@implementation AntiScreenshotView
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  self = [super initWithFrame:frame];
+  if (self) {
+    [self setupSecureView];
+  }
+  return self;
+}
+
+- (instancetype)initWithCoder:(NSCoder *)coder {
+  self = [super initWithCoder:coder];
+  if (self) {
+    [self setupSecureView];
+  }
+  return self;
+}
+
+- (void)setupSecureView {
+  // Create a secure text field - the magic ingredient
+  self.secureTextField = [[UITextField alloc] init];
+  self.secureTextField.secureTextEntry = YES;
+  self.secureTextField.userInteractionEnabled = NO;
+
+  // Get the internal secure view from UITextField
+  // When secureTextEntry is YES, UITextField uses a special internal view
+  // that prevents screenshot capture
+  if (self.secureTextField.subviews.count > 0) {
+    self.secureContainerView = self.secureTextField.subviews.firstObject;
+
+    // Add the secure container to our view hierarchy
+    [self addSubview:self.secureContainerView];
+
+    // Setup constraints
+    self.secureContainerView.translatesAutoresizingMaskIntoConstraints = NO;
+    [NSLayoutConstraint activateConstraints:@[
+      [self.secureContainerView.topAnchor
+          constraintEqualToAnchor:self.topAnchor],
+      [self.secureContainerView.leadingAnchor
+          constraintEqualToAnchor:self.leadingAnchor],
+      [self.secureContainerView.trailingAnchor
+          constraintEqualToAnchor:self.trailingAnchor],
+      [self.secureContainerView.bottomAnchor
+          constraintEqualToAnchor:self.bottomAnchor]
+    ]];
+  }
+}
+
+- (void)addSubview:(UIView *)view {
+  // Redirect child views to the secure container if available
+  if (self.secureContainerView && view != self.secureContainerView) {
+    [self.secureContainerView addSubview:view];
+  } else {
+    [super addSubview:view];
+  }
+}
+
+- (void)insertSubview:(UIView *)view atIndex:(NSInteger)index {
+  if (self.secureContainerView && view != self.secureContainerView) {
+    [self.secureContainerView insertSubview:view atIndex:index];
+  } else {
+    [super insertSubview:view atIndex:index];
+  }
+}
+
+- (void)layoutSubviews {
+  [super layoutSubviews];
+
+  // Ensure secure container fills the view
+  if (self.secureContainerView) {
+    self.secureContainerView.frame = self.bounds;
+  }
+}
+
+@end

package/ios/RNAntiScreenshot.h

@@ -0,0 +1,10 @@
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNAntiScreenshot : RCTViewComponentView
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/RNAntiScreenshot.mm

@@ -0,0 +1,59 @@
+#import "RNAntiScreenshot.h"
+
+#import <react/renderer/components/AntiScreenshotViewSpec/ComponentDescriptors.h>
+#import <react/renderer/components/AntiScreenshotViewSpec/EventEmitters.h>
+#import <react/renderer/components/AntiScreenshotViewSpec/Props.h>
+#import <react/renderer/components/AntiScreenshotViewSpec/RCTComponentViewHelpers.h>
+
+#import "AntiScreenshotView.h"
+#import "RCTFabricComponentsPlugins.h"
+
+using namespace facebook::react;
+
+@interface RNAntiScreenshot () <RCTRNAntiScreenshotViewProtocol>
+@end
+
+@implementation RNAntiScreenshot {
+  AntiScreenshotView *_view;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<
+      RNAntiScreenshotComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps =
+        std::make_shared<const RNAntiScreenshotProps>();
+    _props = defaultProps;
+
+    _view = [[AntiScreenshotView alloc] init];
+    self.contentView = _view;
+  }
+
+  return self;
+}
+
+- (void)updateProps:(Props::Shared const &)props
+           oldProps:(Props::Shared const &)oldProps {
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)mountChildComponentView:
+            (UIView<RCTComponentViewProtocol> *)childComponentView
+                          index:(NSInteger)index {
+  [_view insertSubview:childComponentView atIndex:index];
+}
+
+- (void)unmountChildComponentView:
+            (UIView<RCTComponentViewProtocol> *)childComponentView
+                            index:(NSInteger)index {
+  [childComponentView removeFromSuperview];
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RNAntiScreenshotCls(void) {
+  return RNAntiScreenshot.class;
+}

package/package.json

@@ -0,0 +1,81 @@
+{
+    "name": "@momo-kits/anti-screenshot",
+    "version": "0.1.0",
+    "description": "A React Native component that protects content from screenshots and screen recordings.",
+    "main": "./src/index.tsx",
+    "files": [
+        "src",
+        "lib",
+        "android",
+        "ios",
+        "cpp",
+        "*.podspec",
+        "react-native.config.js",
+        "!ios/build",
+        "!android/build",
+        "!android/gradle",
+        "!android/gradlew",
+        "!android/gradlew.bat",
+        "!android/local.properties",
+        "!**/__tests__",
+        "!**/__fixtures__",
+        "!**/__mocks__",
+        "!**/.*"
+    ],
+    "scripts": {
+        "example": "yarn workspace @momo-kits/anti-screenshot-example",
+        "test": "jest",
+        "typecheck": "tsc",
+        "lint": "eslint \"**/*.{js,ts,tsx}\"",
+        "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib",
+        "build": "echo",
+        "release": "release-it --only-version"
+    },
+    "keywords": [
+        "react-native",
+        "ios",
+        "android",
+        "screenshot",
+        "anti-screenshot",
+        "screen-capture",
+        "security"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git+https://www.npmjs.com/.git"
+    },
+    "author": "MoMo Team",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://www.npmjs.com//issues"
+    },
+    "homepage": "https://www.npmjs.com/#readme",
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org/"
+    },
+    "devDependencies": {
+        "react": "19.0.0",
+        "react-native": "0.80.1"
+    },
+    "peerDependencies": {
+        "react": "*",
+        "react-native": "*"
+    },
+    "engines": {
+        "node": ">=18.0.0"
+    },
+    "codegenConfig": {
+        "name": "AntiScreenshotViewSpec",
+        "type": "all",
+        "jsSrcsDir": "src",
+        "android": {
+            "javaPackageName": "com.momokits.antiscreenshot"
+        },
+        "ios": {
+            "componentProvider": {
+                "RNAntiScreenshot": "RNAntiScreenshot"
+            }
+        }
+    },
+    "dependencies": {}
+}

package/src/AntiScreenshotView.tsx

@@ -0,0 +1,41 @@
+import React from 'react';
+import type { ViewProps, StyleProp, ViewStyle } from 'react-native';
+import RNAntiScreenshotNativeComponent from './RNAntiScreenshotNativeComponent';
+
+export interface AntiScreenshotViewProps extends ViewProps {
+  /**
+   * Style for the container view
+   */
+  style?: StyleProp<ViewStyle>;
+  /**
+   * Children to be protected from screenshots
+   */
+  children?: React.ReactNode;
+}
+
+/**
+ * AntiScreenshotView - A component that protects its content from screenshots.
+ *
+ * Content inside this view will appear as black/blank in screenshots and screen recordings,
+ * while displaying normally on the device screen.
+ *
+ * @example
+ * ```tsx
+ * <AntiScreenshotView style={{ flex: 1 }}>
+ *   <Text>This content is protected from screenshots</Text>
+ * </AntiScreenshotView>
+ * ```
+ */
+export const AntiScreenshotView: React.FC<AntiScreenshotViewProps> = ({
+  children,
+  style,
+  ...props
+}) => {
+  return (
+    <RNAntiScreenshotNativeComponent style={style} {...props}>
+      {children}
+    </RNAntiScreenshotNativeComponent>
+  );
+};
+
+export default AntiScreenshotView;

package/src/RNAntiScreenshotNativeComponent.ts

@@ -0,0 +1,6 @@
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+import type { ViewProps } from 'react-native';
+
+export interface NativeProps extends ViewProps {}
+
+export default codegenNativeComponent<NativeProps>('RNAntiScreenshot');

package/src/index.tsx

@@ -0,0 +1,2 @@
+export { AntiScreenshotView, type AntiScreenshotViewProps } from './AntiScreenshotView';
+export { default } from './AntiScreenshotView';