miaoda-expo-devkit 0.1.1-beta.2 → 0.1.1-beta.21

package/dist/metro.mjs

@@ -1,55 +1,47 @@
-// src/metro.ts
-import connect from "connect";
-import fs2 from "fs";
-import path2 from "path";
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
-// src/routes.ts
-import fs from "fs";
+// src/metro/withNativeWind.ts
 import path from "path";
-var ROUTE_EXT = /\.(tsx|ts|jsx|js)$/;
-function getRoutes(appDir) {
-  const routes = [];
-  function scan(dir, prefix) {
-    let entries;
-    try {
-      entries = fs.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        const isGroup = /^\(.*\)$/.test(entry.name);
-        const nextPrefix = isGroup ? prefix : `${prefix}/${entry.name}`;
-        scan(fullPath, nextPrefix);
-      } else if (ROUTE_EXT.test(entry.name)) {
-        const baseName = entry.name.replace(ROUTE_EXT, "");
-        if (baseName === "_layout") continue;
-        const segment = baseName === "index" ? "" : `/${baseName}`;
-        const routePath = `${prefix}${segment}` || "/";
-        const isDynamic = /\[.*\]/.test(baseName);
-        routes.push({
-          title: routePath,
-          pageId: routePath,
-          pageName: routePath,
-          visible: !isDynamic,
-          path: path.relative(appDir, fullPath)
-        });
-      }
+function patchNativeWindCachePath(options = {}) {
+  const projectRoot = process.cwd();
+  const ourCacheDir = path.resolve(projectRoot, options.cacheDir ?? ".native-wind-cache");
+  const nativewindPkgDir = path.dirname(__require.resolve("react-native-css-interop/package.json"));
+  const nativewindCacheDir = path.resolve(nativewindPkgDir, ".cache");
+  const moduleId = __require.resolve("react-native-css-interop/dist/metro");
+  delete __require.cache[moduleId];
+  let intercepted = false;
+  const originalResolve = path.resolve;
+  path.resolve = ((...args) => {
+    const result = originalResolve(...args);
+    if (result === nativewindCacheDir) {
+      intercepted = true;
+      return ourCacheDir;
     }
+    return result;
+  });
+  try {
+    __require(moduleId);
+  } finally {
+    path.resolve = originalResolve;
+  }
+  if (!intercepted) {
+    throw new Error(
+      "patchNativeWindCachePath: patch \u672A\u751F\u6548\u2014\u2014react-native-css-interop \u53EF\u80FD\u5DF2\u4E0D\u518D\u901A\u8FC7 path.resolve \u8BA1\u7B97\u7F13\u5B58\u8DEF\u5F84\u3002\u5347\u7EA7\u8BE5\u4F9D\u8D56\u540E\u8BF7\u68C0\u67E5 dist/metro/index.js \u4E2D\u7684\u5B9E\u73B0\u3002"
+    );
   }
-  scan(appDir, "");
-  return { routes };
 }
-function createRouteHandler(appDir) {
-  return (_req, res) => {
-    const routeTree = getRoutes(appDir);
-    res.writeHead(200, { "Content-Type": "application/json" });
-    res.end(JSON.stringify(routeTree, null, 2));
-  };
+function withNativeWind(config, options) {
+  const { withNativeWind: nwWithNativeWind } = __require("nativewind/metro");
+  return nwWithNativeWind(config, options);
 }
 
-// src/metro.ts
+// src/metro/withDevStubs.ts
+import path2 from "path";
 var SENTRY_STUB_FILENAME = "sentry-react-native-stub.js";
 var SENTRY_STUB_PATH = path2.resolve(__dirname, "stubs", SENTRY_STUB_FILENAME);
 var NO_OP_LOGBOX_STUB_PATH = path2.resolve(__dirname, "stubs", "no-op-logbox.js");
@@ -77,7 +69,10 @@ function withDevStubs(config) {
     }
   };
 }
-var EXPO_ROUTER_ENTRY_STUB_PATH = path2.resolve(__dirname, "stubs", "expo-router-entry-stub.js");
+
+// src/metro/withEntryInjection.ts
+import path3 from "path";
+var EXPO_ROUTER_ENTRY_STUB_PATH = path3.resolve(__dirname, "stubs", "expo-router-entry-stub.js");
 var EXPO_ROUTER_ENTRY_STUB_FILENAME = "expo-router-entry-stub.js";
 function withEntryInjection(config, options) {
   void options;
@@ -99,13 +94,63 @@ function withEntryInjection(config, options) {
     }
   };
 }
+
+// src/metro/withRouteEndpoint.ts
+import connect from "connect";
+
+// src/routes.ts
+import fs from "fs";
+import path4 from "path";
+var ROUTE_EXT = /\.(tsx|ts|jsx|js)$/;
+function getRoutes(appDir, rootDir) {
+  const routes = [];
+  function scan(dir, prefix) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path4.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        const isGroup = /^\(.*\)$/.test(entry.name);
+        const nextPrefix = isGroup ? prefix : `${prefix}/${entry.name}`;
+        scan(fullPath, nextPrefix);
+      } else if (ROUTE_EXT.test(entry.name)) {
+        const baseName = entry.name.replace(ROUTE_EXT, "");
+        if (baseName === "_layout" || /\[.*\]/.test(baseName)) continue;
+        const segment = baseName === "index" ? "" : `/${baseName}`;
+        const routePath = `${prefix}${segment}` || "/";
+        routes.push({
+          title: routePath.replace(/^\//, "") || "/",
+          pageId: routePath,
+          pageName: routePath,
+          path: path4.relative(rootDir, fullPath)
+        });
+      }
+    }
+  }
+  scan(appDir, "");
+  return { data: routes };
+}
+function createRouteHandler(appDir, rootDir) {
+  return (_req, res) => {
+    const routeTree = getRoutes(appDir, rootDir);
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(routeTree, null, 2));
+  };
+}
+
+// src/metro/withRouteEndpoint.ts
 var DEFAULT_ROUTE_ENDPOINT = "/__routes";
 function withRouteEndpoint(config, options) {
   const { appDir, endpoint = DEFAULT_ROUTE_ENDPOINT } = options;
+  const rootDir = config.projectRoot ?? process.cwd();
   const upstream = config.server?.enhanceMiddleware ?? null;
   const enhanceMiddleware = (middleware, metroServer) => {
     const enhanced = upstream ? upstream(middleware, metroServer) : middleware;
-    return connect().use(enhanced).use(endpoint, createRouteHandler(appDir));
+    return connect().use(enhanced).use(endpoint, createRouteHandler(appDir, rootDir));
   };
   return {
     ...config,
@@ -115,40 +160,152 @@ function withRouteEndpoint(config, options) {
     }
   };
 }
-function withWorkspaceNodeModules(config) {
-  const projectRoot = config.projectRoot ?? process.cwd();
-  if (fs2.existsSync(path2.join(projectRoot, "node_modules"))) {
-    return config;
-  }
-  let dir = path2.dirname(projectRoot);
-  let found = null;
+
+// src/metro/withWorkspaceNodeModules.ts
+import fs2 from "fs";
+import path5 from "path";
+function findAncestorNodeModulesDir(projectRoot) {
+  let dir = path5.dirname(projectRoot);
   while (true) {
-    const candidate = path2.join(dir, "node_modules");
-    if (fs2.existsSync(candidate)) {
-      found = candidate;
-      break;
-    }
-    const parent = path2.dirname(dir);
+    const candidate = path5.join(dir, "node_modules");
+    if (fs2.existsSync(candidate)) return candidate;
+    const parent = path5.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  if (!found) {
-    return config;
+  return null;
+}
+function resolveExternalPnpmStore(nodeModulesDir) {
+  const pnpmDir = path5.join(nodeModulesDir, ".pnpm");
+  try {
+    const realPnpmDir = fs2.realpathSync(pnpmDir);
+    const realNmDir = path5.dirname(realPnpmDir);
+    if (realNmDir !== nodeModulesDir) {
+      return realNmDir;
+    }
+  } catch {
+  }
+  return null;
+}
+function withWorkspaceNodeModules(config) {
+  const projectRoot = config.projectRoot ?? process.cwd();
+  const found = findAncestorNodeModulesDir(projectRoot);
+  if (!found) return config;
+  const foldersToAdd = [found];
+  const externalStore = resolveExternalPnpmStore(found);
+  if (externalStore) {
+    foldersToAdd.push(externalStore);
   }
-  const existingWatchFolders = config.watchFolders ?? [];
-  const existingNodeModulesPaths = config.resolver?.nodeModulesPaths ?? [];
   return {
     ...config,
-    watchFolders: [...existingWatchFolders, found],
+    watchFolders: [...config.watchFolders ?? [], ...foldersToAdd],
+    resolver: {
+      ...config.resolver,
+      nodeModulesPaths: [...config.resolver?.nodeModulesPaths ?? [], ...foldersToAdd]
+    }
+  };
+}
+
+// src/metro/withCssInterop.ts
+import path6 from "path";
+var EXPO_IMAGE_STUB_FILENAME = "expo-image-stub.js";
+var EXPO_IMAGE_STUB_PATH = path6.resolve(__dirname, "stubs", EXPO_IMAGE_STUB_FILENAME);
+var EXPO_CAMERA_STUB_FILENAME = "expo-camera-stub.js";
+var EXPO_CAMERA_STUB_PATH = path6.resolve(__dirname, "stubs", EXPO_CAMERA_STUB_FILENAME);
+var EXPO_LINEAR_GRADIENT_STUB_FILENAME = "expo-linear-gradient-stub.js";
+var EXPO_LINEAR_GRADIENT_STUB_PATH = path6.resolve(__dirname, "stubs", EXPO_LINEAR_GRADIENT_STUB_FILENAME);
+var EXPO_BLUR_STUB_FILENAME = "expo-blur-stub.js";
+var EXPO_BLUR_STUB_PATH = path6.resolve(__dirname, "stubs", EXPO_BLUR_STUB_FILENAME);
+function withCssInterop(config) {
+  const upstream = config.resolver?.resolveRequest ?? null;
+  const resolveRequest = (context, moduleName, platform) => {
+    if (moduleName === "expo-image" && !context.originModulePath.includes(EXPO_IMAGE_STUB_FILENAME)) {
+      return { filePath: EXPO_IMAGE_STUB_PATH, type: "sourceFile" };
+    }
+    if (moduleName === "expo-camera" && !context.originModulePath.includes(EXPO_CAMERA_STUB_FILENAME)) {
+      return { filePath: EXPO_CAMERA_STUB_PATH, type: "sourceFile" };
+    }
+    if (moduleName === "expo-linear-gradient" && !context.originModulePath.includes(EXPO_LINEAR_GRADIENT_STUB_FILENAME)) {
+      return { filePath: EXPO_LINEAR_GRADIENT_STUB_PATH, type: "sourceFile" };
+    }
+    if (moduleName === "expo-blur" && !context.originModulePath.includes(EXPO_BLUR_STUB_FILENAME)) {
+      return { filePath: EXPO_BLUR_STUB_PATH, type: "sourceFile" };
+    }
+    if (upstream) {
+      return upstream(context, moduleName, platform);
+    }
+    return context.resolveRequest(context, moduleName, platform);
+  };
+  return {
+    ...config,
     resolver: {
       ...config.resolver,
-      nodeModulesPaths: [...existingNodeModulesPaths, found]
+      resolveRequest
     }
   };
 }
+
+// src/metro/withDevkit.ts
+import path7 from "path";
+
+// src/metro/withEsbuildMinify.ts
+function withEsbuildMinify(config) {
+  return {
+    ...config,
+    transformer: {
+      ...config.transformer,
+      minifierPath: __require.resolve("metro-minify-esbuild"),
+      // 清空 terser 默认选项，esbuild 用自己的默认压缩配置
+      minifierConfig: {}
+    }
+  };
+}
+
+// src/metro/withDevkit.ts
+var EXPO_NOTIFICATIONS_STUB_FILENAME = "expo-notifications-stub.js";
+var EXPO_NOTIFICATIONS_STUB_PATH = path7.resolve(__dirname, "stubs", EXPO_NOTIFICATIONS_STUB_FILENAME);
+function withExpoNotificationsStub(config) {
+  const upstream = config.resolver?.resolveRequest ?? null;
+  const resolveRequest = (context, moduleName, platform) => {
+    if (platform === "android" && moduleName === "expo-notifications" && !context.originModulePath.includes(EXPO_NOTIFICATIONS_STUB_FILENAME)) {
+      return { filePath: EXPO_NOTIFICATIONS_STUB_PATH, type: "sourceFile" };
+    }
+    if (upstream) return upstream(context, moduleName, platform);
+    return context.resolveRequest(context, moduleName, platform);
+  };
+  return { ...config, resolver: { ...config.resolver, resolveRequest } };
+}
+function withDevkit(config, options = {}) {
+  const projectRoot = config.projectRoot ?? process.cwd();
+  const { input = "./src/global.css" } = options;
+  config = withWorkspaceNodeModules(config);
+  config = withCssInterop(config);
+  config = withEsbuildMinify(config);
+  config = withExpoNotificationsStub(config);
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    config = withEntryInjection(config);
+    config = withDevStubs(config);
+    config = withRouteEndpoint(config, { appDir: path7.join(projectRoot, "src", "app") });
+  }
+  return withNativeWind(config, { input, inlineRem: 16 });
+}
+
+// src/metro/index.ts
+try {
+  __require.resolve("react-native-css-interop/package.json");
+  patchNativeWindCachePath();
+} catch (e) {
+  if (e.code !== "MODULE_NOT_FOUND") throw e;
+}
 export {
+  patchNativeWindCachePath,
+  withCssInterop,
   withDevStubs,
+  withDevkit,
   withEntryInjection,
+  withEsbuildMinify,
+  withExpoNotificationsStub,
+  withNativeWind,
   withRouteEndpoint,
   withWorkspaceNodeModules
 };

package/dist/rules/no-duplicate-expo-router-url.js

@@ -103,7 +103,7 @@ var noDuplicateExpoRouterUrlRule = {
   },
   create(context) {
     return {
-      Program(node) {
+      Program() {
         const projectRoot = findProjectRoot(context.filename);
         if (!projectRoot) return;
         const routerRoot = getRouterRoot(projectRoot);
@@ -118,7 +118,7 @@ var noDuplicateExpoRouterUrlRule = {
         const others = files.filter((f) => f !== rel);
         if (others.length === 0) return;
         context.report({
-          loc: { line: 1, column: 0 },
+          loc: { start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
           messageId: "duplicateUrl",
           data: { url, other: others.join(", ") }
         });

package/dist/rules/no-missing-css-import.js

@@ -0,0 +1,98 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/rules/no-missing-css-import.ts
+var no_missing_css_import_exports = {};
+__export(no_missing_css_import_exports, {
+  default: () => no_missing_css_import_default
+});
+module.exports = __toCommonJS(no_missing_css_import_exports);
+var import_node_fs = __toESM(require("fs"));
+var import_node_path = __toESM(require("path"));
+var import_oxc_resolver = require("oxc-resolver");
+var CSS_EXTENSION = /\.css$/i;
+var resolverCache = /* @__PURE__ */ new Map();
+function getResolver(projectRoot) {
+  let resolver = resolverCache.get(projectRoot);
+  if (!resolver) {
+    resolver = new import_oxc_resolver.ResolverFactory({
+      extensions: [".css"],
+      conditionNames: ["import", "require", "node", "default"]
+    });
+    resolverCache.set(projectRoot, resolver);
+  }
+  return resolver;
+}
+function findProjectRoot(startPath) {
+  let dir = import_node_path.default.dirname(startPath);
+  while (dir !== import_node_path.default.dirname(dir)) {
+    if (import_node_fs.default.existsSync(import_node_path.default.join(dir, "package.json"))) return dir;
+    dir = import_node_path.default.dirname(dir);
+  }
+  return dir;
+}
+var noMissingCssImportRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow CSS imports that reference non-existent files."
+    },
+    schema: [],
+    messages: {
+      cssNotFound: "CSS file '{{source}}' does not exist."
+    }
+  },
+  create(context) {
+    const projectRoot = findProjectRoot(context.filename);
+    const resolver = getResolver(projectRoot);
+    const currentDir = import_node_path.default.dirname(context.filename);
+    function check(node, source) {
+      if (!CSS_EXTENSION.test(source)) return;
+      try {
+        const result = resolver.sync(currentDir, source);
+        if (!result.path || !import_node_fs.default.existsSync(result.path)) {
+          context.report({ node, messageId: "cssNotFound", data: { source } });
+        }
+      } catch {
+        context.report({ node, messageId: "cssNotFound", data: { source } });
+      }
+    }
+    return {
+      ImportDeclaration(node) {
+        check(node, node.source.value);
+      }
+    };
+  }
+};
+var plugin = {
+  meta: { name: "css-import" },
+  rules: { "no-missing-css-import": noMissingCssImportRule }
+};
+var no_missing_css_import_default = plugin;
+module.exports = module.exports.default;

package/dist/rules/no-undeclared-expo-plugin.js

@@ -81,6 +81,7 @@ var KNOWN_CONFIG_PLUGIN_PACKAGES = /* @__PURE__ */ new Set([
   "expo-widgets"
 ]);
 var pluginsCache = /* @__PURE__ */ new Map();
+var reportedPackages = /* @__PURE__ */ new Set();
 function findProjectRoot(startPath) {
   let dir = import_node_path.default.dirname(startPath);
   while (dir !== import_node_path.default.dirname(dir)) {
@@ -132,6 +133,9 @@ var requireExpoPluginRule = {
       if (!pkg) return;
       if (!KNOWN_CONFIG_PLUGIN_PACKAGES.has(pkg)) return;
       if (declaredPlugins.includes(pkg)) return;
+      const reportKey = `${projectRoot}::${pkg}`;
+      if (reportedPackages.has(reportKey)) return;
+      reportedPackages.add(reportKey);
       context.report({
         node,
         messageId: "missingPlugin",

package/dist/rules/no-unused-expo-plugin.js

@@ -0,0 +1,162 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/rules/no-unused-expo-plugin.ts
+var no_unused_expo_plugin_exports = {};
+__export(no_unused_expo_plugin_exports, {
+  default: () => no_unused_expo_plugin_default
+});
+module.exports = __toCommonJS(no_unused_expo_plugin_exports);
+var import_node_fs = __toESM(require("fs"));
+var import_node_path = __toESM(require("path"));
+var KNOWN_CONFIG_PLUGIN_PACKAGES = /* @__PURE__ */ new Set([
+  "expo-apple-authentication",
+  "expo-asset",
+  "expo-audio",
+  "expo-background-fetch",
+  "expo-background-task",
+  "expo-brightness",
+  "expo-brownfield",
+  "expo-build-properties",
+  "expo-calendar",
+  "expo-camera",
+  "expo-cellular",
+  "expo-contacts",
+  "expo-dev-client",
+  "expo-dev-launcher",
+  "expo-dev-menu",
+  "expo-document-picker",
+  "expo-file-system",
+  "expo-font",
+  "expo-image",
+  "expo-image-picker",
+  "expo-local-authentication",
+  "expo-localization",
+  "expo-location",
+  "expo-mail-composer",
+  "expo-maps",
+  "expo-media-library",
+  "expo-modules-test-core",
+  "expo-navigation-bar",
+  "expo-notifications",
+  "expo-router",
+  "expo-screen-orientation",
+  "expo-secure-store",
+  "expo-sensors",
+  "expo-sharing",
+  "expo-splash-screen",
+  "expo-sqlite",
+  "expo-system-ui",
+  "expo-task-manager",
+  "expo-tracking-transparency",
+  "expo-updates",
+  "expo-video",
+  "expo-web-browser",
+  "expo-widgets"
+]);
+var pluginsCache = /* @__PURE__ */ new Map();
+var depsCache = /* @__PURE__ */ new Map();
+function findProjectRoot(startPath) {
+  let dir = import_node_path.default.dirname(startPath);
+  while (dir !== import_node_path.default.dirname(dir)) {
+    if (import_node_fs.default.existsSync(import_node_path.default.join(dir, "package.json"))) {
+      return dir;
+    }
+    dir = import_node_path.default.dirname(dir);
+  }
+  return dir;
+}
+function getPluginsFromAppJson(projectRoot) {
+  if (pluginsCache.has(projectRoot)) return pluginsCache.get(projectRoot);
+  const appJsonPath = import_node_path.default.join(projectRoot, "app.json");
+  try {
+    const raw = JSON.parse(import_node_fs.default.readFileSync(appJsonPath, "utf-8"));
+    const entries = raw?.expo?.plugins ?? [];
+    const names = entries.map((entry) => Array.isArray(entry) ? entry[0] : entry);
+    pluginsCache.set(projectRoot, names);
+    return names;
+  } catch {
+    pluginsCache.set(projectRoot, []);
+    return [];
+  }
+}
+function getInstalledDeps(projectRoot) {
+  if (depsCache.has(projectRoot)) return depsCache.get(projectRoot);
+  const pkgPath = import_node_path.default.join(projectRoot, "package.json");
+  try {
+    const raw = JSON.parse(import_node_fs.default.readFileSync(pkgPath, "utf-8"));
+    const deps = /* @__PURE__ */ new Set([
+      ...Object.keys(raw["dependencies"] ?? {}),
+      ...Object.keys(raw["devDependencies"] ?? {}),
+      ...Object.keys(raw["peerDependencies"] ?? {}),
+      ...Object.keys(raw["optionalDependencies"] ?? {})
+    ]);
+    depsCache.set(projectRoot, deps);
+    return deps;
+  } catch {
+    depsCache.set(projectRoot, /* @__PURE__ */ new Set());
+    return /* @__PURE__ */ new Set();
+  }
+}
+var noUnusedExpoPluginRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Ensure Expo Config Plugins declared in app.json's plugins array are installed in package.json."
+    },
+    schema: [],
+    messages: {
+      notInstalled: "'{{packageName}}' is declared in app.json \u2192 expo.plugins but is not installed in package.json."
+    }
+  },
+  create(context) {
+    const projectRoot = findProjectRoot(context.filename);
+    const declaredPlugins = getPluginsFromAppJson(projectRoot);
+    const installedDeps = getInstalledDeps(projectRoot);
+    return {
+      Program(node) {
+        for (const pkg of declaredPlugins) {
+          if (!KNOWN_CONFIG_PLUGIN_PACKAGES.has(pkg)) continue;
+          if (installedDeps.has(pkg)) continue;
+          context.report({
+            node,
+            messageId: "notInstalled",
+            data: { packageName: pkg }
+          });
+        }
+      }
+    };
+  }
+};
+var plugin = {
+  meta: { name: "expo-unused-config-plugin" },
+  rules: { "no-unused-expo-plugin": noUnusedExpoPluginRule }
+};
+var no_unused_expo_plugin_default = plugin;
+module.exports = module.exports.default;

package/dist/stubs/expo-blur-stub.js

@@ -0,0 +1,29 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var ExpoBlur = __toESM(require("expo-blur"));
+var import_nativewind = require("nativewind");
+if (ExpoBlur.BlurView) (0, import_nativewind.cssInterop)(ExpoBlur.BlurView, { className: "style" });
+if (ExpoBlur.BlurTargetView) (0, import_nativewind.cssInterop)(ExpoBlur.BlurTargetView, { className: "style" });
+module.exports = ExpoBlur;
+//# sourceMappingURL=expo-blur-stub.js.map