miaoda-expo-devkit 0.1.1-beta.96 → 0.1.1-beta.97

package/dist/cli/lint.js

@@ -9089,29 +9089,27 @@ var require_has_flag = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/supports-color@8.1.1/node_modules/supports-color/index.js
+// ../../node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js
 var require_supports_color = __commonJS({
-  "../../node_modules/.pnpm/supports-color@8.1.1/node_modules/supports-color/index.js"(exports2, module2) {
+  "../../node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js"(exports2, module2) {
     "use strict";
     var os = require("os");
     var tty = require("tty");
     var hasFlag = require_has_flag();
     var { env } = process;
-    var flagForceColor;
+    var forceColor;
     if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
-      flagForceColor = 0;
+      forceColor = 0;
     } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-      flagForceColor = 1;
+      forceColor = 1;
     }
-    function envForceColor() {
-      if ("FORCE_COLOR" in env) {
-        if (env.FORCE_COLOR === "true") {
-          return 1;
-        }
-        if (env.FORCE_COLOR === "false") {
-          return 0;
-        }
-        return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+    if ("FORCE_COLOR" in env) {
+      if (env.FORCE_COLOR === "true") {
+        forceColor = 1;
+      } else if (env.FORCE_COLOR === "false") {
+        forceColor = 0;
+      } else {
+        forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
       }
     }
     function translateLevel(level) {
@@ -9125,22 +9123,15 @@ var require_supports_color = __commonJS({
         has16m: level >= 3
       };
     }
-    function supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
-      const noFlagForceColor = envForceColor();
-      if (noFlagForceColor !== void 0) {
-        flagForceColor = noFlagForceColor;
-      }
-      const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+    function supportsColor(haveStream, streamIsTTY) {
       if (forceColor === 0) {
         return 0;
       }
-      if (sniffFlags) {
-        if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
-          return 3;
-        }
-        if (hasFlag("color=256")) {
-          return 2;
-        }
+      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+        return 3;
+      }
+      if (hasFlag("color=256")) {
+        return 2;
       }
       if (haveStream && !streamIsTTY && forceColor === void 0) {
         return 0;
@@ -9157,7 +9148,7 @@ var require_supports_color = __commonJS({
         return 1;
       }
       if ("CI" in env) {
-        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
           return 1;
         }
         return min;
@@ -9169,7 +9160,7 @@ var require_supports_color = __commonJS({
         return 3;
       }
       if ("TERM_PROGRAM" in env) {
-        const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+        const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
         switch (env.TERM_PROGRAM) {
           case "iTerm.app":
             return version >= 3 ? 3 : 2;
@@ -9188,17 +9179,14 @@ var require_supports_color = __commonJS({
       }
       return min;
     }
-    function getSupportLevel(stream, options = {}) {
-      const level = supportsColor(stream, {
-        streamIsTTY: stream && stream.isTTY,
-        ...options
-      });
+    function getSupportLevel(stream) {
+      const level = supportsColor(stream, stream && stream.isTTY);
       return translateLevel(level);
     }
     module2.exports = {
       supportsColor: getSupportLevel,
-      stdout: getSupportLevel({ isTTY: tty.isatty(1) }),
-      stderr: getSupportLevel({ isTTY: tty.isatty(2) })
+      stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+      stderr: translateLevel(supportsColor(true, tty.isatty(2)))
     };
   }
 });

package/dist/rules/no-invalid-expo-config-value.js

@@ -0,0 +1,141 @@
+"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-invalid-expo-config-value.ts
+var no_invalid_expo_config_value_exports = {};
+__export(no_invalid_expo_config_value_exports, {
+  default: () => no_invalid_expo_config_value_default
+});
+module.exports = __toCommonJS(no_invalid_expo_config_value_exports);
+var import_node_fs = __toESM(require("fs"));
+var import_node_path2 = __toESM(require("path"));
+
+// src/rules/utils.ts
+var import_node_path = __toESM(require("path"));
+var import_package_up = require("package-up");
+function findProjectRoot(startPath) {
+  const pkgPath = (0, import_package_up.packageUpSync)({ cwd: import_node_path.default.dirname(startPath) });
+  return pkgPath ? import_node_path.default.dirname(pkgPath) : null;
+}
+
+// src/rules/no-invalid-expo-config-value.ts
+var USER_INTERFACE_STYLE = /* @__PURE__ */ new Set(["light", "dark", "automatic"]);
+var ORIENTATION = /* @__PURE__ */ new Set(["default", "portrait", "landscape"]);
+var SPLASH_RESIZE_MODE = /* @__PURE__ */ new Set(["contain", "cover"]);
+var INITIAL_ORIENTATION = /* @__PURE__ */ new Set([
+  "DEFAULT",
+  "ALL",
+  "PORTRAIT",
+  "PORTRAIT_UP",
+  "PORTRAIT_DOWN",
+  "LANDSCAPE",
+  "LANDSCAPE_LEFT",
+  "LANDSCAPE_RIGHT"
+]);
+function collectEnumIssues(appJson) {
+  const issues = [];
+  const expo = appJson.expo ?? {};
+  const push = (field, value, allowed, allowedLabel) => {
+    if (typeof value === "string" && value.length > 0 && !allowed.has(value)) {
+      issues.push({ field, value, allowed: allowedLabel });
+    }
+  };
+  push("expo.orientation", expo.orientation, ORIENTATION, "default, portrait, landscape");
+  push("expo.userInterfaceStyle", expo.userInterfaceStyle, USER_INTERFACE_STYLE, "light, dark, automatic");
+  push(
+    "expo.android.userInterfaceStyle",
+    expo.android?.userInterfaceStyle,
+    USER_INTERFACE_STYLE,
+    "light, dark, automatic"
+  );
+  const splashes = [
+    ["expo.splash", expo.splash],
+    ["expo.android.splash", expo.android?.splash],
+    ["expo.ios.splash", expo.ios?.splash]
+  ];
+  for (const [prefix, splash] of splashes) {
+    if (!splash) continue;
+    push(`${prefix}.resizeMode`, splash.resizeMode, SPLASH_RESIZE_MODE, "contain, cover");
+  }
+  for (const entry of expo.plugins ?? []) {
+    if (!Array.isArray(entry) || entry[0] !== "expo-screen-orientation") continue;
+    const opts = entry[1];
+    if (opts != null && typeof opts === "object") {
+      const initial = opts.initialOrientation;
+      push(
+        "plugins[expo-screen-orientation].initialOrientation",
+        initial,
+        INITIAL_ORIENTATION,
+        "DEFAULT, ALL, PORTRAIT, PORTRAIT_UP, PORTRAIT_DOWN, LANDSCAPE, LANDSCAPE_LEFT, LANDSCAPE_RIGHT"
+      );
+    }
+  }
+  return issues;
+}
+var noInvalidExpoConfigValueRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Validate enum/string fields in app.json that `expo prebuild` consumes (userInterfaceStyle, orientation, splash.resizeMode, screen-orientation.initialOrientation)."
+    },
+    schema: [],
+    messages: {
+      invalidEnum: '{{field}} has invalid value "{{value}}". `expo prebuild` expects one of: {{allowed}}. Using an unrecognized value will either abort prebuild or be silently ignored.'
+    }
+  },
+  create(context) {
+    const projectRoot = findProjectRoot(context.filename);
+    if (!projectRoot) return {};
+    return {
+      Program(node) {
+        let appJson;
+        try {
+          appJson = JSON.parse(
+            import_node_fs.default.readFileSync(import_node_path2.default.join(projectRoot, "app.json"), "utf-8")
+          );
+        } catch {
+          return;
+        }
+        for (const issue of collectEnumIssues(appJson)) {
+          context.report({
+            node,
+            messageId: "invalidEnum",
+            data: { field: issue.field, value: issue.value, allowed: issue.allowed }
+          });
+        }
+      }
+    };
+  }
+};
+var plugin = {
+  meta: { name: "expo-config-value" },
+  rules: { "no-invalid-expo-config-value": noInvalidExpoConfigValueRule }
+};
+var no_invalid_expo_config_value_default = plugin;
+module.exports = module.exports.default;

package/dist/rules/no-invalid-notification-config.js

@@ -0,0 +1,228 @@
+"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-invalid-notification-config.ts
+var no_invalid_notification_config_exports = {};
+__export(no_invalid_notification_config_exports, {
+  default: () => no_invalid_notification_config_default
+});
+module.exports = __toCommonJS(no_invalid_notification_config_exports);
+var import_node_fs2 = __toESM(require("fs"));
+var import_node_path2 = __toESM(require("path"));
+
+// src/rules/utils.ts
+var import_node_path = __toESM(require("path"));
+var import_package_up = require("package-up");
+function findProjectRoot(startPath) {
+  const pkgPath = (0, import_package_up.packageUpSync)({ cwd: import_node_path.default.dirname(startPath) });
+  return pkgPath ? import_node_path.default.dirname(pkgPath) : null;
+}
+
+// src/rules/image-format.ts
+var import_node_fs = __toESM(require("fs"));
+var PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+var JPEG_SIGNATURE = Buffer.from([255, 216, 255]);
+var GIF87_SIGNATURE = Buffer.from("GIF87a", "ascii");
+var GIF89_SIGNATURE = Buffer.from("GIF89a", "ascii");
+var RIFF_SIGNATURE = Buffer.from("RIFF", "ascii");
+var WEBP_SIGNATURE = Buffer.from("WEBP", "ascii");
+function detectImageFormat(filePath) {
+  let fd;
+  try {
+    fd = import_node_fs.default.openSync(filePath, "r");
+  } catch {
+    return null;
+  }
+  try {
+    const buf = Buffer.alloc(12);
+    const bytesRead = import_node_fs.default.readSync(fd, buf, 0, buf.length, 0);
+    if (bytesRead >= 8 && buf.subarray(0, 8).equals(PNG_SIGNATURE)) {
+      return "png";
+    }
+    if (bytesRead >= 3 && buf.subarray(0, 3).equals(JPEG_SIGNATURE)) {
+      return "jpeg";
+    }
+    if (bytesRead >= 6 && (buf.subarray(0, 6).equals(GIF87_SIGNATURE) || buf.subarray(0, 6).equals(GIF89_SIGNATURE))) {
+      return "gif";
+    }
+    if (bytesRead >= 12 && buf.subarray(0, 4).equals(RIFF_SIGNATURE) && buf.subarray(8, 12).equals(WEBP_SIGNATURE)) {
+      return "webp";
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    import_node_fs.default.closeSync(fd);
+  }
+}
+
+// src/rules/no-invalid-notification-config.ts
+var SUPPORTED_FORMATS = /* @__PURE__ */ new Set([
+  "png",
+  "jpeg",
+  "webp",
+  "gif"
+]);
+var EXT_TO_FORMAT = {
+  png: "png",
+  jpg: "jpeg",
+  jpeg: "jpeg",
+  jpe: "jpeg",
+  webp: "webp",
+  gif: "gif"
+};
+function isRemoteUrl(value) {
+  return value.startsWith("http://") || value.startsWith("https://");
+}
+var HEX_COLOR = /^#[0-9a-fA-F]{3}([0-9a-fA-F]{3}([0-9a-fA-F]{2})?)?$/;
+function isHexColor(value) {
+  return HEX_COLOR.test(value);
+}
+function looksLikeColorName(value) {
+  if (!/^[a-z][a-z0-9_]*$/i.test(value) || value.includes(" ")) return false;
+  return !/^[0-9a-f]+$/i.test(value);
+}
+function getNotificationPluginOptions(plugins) {
+  for (const entry of plugins) {
+    if (entry === "expo-notifications") return {};
+    if (Array.isArray(entry) && entry[0] === "expo-notifications") {
+      const opts = entry[1];
+      if (opts != null && typeof opts === "object") return opts;
+      return {};
+    }
+  }
+  return null;
+}
+function checkIcon(projectRoot, icon) {
+  if (typeof icon !== "string") return null;
+  if (isRemoteUrl(icon)) return null;
+  const abs = import_node_path2.default.resolve(projectRoot, icon);
+  if (!import_node_fs2.default.existsSync(abs)) return { kind: "iconMissing" };
+  const ext = import_node_path2.default.extname(icon).replace(/^\./, "").toLowerCase();
+  const declared = EXT_TO_FORMAT[ext];
+  if (!declared) {
+    return { kind: "iconUnsupported", format: ext || "unknown" };
+  }
+  const actual = detectImageFormat(abs);
+  if (actual === null || !SUPPORTED_FORMATS.has(actual)) {
+    return { kind: "iconUnsupported", format: actual ?? "unknown" };
+  }
+  if (declared !== actual) {
+    return { kind: "iconMasquerade", declared, actual };
+  }
+  return null;
+}
+function collectIssues(projectRoot, options) {
+  const issues = [];
+  if (options.sounds !== void 0 && options.sounds !== null) {
+    if (!Array.isArray(options.sounds) && typeof options.sounds !== "string") {
+      issues.push({ kind: "soundsNotArray", actualType: typeof options.sounds });
+    }
+  }
+  if (typeof options.color === "string" && options.color.length > 0) {
+    if (!isHexColor(options.color) && !looksLikeColorName(options.color)) {
+      issues.push({ kind: "invalidColor", value: options.color });
+    }
+  }
+  if (options.icon !== void 0 && options.icon !== null) {
+    const iconIssue = checkIcon(projectRoot, options.icon);
+    if (iconIssue) issues.push(iconIssue);
+  }
+  return issues;
+}
+var noInvalidNotificationConfigRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Validate expo-notifications plugin config: sounds must be an array, color must be a valid hex/name, icon must be a supported image format and not masquerading."
+    },
+    schema: [],
+    messages: {
+      soundsNotArray: 'expo-notifications `sounds` must be an array of file paths, found {{actualType}}. `expo prebuild` throws: "Must provide an array of sound files in your app config".',
+      invalidColor: 'expo-notifications `color` "{{value}}" is not a valid color. Use a hex color like "#E63946" (supports #RGB / #RRGGBB / #AARRGGBB) or a lowercase color name.',
+      iconMissing: "expo-notifications `icon` references a file that does not exist.",
+      iconUnsupported: 'expo-notifications `icon` has unsupported image format "{{format}}". `expo prebuild` (via @expo/image-utils) only supports png, jpeg, webp, gif.',
+      iconMasquerade: "expo-notifications `icon` is declared as .{{declared}} but the file content is actually {{actual}}. This format masquerade fails prebuild. Convert the file to match its extension."
+    }
+  },
+  create(context) {
+    const projectRoot = findProjectRoot(context.filename);
+    if (!projectRoot) return {};
+    return {
+      Program(node) {
+        let appJson;
+        try {
+          appJson = JSON.parse(
+            import_node_fs2.default.readFileSync(import_node_path2.default.join(projectRoot, "app.json"), "utf-8")
+          );
+        } catch {
+          return;
+        }
+        const plugins = appJson.expo?.plugins ?? [];
+        const options = getNotificationPluginOptions(plugins);
+        if (!options) return;
+        for (const issue of collectIssues(projectRoot, options)) {
+          if (issue.kind === "soundsNotArray") {
+            context.report({
+              node,
+              messageId: "soundsNotArray",
+              data: { actualType: issue.actualType }
+            });
+          } else if (issue.kind === "invalidColor") {
+            context.report({
+              node,
+              messageId: "invalidColor",
+              data: { value: issue.value }
+            });
+          } else if (issue.kind === "iconMissing") {
+            context.report({ node, messageId: "iconMissing" });
+          } else if (issue.kind === "iconUnsupported") {
+            context.report({
+              node,
+              messageId: "iconUnsupported",
+              data: { format: issue.format }
+            });
+          } else {
+            context.report({
+              node,
+              messageId: "iconMasquerade",
+              data: { declared: issue.declared, actual: issue.actual }
+            });
+          }
+        }
+      }
+    };
+  }
+};
+var plugin = {
+  meta: { name: "expo-notifications-config" },
+  rules: { "no-invalid-notification-config": noInvalidNotificationConfigRule }
+};
+var no_invalid_notification_config_default = plugin;
+module.exports = module.exports.default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "miaoda-expo-devkit",
-  "version": "0.1.1-beta.96",
+  "version": "0.1.1-beta.97",
   "description": "Expo 应用开发工具集：Sentry DSN 替换 stub、错误/网络捕获、Metro 符号化",
   "license": "MIT",
   "main": "./dist/index.js",
@@ -64,6 +64,8 @@
     "./rules/no-missing-image-import": "./dist/rules/no-missing-image-import.js",
     "./rules/no-splash-screen-missing-image": "./dist/rules/no-splash-screen-missing-image.js",
     "./rules/no-missing-notification-asset": "./dist/rules/no-missing-notification-asset.js",
+    "./rules/no-invalid-notification-config": "./dist/rules/no-invalid-notification-config.js",
+    "./rules/no-invalid-expo-config-value": "./dist/rules/no-invalid-expo-config-value.js",
     "./rules/no-gifted-charts-missing-linear-gradient": "./dist/rules/no-gifted-charts-missing-linear-gradient.js",
     "./biome": "./biome-config.json",
     "./oxlint": "./oxlint-config.json",