@craft-native/android 0.0.451 → 0.0.467

package/dist/index.js

@@ -1,4 +1,212 @@
 // @bun
+// ../typescript/src/native-notifications.ts
+function nativeNotificationProblems(categories, nativeApp, renderer) {
+  if (categories === undefined)
+    return [];
+  if (!Array.isArray(categories))
+    return ["notificationCategories must be an array."];
+  const problems = [];
+  const categoryIds = new Set;
+  const object = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+  const text = (value) => typeof value === "string" && value.trim().length > 0;
+  for (const [index, category] of categories.entries()) {
+    const field = `notificationCategories[${index}]`;
+    if (!object(category) || !text(category.id)) {
+      problems.push(`${field} needs a nonempty id.`);
+      continue;
+    }
+    if (categoryIds.has(category.id))
+      problems.push(`${field}.id must be unique.`);
+    categoryIds.add(category.id);
+    if (!Array.isArray(category.actions) || category.actions.length < 1 || category.actions.length > 3) {
+      problems.push(`${field}.actions must contain 1\u20133 actions for both platforms.`);
+      continue;
+    }
+    const actionIds = new Set;
+    for (const [position, action] of category.actions.entries()) {
+      const path = `${field}.actions[${position}]`;
+      if (!object(action) || !text(action.id) || !text(action.title)) {
+        problems.push(`${path} needs a nonempty id and title.`);
+        continue;
+      }
+      if (action.id.startsWith("com.apple.") || actionIds.has(action.id))
+        problems.push(`${path}.id must be unique and must not use Apple's reserved prefix.`);
+      actionIds.add(action.id);
+      for (const flag of ["destructive", "foreground", "authenticationRequired"]) {
+        if (action[flag] !== undefined && typeof action[flag] !== "boolean")
+          problems.push(`${path}.${flag} must be a boolean.`);
+      }
+      if (!nativeApp?.trim() && (action.foreground !== true || renderer === "native"))
+        problems.push(`${path} requires nativeApp to receive native/background action events.`);
+      if (action.textInput !== undefined && (!object(action.textInput) || !text(action.textInput.buttonTitle) || action.textInput.placeholder !== undefined && typeof action.textInput.placeholder !== "string")) {
+        problems.push(`${path}.textInput needs a buttonTitle and an optional string placeholder.`);
+      }
+    }
+  }
+  return problems;
+}
+
+// ../typescript/src/native-routing.ts
+function applyNativeParameterConstraints(params, rules) {
+  if (rules === undefined)
+    return true;
+  if (!rules || typeof rules !== "object" || Array.isArray(rules))
+    return false;
+  for (const [name, rule] of Object.entries(rules)) {
+    let value = params[name];
+    if (typeof value !== "string" || !rule || typeof rule !== "object" || Array.isArray(rule))
+      return false;
+    if (Object.keys(rule).some((key) => !["pattern", "exclude", "normalize"].includes(key)))
+      return false;
+    if (rule.normalize !== undefined && rule.normalize !== "lowercase")
+      return false;
+    if (rule.normalize === "lowercase")
+      value = value.toLowerCase();
+    if (rule.exclude !== undefined) {
+      if (!Array.isArray(rule.exclude) || rule.exclude.some((item) => typeof item !== "string"))
+        return false;
+      if (rule.exclude.some((item) => (rule.normalize === "lowercase" ? item.toLowerCase() : item) === value))
+        return false;
+    }
+    if (rule.pattern !== undefined) {
+      if (typeof rule.pattern !== "string")
+        return false;
+      try {
+        const matched = new RegExp(`^(?:${rule.pattern})$`).exec(value);
+        if (!matched || matched[0] !== value)
+          return false;
+      } catch {
+        return false;
+      }
+    }
+    params[name] = value;
+  }
+  return true;
+}
+function nativeRouteConstraintProblems(screens, constraints) {
+  const problems = [];
+  if (constraints === undefined)
+    return problems;
+  if (!constraints || typeof constraints !== "object" || Array.isArray(constraints))
+    return ["nativeScreenConstraints must name route parameter constraints."];
+  for (const [route, rules] of Object.entries(constraints)) {
+    const prefix = `nativeScreenConstraints[${JSON.stringify(route)}]`;
+    if (!Object.prototype.hasOwnProperty.call(screens ?? {}, route))
+      problems.push(`${prefix} names no native screen route.`);
+    if (!rules || typeof rules !== "object" || Array.isArray(rules)) {
+      problems.push(`${prefix} must name parameter constraints.`);
+      continue;
+    }
+    const names = route.split("/").filter((part) => part.startsWith(":")).map((part) => part.slice(1));
+    for (const [name, rule] of Object.entries(rules)) {
+      const field = `${prefix}[${JSON.stringify(name)}]`;
+      if (!names.includes(name))
+        problems.push(`${field} names no path parameter.`);
+      if (!rule || typeof rule !== "object" || Array.isArray(rule)) {
+        problems.push(`${field} must be a parameter constraint.`);
+        continue;
+      }
+      if (Object.keys(rule).some((key) => !["pattern", "exclude", "normalize"].includes(key)))
+        problems.push(`${field} has an unknown constraint field.`);
+      if (rule.exclude !== undefined && (!Array.isArray(rule.exclude) || rule.exclude.some((value) => typeof value !== "string")))
+        problems.push(`${field}.exclude must contain strings.`);
+      if (rule.normalize !== undefined && rule.normalize !== "lowercase")
+        problems.push(`${field}.normalize must be lowercase.`);
+      if (rule.pattern !== undefined) {
+        try {
+          if (typeof rule.pattern !== "string")
+            throw new Error("not a string");
+          new RegExp(`^(?:${rule.pattern})$`);
+        } catch {
+          problems.push(`${field}.pattern must be a valid regular expression.`);
+        }
+      }
+    }
+  }
+  return problems;
+}
+function normalizeNativePath(raw) {
+  if (typeof raw !== "string")
+    return null;
+  let path = raw;
+  const cut = path.search(/[?#]/);
+  if (cut >= 0)
+    path = path.slice(0, cut);
+  if (!path.startsWith("/"))
+    return null;
+  path = path.replace(/\/{2,}/g, "/");
+  if (path.length > 1 && path.endsWith("/"))
+    path = path.slice(0, -1);
+  return path;
+}
+function routeSegments(path) {
+  return path === "/" ? [] : path.slice(1).split("/");
+}
+function matchNativePath(nativeScreens, raw, constraints) {
+  if (constraints !== undefined && (!constraints || typeof constraints !== "object" || Array.isArray(constraints)))
+    return null;
+  const path = normalizeNativePath(raw);
+  if (path === null)
+    return null;
+  const routes = Object.entries(nativeScreens ?? {}).map(([pattern, screen]) => ({ key: pattern, pattern: normalizeNativePath(pattern), screen })).filter((route) => route.pattern !== null && !!route.screen).map((route) => ({ ...route, segments: routeSegments(route.pattern) }));
+  const wild = (segments) => segments.at(-1) === "*" ? 1 : 0;
+  const fixed = (segments) => segments.filter((s) => s !== "*" && !s.startsWith(":")).length;
+  routes.sort((a, b) => wild(a.segments) - wild(b.segments) || fixed(b.segments) - fixed(a.segments) || b.segments.length - a.segments.length || (a.pattern < b.pattern ? -1 : a.pattern > b.pattern ? 1 : 0));
+  const decode = (value) => {
+    try {
+      return decodeURIComponent(value);
+    } catch {
+      return value;
+    }
+  };
+  const parts = routeSegments(path);
+  for (const route of routes) {
+    const params = {};
+    let matched = true;
+    for (let i = 0;i < route.segments.length; i++) {
+      const segment = route.segments[i];
+      if (segment === "*") {
+        params["*"] = parts.slice(i).join("/");
+        break;
+      }
+      if (i >= parts.length) {
+        matched = false;
+        break;
+      }
+      if (segment.startsWith(":")) {
+        if (!parts[i]) {
+          matched = false;
+          break;
+        }
+        params[segment.slice(1)] = decode(parts[i]);
+      } else if (segment !== parts[i]) {
+        matched = false;
+        break;
+      }
+    }
+    if (!matched)
+      continue;
+    if (route.segments.at(-1) !== "*" && route.segments.length !== parts.length)
+      continue;
+    if (!applyNativeParameterConstraints(params, constraints?.[route.key]))
+      continue;
+    const query = raw.indexOf("?");
+    if (query >= 0) {
+      for (const item of raw.slice(query + 1).split("#")[0].split("&")) {
+        if (!item)
+          continue;
+        const [rawKey = "", ...rest] = item.split("=");
+        const key = decode(rawKey);
+        if (!key || key in params)
+          continue;
+        params[key] = decode(rest.join("=").replace(/\+/g, " "));
+      }
+    }
+    return { path, screen: route.screen, params };
+  }
+  return null;
+}
+
 // src/index.ts
 import { gzipSync } from "zlib";
 import { cpSync, existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync, rmSync as rmSync2, statSync, writeFileSync } from "fs";
@@ -128,7 +336,7 @@ import { readFileSync } from "fs";
 import { mkdtemp, rm, writeFile } from "fs/promises";
 import { tmpdir } from "os";
 import { dirname, join } from "path";
-async function runKotlinFixture(source) {
+async function runKotlinFixture(source, libraries = []) {
   const gradle = Bun.which("gradle");
   if (!gradle)
     throw new Error("Gradle is required to run native Kotlin fixtures");
@@ -152,6 +360,8 @@ configurations {
 dependencies {
     kotlinCompiler 'org.jetbrains.kotlin:kotlin-compiler-embeddable:${version}'
     kotlinRuntime 'org.jetbrains.kotlin:kotlin-stdlib:${version}'
+${libraries.map((library) => `    kotlinRuntime ${JSON.stringify(library)}`).join(`
+`)}
 }
 tasks.register('compileFixture', JavaExec) {
     classpath = configurations.kotlinCompiler
@@ -932,32 +1142,8 @@ function normalizeNativeRoutePath(raw) {
 function nativeRouteSegments(path) {
   return path === "/" ? [] : path.slice(1).split("/");
 }
-function matchesNativeRoute(nativeScreens, raw) {
-  const path = normalizeNativeRoutePath(raw);
-  if (path === null)
-    return false;
-  const parts = nativeRouteSegments(path);
-  return Object.entries(nativeScreens ?? {}).some(([pattern, screen]) => {
-    if (!screen)
-      return false;
-    const normalized = normalizeNativeRoutePath(pattern);
-    if (normalized === null)
-      return false;
-    const route = nativeRouteSegments(normalized);
-    for (let index = 0;index < route.length; index++) {
-      const segment = route[index];
-      if (segment === "*")
-        return index === route.length - 1;
-      if (index >= parts.length)
-        return false;
-      if (segment.startsWith(":")) {
-        if (!parts[index])
-          return false;
-      } else if (segment !== parts[index])
-        return false;
-    }
-    return route.length === parts.length;
-  });
+function matchesNativeRoute(nativeScreens, raw, constraints) {
+  return matchNativePath(nativeScreens, raw, constraints) !== null;
 }
 function nativeStartPath(config) {
   if (!config.devServerURL)
@@ -970,6 +1156,15 @@ function nativeStartPath(config) {
   }
 }
 function validateNativeRouteConfig(config) {
+  const constraintProblems = [
+    ...nativeRouteConstraintProblems(config.nativeScreens, config.nativeScreenConstraints),
+    ...nativeNotificationProblems(config.notificationCategories, config.nativeApp, config.renderer)
+  ];
+  if ((config.notificationCategories?.length ?? 0) > 0 && config.renderer !== "native")
+    constraintProblems.push("notificationCategories currently requires the native Android renderer.");
+  if (constraintProblems.length)
+    throw new Error(constraintProblems.join(`
+`));
   const screens = Object.entries(config.nativeScreens ?? {});
   for (const [pattern, screen] of screens) {
     if (normalizeNativeRoutePath(pattern) !== pattern || /[?#]/.test(pattern))
@@ -989,11 +1184,11 @@ function validateNativeRouteConfig(config) {
   }
   if (config.renderer === "native" && screens.length > 0) {
     for (const id of ids) {
-      if (!matchesNativeRoute(config.nativeScreens, id))
+      if (!matchesNativeRoute(config.nativeScreens, id, config.nativeScreenConstraints))
         throw new Error(`Tab "${id}" is not a nativeScreens path; with renderer: "native" every tab must be a native screen.`);
     }
     const start = nativeStartPath(config);
-    if (!matchesNativeRoute(config.nativeScreens, start))
+    if (!matchesNativeRoute(config.nativeScreens, start, config.nativeScreenConstraints))
       throw new Error(`The start path "${start}" (from devServerURL) is not a nativeScreens path; with renderer: "native" the app must start on a native screen.`);
   }
   if (config.nativeApp !== undefined) {
@@ -1059,7 +1254,7 @@ function renderAndroidPermissions(config) {
     permissions.add("android.permission.FOREGROUND_SERVICE");
     permissions.add("android.permission.FOREGROUND_SERVICE_LOCATION");
   }
-  if (config.enablePushNotifications)
+  if (config.enablePushNotifications || config.enableLocalNotifications)
     permissions.add("android.permission.POST_NOTIFICATIONS");
   if (config.enableKeepAwake || config.enableBarometer && config.enableBackgroundLocation)
     permissions.add("android.permission.WAKE_LOCK");
@@ -1767,6 +1962,7 @@ async function run(options) {
     throw error;
   }
 }
+var nativeRouteConstraints = true;
 export {
   ANDROID_MIN_SDK,
   HEALTH_CONNECT_PERMISSIONS,
@@ -1781,6 +1977,7 @@ export {
   nativeMapProviders,
   nativeMessages,
   nativeRouteBundles,
+  nativeRouteConstraints,
   nativeRouteRuntime,
   nativeSensorCapabilities,
   open,
@@ -1794,4 +1991,4 @@ export {
   syncNativeFonts
 };
 
-//# debugId=607F99B9A5B4A43764756E2164756E21
+//# debugId=1EFE2D8AB406306964756E2164756E21