@swipt/cli 0.1.0-nightly.42 → 0.1.0-nightly.44

package/metro.mjs

@@ -12,21 +12,72 @@ const cliDirectory = path.dirname(fileURLToPath(import.meta.url));
 
 const sourceExtensions = ["js", "jsx", "json", "ts", "tsx", "cjs", "mjs"];
 const assetExtensions = [
-  "bmp", "gif", "jpg", "jpeg", "png", "psd", "svg", "webp", "xml", "m4v", "mov", "mp4", "mpeg", "mpg", "webm", "aac", "aiff", "caf",
-  "m4a", "mp3", "wav", "html", "pdf", "yaml", "yml", "otf", "ttf", "zip",
+  "bmp",
+  "gif",
+  "jpg",
+  "jpeg",
+  "png",
+  "psd",
+  "svg",
+  "webp",
+  "xml",
+  "m4v",
+  "mov",
+  "mp4",
+  "mpeg",
+  "mpg",
+  "webm",
+  "aac",
+  "aiff",
+  "caf",
+  "m4a",
+  "mp3",
+  "wav",
+  "html",
+  "pdf",
+  "yaml",
+  "yml",
+  "otf",
+  "ttf",
+  "zip",
+  "db",
+  "sqlite",
+  "sqlite3",
 ];
-const imageExtensions = new Set(["png", "jpg", "jpeg", "bmp", "gif", "webp", "psd", "svg", "tiff", "ktx"]);
+const imageExtensions = new Set([
+  "png",
+  "jpg",
+  "jpeg",
+  "bmp",
+  "gif",
+  "webp",
+  "psd",
+  "svg",
+  "tiff",
+  "ktx",
+]);
 const babelConfigNames = [
-  ".babelrc", ".babelrc.js", ".babelrc.cjs", ".babelrc.mjs", ".babelrc.json", ".babelrc.cts",
-  "babel.config.js", "babel.config.cjs", "babel.config.mjs", "babel.config.json", "babel.config.cts", "babel.config.ts", "babel.config.mts",
+  ".babelrc",
+  ".babelrc.js",
+  ".babelrc.cjs",
+  ".babelrc.mjs",
+  ".babelrc.json",
+  ".babelrc.cts",
+  "babel.config.js",
+  "babel.config.cjs",
+  "babel.config.mjs",
+  "babel.config.json",
+  "babel.config.cts",
+  "babel.config.ts",
+  "babel.config.mts",
 ];
 const contextModes = ["sync", "eager", "lazy", "lazy-once"];
 const scaleSuffixes = ["", "@1x", "@1.5x", "@2x", "@3x", "@4x"];
 const platformSuffixes = ["", ".ios", ".native"];
 const platformRank = { ios: 2, native: 1 };
 
-const posix = file => file.split(path.sep).join("/");
-const escape = text => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const posix = (file) => file.split(path.sep).join("/");
+const escape = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 
 export function loadEnvironment(root) {
   loadProjectEnv(root, { mode: "production", silent: true });
@@ -35,7 +86,9 @@ export function loadEnvironment(root) {
 
 function defaultPreset(root) {
   try {
-    return createRequire(path.join(root, "package.json")).resolve("expo/internal/babel-preset");
+    return createRequire(path.join(root, "package.json")).resolve(
+      "expo/internal/babel-preset",
+    );
   } catch {
     return require.resolve("babel-preset-expo");
   }
@@ -46,9 +99,14 @@ function contextFiles(directory, recursive) {
     return [];
   }
   const extensions = new Set([...sourceExtensions, ...assetExtensions]);
-  return fs.readdirSync(directory, { recursive })
+  return fs
+    .readdirSync(directory, { recursive })
     .map(posix)
-    .filter(file => extensions.has(path.extname(file).slice(1)) && fs.statSync(path.join(directory, file)).isFile())
+    .filter(
+      (file) =>
+        extensions.has(path.extname(file).slice(1)) &&
+        fs.statSync(path.join(directory, file)).isFile(),
+    )
     .sort();
 }
 
@@ -64,7 +122,9 @@ function requireContext({ types: t, template }) {
         return value;
       }
     }
-    throw call.buildCodeFrameError(`argument ${index + 1} of require.context must be ${expected}`);
+    throw call.buildCodeFrameError(
+      `argument ${index + 1} of require.context must be ${expected}`,
+    );
   };
   const pattern = (call, index) => {
     const node = call.node.arguments[index];
@@ -72,7 +132,9 @@ function requireContext({ types: t, template }) {
       return /^\.\/.*$/;
     }
     if (!t.isRegExpLiteral(node)) {
-      throw call.buildCodeFrameError(`argument ${index + 1} of require.context must be a regular expression literal`);
+      throw call.buildCodeFrameError(
+        `argument ${index + 1} of require.context must be a regular expression literal`,
+      );
     }
     return new RegExp(node.pattern, node.flags.replace(/[gy]/g, ""));
   };
@@ -82,24 +144,52 @@ function requireContext({ types: t, template }) {
       CallExpression(call, state) {
         const { callee } = call.node;
         if (
-          !t.isMemberExpression(callee) || !t.isIdentifier(callee.object, { name: "require" }) || call.scope.hasBinding("require")
-          || !(callee.computed ? t.isStringLiteral(callee.property, { value: "context" }) : t.isIdentifier(callee.property, { name: "context" }))
+          !t.isMemberExpression(callee) ||
+          !t.isIdentifier(callee.object, { name: "require" }) ||
+          call.scope.hasBinding("require") ||
+          !(callee.computed
+            ? t.isStringLiteral(callee.property, { value: "context" })
+            : t.isIdentifier(callee.property, { name: "context" }))
         ) {
           return;
         }
         const from = path.dirname(state.filename);
-        const directory = path.resolve(from, argument(call, 0, undefined, "a string", value => typeof value === "string"));
-        const recursive = argument(call, 1, true, "a boolean", value => typeof value === "boolean");
+        const directory = path.resolve(
+          from,
+          argument(
+            call,
+            0,
+            undefined,
+            "a string",
+            (value) => typeof value === "string",
+          ),
+        );
+        const recursive = argument(
+          call,
+          1,
+          true,
+          "a boolean",
+          (value) => typeof value === "boolean",
+        );
         const filter = pattern(call, 2);
-        const mode = argument(call, 3, "sync", `one of ${contextModes.join(", ")}`, value => contextModes.includes(value));
+        const mode = argument(
+          call,
+          3,
+          "sync",
+          `one of ${contextModes.join(", ")}`,
+          (value) => contextModes.includes(value),
+        );
         const entries = contextFiles(directory, recursive)
-          .map(file => `./${file}`)
-          .filter(key => filter.test(key))
-          .map(key => {
-            const target = posix(path.relative(from, path.join(directory, key)));
+          .map((file) => `./${file}`)
+          .filter((key) => filter.test(key))
+          .map((key) => {
+            const target = posix(
+              path.relative(from, path.join(directory, key)),
+            );
             return `${JSON.stringify(key)}: () => require(${JSON.stringify(target.startsWith(".") ? target : `./${target}`)})`;
           });
-        call.replaceWith(template.expression.ast(`(() => {
+        call.replaceWith(
+          template.expression.ast(`(() => {
           const modules = { ${entries.join(", ")} };
           const context = key => {
             if (!Object.prototype.hasOwnProperty.call(modules, key)) {
@@ -111,27 +201,42 @@ function requireContext({ types: t, template }) {
           context.resolve = key => key;
           context.id = ${JSON.stringify(posix(path.relative(state.cwd, directory)) || ".")};
           return context;
-        })()`));
+        })()`),
+        );
       },
     },
   };
 }
 
-const loaderOf = file => {
+const loaderOf = (file) => {
   const extension = path.extname(file);
-  return extension === ".tsx" ? "tsx" : [".ts", ".mts", ".cts"].includes(extension) ? "ts" : "jsx";
+  return extension === ".tsx"
+    ? "tsx"
+    : [".ts", ".mts", ".cts"].includes(extension)
+      ? "ts"
+      : "jsx";
 };
 
 function archivedAsset(root, file) {
   const relative = path.relative(root, file).split(path.sep);
-  return relative[0] === "assets" ? { path: relative.slice(1).join("/"), bundled: false } : { path: relative.map(part => (part === ".." ? "__" : part)).join("/"), bundled: true };
+  return relative[0] === "assets"
+    ? { path: relative.slice(1).join("/"), bundled: false }
+    : {
+        path: relative.map((part) => (part === ".." ? "__" : part)).join("/"),
+        bundled: true,
+      };
 }
 
 function assetVariants(resolved) {
   const directory = path.dirname(resolved);
   const extension = path.extname(resolved);
-  const stem = path.basename(resolved, extension).replace(/(\.(ios|native))$/, "").replace(/@[\d.]+x$/, "");
-  const pattern = new RegExp(`^${escape(stem)}(?:@([\\d.]+)x)?(?:\\.(ios|native))?${escape(extension)}$`);
+  const stem = path
+    .basename(resolved, extension)
+    .replace(/(\.(ios|native))$/, "")
+    .replace(/@[\d.]+x$/, "");
+  const pattern = new RegExp(
+    `^${escape(stem)}(?:@([\\d.]+)x)?(?:\\.(ios|native))?${escape(extension)}$`,
+  );
   const scales = new Map();
   for (const name of fs.readdirSync(directory)) {
     const match = pattern.exec(name);
@@ -144,13 +249,17 @@ function assetVariants(resolved) {
       scales.set(scale, { rank, file: path.join(directory, name) });
     }
   }
-  return [...scales].sort(([a], [b]) => a - b).map(([scale, { file }]) => ({ scale, file }));
+  return [...scales]
+    .sort(([a], [b]) => a - b)
+    .map(([scale, { file }]) => ({ scale, file }));
 }
 
 function assetModule(root, variants, assets) {
   const [first] = variants;
   const extension = path.extname(first.file).slice(1);
-  const size = imageExtensions.has(extension) ? imageSize(fs.readFileSync(first.file)) : undefined;
+  const size = imageExtensions.has(extension)
+    ? imageSize(fs.readFileSync(first.file))
+    : undefined;
   const files = variants.map(({ scale, file }) => {
     const archived = archivedAsset(root, file);
     if (archived.bundled) {
@@ -174,16 +283,25 @@ function checkWorklets(root) {
   } catch {
     return;
   }
-  const { version } = JSON.parse(fs.readFileSync(path.join(path.dirname(plugin), "..", "package.json"), "utf8"));
+  const { version } = JSON.parse(
+    fs.readFileSync(
+      path.join(path.dirname(plugin), "..", "package.json"),
+      "utf8",
+    ),
+  );
   const { version: expected } = require("react-native-worklets/package.json");
   if (version !== expected) {
-    throw new Error(`the project has react-native-worklets ${version}, but Swipt runs ${expected}; install react-native-worklets@${expected} or remove it`);
+    throw new Error(
+      `the project has react-native-worklets ${version}, but Swipt runs ${expected}; install react-native-worklets@${expected} or remove it`,
+    );
   }
 }
 
 export function metro(root, { assets, sourcemap }) {
   checkWorklets(root);
-  const configName = babelConfigNames.find(name => fs.existsSync(path.join(root, name)));
+  const configName = babelConfigNames.find((name) =>
+    fs.existsSync(path.join(root, name)),
+  );
   const babel = {
     cwd: root,
     root,
@@ -194,58 +312,110 @@ export function metro(root, { assets, sourcemap }) {
     compact: false,
     retainLines: true,
     sourceMaps: sourcemap ? "inline" : false,
-    ...(configName ? { extends: path.join(root, configName) } : { presets: [defaultPreset(root)] }),
+    ...(configName
+      ? { extends: path.join(root, configName) }
+      : { presets: [defaultPreset(root)] }),
     plugins: [requireContext],
   };
   const caller = {
-    name: "metro", bundler: "metro", platform: "ios", engine: "hermes", isDev: false, isServer: false, isReactServer: false, baseUrl: "",
-    routerRoot: "app", projectRoot: root, isHMREnabled: true, metroSourceType: "module", supportsStaticESM: true,
+    name: "metro",
+    bundler: "metro",
+    platform: "ios",
+    engine: "hermes",
+    isDev: false,
+    isServer: false,
+    isReactServer: false,
+    baseUrl: "",
+    routerRoot: "app",
+    projectRoot: root,
+    isHMREnabled: true,
+    metroSourceType: "module",
+    supportsStaticESM: true,
   };
   const internal = Symbol("internal");
   return {
     name: "swiplet-metro",
     setup(build) {
-      build.onResolve({ filter: /^@babel\/runtime\// }, async args => {
+      build.onResolve({ filter: /^@babel\/runtime\// }, async (args) => {
         if (args.pluginData === internal) {
           return undefined;
         }
-        const options = { kind: args.kind, importer: args.importer, pluginData: internal };
-        const found = await build.resolve(args.path, { ...options, resolveDir: args.resolveDir });
-        return found.errors.length === 0 ? found : build.resolve(args.path, { ...options, resolveDir: cliDirectory });
+        const options = {
+          kind: args.kind,
+          importer: args.importer,
+          pluginData: internal,
+        };
+        const found = await build.resolve(args.path, {
+          ...options,
+          resolveDir: args.resolveDir,
+        });
+        return found.errors.length === 0
+          ? found
+          : build.resolve(args.path, { ...options, resolveDir: cliDirectory });
       });
       if (assets) {
-        build.onResolve({ filter: new RegExp(`\\.(${assetExtensions.join("|")})$`) }, async args => {
-          if (args.pluginData === internal) {
-            return undefined;
-          }
-          const extension = path.extname(args.path);
-          const stem = args.path.slice(0, -extension.length);
-          let first;
-          for (const scale of scaleSuffixes) {
-            for (const platform of platformSuffixes) {
-              const found = await build.resolve(`${stem}${scale}${platform}${extension}`, { kind: args.kind, importer: args.importer, resolveDir: args.resolveDir, pluginData: internal });
-              if (found.errors.length === 0) {
-                return { path: found.path, namespace: "swiplet-asset", pluginData: assetVariants(found.path) };
+        build.onResolve(
+          { filter: new RegExp(`\\.(${assetExtensions.join("|")})$`) },
+          async (args) => {
+            if (args.pluginData === internal) {
+              return undefined;
+            }
+            const extension = path.extname(args.path);
+            const stem = args.path.slice(0, -extension.length);
+            let first;
+            for (const scale of scaleSuffixes) {
+              for (const platform of platformSuffixes) {
+                const found = await build.resolve(
+                  `${stem}${scale}${platform}${extension}`,
+                  {
+                    kind: args.kind,
+                    importer: args.importer,
+                    resolveDir: args.resolveDir,
+                    pluginData: internal,
+                  },
+                );
+                if (found.errors.length === 0) {
+                  return {
+                    path: found.path,
+                    namespace: "swiplet-asset",
+                    pluginData: assetVariants(found.path),
+                  };
+                }
+                first ??= found;
               }
-              first ??= found;
             }
-          }
-          return { errors: first.errors };
-        });
-        build.onLoad({ filter: /.*/, namespace: "swiplet-asset" }, args => ({
+            return { errors: first.errors };
+          },
+        );
+        build.onLoad({ filter: /.*/, namespace: "swiplet-asset" }, (args) => ({
           contents: assetModule(root, args.pluginData, assets),
           loader: "js",
           resolveDir: root,
         }));
       }
-      build.onLoad({ filter: /\.[cm]?[jt]sx?$/, namespace: "file" }, async args => {
-        const result = await transformAsync(await fs.promises.readFile(args.path, "utf8"), {
-          ...babel,
-          filename: args.path,
-          caller: { ...caller, isNodeModule: args.path.includes("node_modules") },
-        });
-        return result === null ? undefined : { contents: result.code, loader: loaderOf(args.path), resolveDir: path.dirname(args.path) };
-      });
+      build.onLoad(
+        { filter: /\.[cm]?[jt]sx?$/, namespace: "file" },
+        async (args) => {
+          const result = await transformAsync(
+            await fs.promises.readFile(args.path, "utf8"),
+            {
+              ...babel,
+              filename: args.path,
+              caller: {
+                ...caller,
+                isNodeModule: args.path.includes("node_modules"),
+              },
+            },
+          );
+          return result === null
+            ? undefined
+            : {
+                contents: result.code,
+                loader: loaderOf(args.path),
+                resolveDir: path.dirname(args.path),
+              };
+        },
+      );
     },
   };
 }

package/output.mjs

@@ -5,9 +5,16 @@ import { ServiceStatus, ServiceStatusSchema } from "./proto/swiplets_pb.js";
 
 export class FalseResult extends Error {}
 
-export const enumText = (schema, value, prefix) => schema.value[value].name.slice(prefix.length).toLowerCase().replaceAll("_", " ");
+export const enumText = (schema, value, prefix) =>
+  schema.value[value].name
+    .slice(prefix.length)
+    .toLowerCase()
+    .replaceAll("_", " ");
 
-const levelName = level => (level === LogLevel.UNSPECIFIED ? "info" : enumText(LogLevelSchema, level, "LOG_LEVEL_"));
+const levelName = (level) =>
+  level === LogLevel.UNSPECIFIED
+    ? "info"
+    : enumText(LogLevelSchema, level, "LOG_LEVEL_");
 
 const pad = (value, width) => String(value).padStart(width, "0");
 
@@ -28,15 +35,28 @@ export function columns(rows) {
       widths[index] = Math.max(widths[index] ?? 0, cell.length);
     });
   }
-  return rows.map(row => row.map((cell, index) => (index === row.length - 1 ? cell : cell.padEnd(widths[index] + 2))).join("").trimEnd()).join("\n");
+  return rows
+    .map((row) =>
+      row
+        .map((cell, index) =>
+          index === row.length - 1 ? cell : cell.padEnd(widths[index] + 2),
+        )
+        .join("")
+        .trimEnd(),
+    )
+    .join("\n");
 }
 
-const frameText = frame => {
+const frameText = (frame) => {
   const position = `${frame.file}:${frame.line}:${frame.column}`;
   return frame.function === "" ? position : `${frame.function} (${position})`;
 };
 
-export const failureText = failure => [`${failure.name}: ${failure.message}`, ...failure.stack.map(frame => `    at ${frameText(frame)}`)].join("\n");
+export const failureText = (failure) =>
+  [
+    `${failure.name}: ${failure.message}`,
+    ...failure.stack.map((frame) => `    at ${frameText(frame)}`),
+  ].join("\n");
 
 export function printScriptError(failure) {
   console.error(`error: ${failureText(failure)}`);
@@ -44,8 +64,13 @@ export function printScriptError(failure) {
 }
 
 export function printLog(entry, toStdout) {
-  const message = entry.tag === "" ? entry.message : `${entry.tag}: ${entry.message}`;
-  (toStdout ? console.log : console.error)(clockTime(entry.time), levelName(entry.level).toUpperCase(), message);
+  const message =
+    entry.tag === "" ? entry.message : `${entry.tag}: ${entry.message}`;
+  (toStdout ? console.log : console.error)(
+    clockTime(entry.time),
+    levelName(entry.level).toUpperCase(),
+    message,
+  );
 }
 
 export function serviceText(id, state) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swipt/cli",
-  "version": "0.1.0-nightly.42",
+  "version": "0.1.0-nightly.44",
   "license": "GPL-3.0-or-later",
   "repository": {
     "type": "git",
@@ -20,6 +20,7 @@
   },
   "dependencies": {
     "@babel/core": "^7.29.7",
+    "@babel/plugin-transform-block-scoping": "^7.29.12",
     "@babel/runtime": "^7.29.10",
     "@bufbuild/protobuf": "^2.16.0",
     "@expo/env": "^2.5.3",
@@ -30,7 +31,7 @@
     "react-native-worklets": "0.13.0"
   },
   "peerDependencies": {
-    "@swipt/api": "0.1.0-nightly.42"
+    "@swipt/api": "0.1.0-nightly.44"
   },
   "devDependencies": {
     "@bufbuild/protoc-gen-es": "^2.16.0"