@lynx-js/autolink-codegen 0.0.0 → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# @lynx-js/autolink-codegen
+
+## 0.1.0
+
+### Minor Changes
+
+- Add the Native Autolink codegen package. ([#2601](https://github.com/lynx-family/lynx-stack/pull/2601))
+
+## 0.0.0
+
+### Minor Changes
+
+- Initial Native Autolink codegen package.

package/README.md

@@ -0,0 +1,30 @@
+# @lynx-js/autolink-codegen
+
+Native Autolink code generator for Lynx extensions.
+
+It scans `types/**/*.d.ts` for native module declarations annotated with
+`/** @lynxmodule */`, reads `lynx.ext.json`, and generates:
+
+- `generated/<ModuleName>.ts`
+- Android `<ModuleName>Spec.java`
+- iOS `<ModuleName>Spec.h` and `<ModuleName>Spec.m`
+
+Run it from an extension package:
+
+```bash
+npx @lynx-js/autolink-codegen
+```
+
+The installed binary name is `lynx-autolink-codegen`, so generated extensions
+can use:
+
+```json
+{
+  "scripts": {
+    "codegen": "lynx-autolink-codegen"
+  }
+}
+```
+
+The first version intentionally supports only Native Autolink. Web Autolink and
+Web spec generation are outside this package.

package/dist/131.js

@@ -0,0 +1,480 @@
+import node_fs from "node:fs";
+import node_path from "node:path";
+const MODULE_HEADER_PATTERN = /\/\*\*[\s\S]*?@lynxmodule[\s\S]*?\*\/\s*export\s+declare\s+class\s+([A-Za-z_$][\w$]*)\s*\{/g;
+const IDENTIFIER_PATTERN = /^[A-Z_$][\w$]*$/i;
+const JAVA_PACKAGE_NAME_PATTERN = /^[A-Z_]\w*(?:\.[A-Z_]\w*)*$/i;
+function parseNativeModules(source, filename = '<inline>') {
+    const modules = [];
+    const seen = new Set();
+    for (const { body, name: moduleName } of findNativeModuleDeclarations(source, filename)){
+        if (seen.has(moduleName)) throw new Error(`Duplicate native module "${moduleName}" in ${filename}`);
+        seen.add(moduleName);
+        modules.push({
+            name: moduleName,
+            methods: parseMethods(body, filename, moduleName)
+        });
+    }
+    return modules;
+}
+function findNativeModuleDeclarations(source, filename) {
+    const declarations = [];
+    const pattern = new RegExp(MODULE_HEADER_PATTERN);
+    let match = pattern.exec(source);
+    while(null !== match){
+        const moduleName = match[1];
+        const matchedHeader = match[0];
+        if (void 0 === moduleName) {
+            match = pattern.exec(source);
+            continue;
+        }
+        const openBraceIndex = match.index + matchedHeader.length - 1;
+        const closeBraceIndex = findMatchingBrace(source, openBraceIndex);
+        if (-1 === closeBraceIndex) throw new Error(`Invalid native module declaration in ${filename}: ${moduleName} is missing a closing brace`);
+        declarations.push({
+            name: moduleName,
+            body: source.slice(openBraceIndex + 1, closeBraceIndex)
+        });
+        pattern.lastIndex = closeBraceIndex + 1;
+        match = pattern.exec(source);
+    }
+    return declarations;
+}
+function findMatchingBrace(source, openBraceIndex) {
+    let braceDepth = 1;
+    let inBlockComment = false;
+    let inLineComment = false;
+    let quote;
+    let escaped = false;
+    for(let index = openBraceIndex + 1; index < source.length; index += 1){
+        const character = source.charAt(index);
+        const next = source.charAt(index + 1);
+        if (inBlockComment) {
+            if ('*' === character && '/' === next) {
+                index += 1;
+                inBlockComment = false;
+            }
+            continue;
+        }
+        if (inLineComment) {
+            if ('\n' === character || '\r' === character) inLineComment = false;
+            continue;
+        }
+        if (void 0 !== quote) {
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if ('\\' === character) {
+                escaped = true;
+                continue;
+            }
+            if (character === quote) quote = void 0;
+            continue;
+        }
+        if ('/' === character && '*' === next) {
+            index += 1;
+            inBlockComment = true;
+            continue;
+        }
+        if ('/' === character && '/' === next) {
+            index += 1;
+            inLineComment = true;
+            continue;
+        }
+        if ('\'' === character || '"' === character || '`' === character) {
+            quote = character;
+            continue;
+        }
+        if ('{' === character) {
+            braceDepth += 1;
+            continue;
+        }
+        if ('}' === character) {
+            braceDepth -= 1;
+            if (0 === braceDepth) return index;
+        }
+    }
+    return -1;
+}
+function generate(options = {}) {
+    const root = node_path.resolve(options.root ?? process.cwd());
+    const manifest = readManifest(root);
+    const modules = readNativeModuleSpecs(root);
+    const seenModules = new Set();
+    const files = [];
+    for (const module of modules){
+        if (seenModules.has(module.name)) throw new Error(`Duplicate native module "${module.name}" across types`);
+        seenModules.add(module.name);
+        files.push({
+            path: node_path.posix.join('generated', `${module.name}.ts`),
+            content: generateJsFacade(module)
+        });
+        files.push({
+            path: node_path.posix.join(manifest.platforms.android.sourceDir, 'src', 'main', 'java', ...manifest.platforms.android.packageName.split('.'), 'generated', `${module.name}Spec.java`),
+            content: generateAndroidSpec(module, manifest.platforms.android.packageName)
+        });
+        files.push({
+            path: node_path.posix.join(manifest.platforms.ios.sourceDir, 'src', 'generated', `${module.name}Spec.h`),
+            content: generateIosHeader(module)
+        });
+        files.push({
+            path: node_path.posix.join(manifest.platforms.ios.sourceDir, 'src', 'generated', `${module.name}Spec.m`),
+            content: generateIosImplementation(module)
+        });
+    }
+    return files;
+}
+function runCodegen(options = {}) {
+    const root = node_path.resolve(options.root ?? process.cwd());
+    const files = generate({
+        root
+    });
+    const targets = files.map((file)=>({
+            file,
+            target: resolveInside(root, file.path, 'package root')
+        }));
+    for (const { target } of targets)assertNoSymlinkTraversal(root, target);
+    for (const { file, target } of targets){
+        node_fs.mkdirSync(node_path.dirname(target), {
+            recursive: true
+        });
+        node_fs.writeFileSync(target, file.content);
+    }
+    return files;
+}
+function parseMethods(body, filename, moduleName) {
+    const methods = [];
+    const seen = new Set();
+    for (const trimmed of splitMethodDeclarations(body, filename, moduleName)){
+        const openParen = trimmed.indexOf('(');
+        const closeParen = trimmed.lastIndexOf(')');
+        const returnColon = -1 === closeParen ? -1 : trimmed.indexOf(':', closeParen);
+        if (openParen <= 0 || closeParen <= openParen || returnColon <= closeParen) throw new Error(`Invalid method declaration in ${filename}: ${moduleName}.${trimmed}`);
+        const methodName = trimmed.slice(0, openParen).trim();
+        const paramsSource = trimmed.slice(openParen + 1, closeParen);
+        const returnSource = trimmed.slice(returnColon + 1).trim();
+        if (!IDENTIFIER_PATTERN.test(methodName)) throw new Error(`Invalid method name "${methodName}" in ${filename}: ${moduleName}`);
+        if (seen.has(methodName)) throw new Error(`Duplicate method "${moduleName}.${methodName}" in ${filename}`);
+        seen.add(methodName);
+        methods.push({
+            name: methodName,
+            params: parseParams(paramsSource, filename, moduleName, methodName),
+            returnType: parseType(returnSource.trim(), filename, `${moduleName}.${methodName} return`)
+        });
+    }
+    return methods;
+}
+function stripTypeScriptComments(source) {
+    let result = '';
+    let inBlockComment = false;
+    let inLineComment = false;
+    let quote;
+    let escaped = false;
+    for(let index = 0; index < source.length; index += 1){
+        const character = source.charAt(index);
+        const next = source.charAt(index + 1);
+        if (inBlockComment) {
+            if ('\n' === character || '\r' === character) result += character;
+            else result += ' ';
+            if ('*' === character && '/' === next) {
+                result += ' ';
+                index += 1;
+                inBlockComment = false;
+            }
+            continue;
+        }
+        if (inLineComment) {
+            if ('\n' === character || '\r' === character) {
+                result += character;
+                inLineComment = false;
+            } else result += ' ';
+            continue;
+        }
+        if (void 0 !== quote) {
+            result += character;
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if ('\\' === character) {
+                escaped = true;
+                continue;
+            }
+            if (character === quote) quote = void 0;
+            continue;
+        }
+        if ('/' === character && '*' === next) {
+            result += '  ';
+            index += 1;
+            inBlockComment = true;
+            continue;
+        }
+        if ('/' === character && '/' === next) {
+            result += '  ';
+            index += 1;
+            inLineComment = true;
+            continue;
+        }
+        if ('\'' === character || '"' === character || '`' === character) quote = character;
+        result += character;
+    }
+    return result;
+}
+function splitMethodDeclarations(body, filename, moduleName) {
+    const declarations = [];
+    const source = stripTypeScriptComments(body);
+    let buffer = '';
+    for (const line of source.split(/\r?\n/)){
+        const parts = line.split(';');
+        for(let index = 0; index < parts.length; index += 1){
+            const part = parts[index]?.trim();
+            if (void 0 !== part && part.length > 0) buffer = `${buffer} ${part}`.trim();
+            if (buffer.length > 0 && (index < parts.length - 1 || isCompleteMethodDeclaration(buffer))) {
+                declarations.push(buffer);
+                buffer = '';
+            }
+        }
+    }
+    if (buffer.length > 0) throw new Error(`Invalid method declaration in ${filename}: ${moduleName}.${buffer}`);
+    return declarations;
+}
+function isCompleteMethodDeclaration(source) {
+    if (0 === source.length) return false;
+    let parenDepth = 0;
+    for (const character of source){
+        if ('(' === character) {
+            parenDepth += 1;
+            continue;
+        }
+        if (')' === character) {
+            parenDepth -= 1;
+            if (parenDepth < 0) return false;
+        }
+    }
+    if (0 !== parenDepth) return false;
+    const openParen = source.indexOf('(');
+    const closeParen = source.lastIndexOf(')');
+    const returnColon = -1 === closeParen ? -1 : source.indexOf(':', closeParen);
+    return openParen > 0 && closeParen > openParen && returnColon > closeParen;
+}
+function parseParams(source, filename, moduleName, methodName) {
+    const trimmed = source.trim();
+    if (0 === trimmed.length) return [];
+    const params = trimmed.split(',').filter((paramSource)=>paramSource.trim().length > 0);
+    return params.map((paramSource)=>{
+        const normalizedParam = paramSource.trim();
+        const colon = normalizedParam.indexOf(':');
+        if (colon <= 0 || colon === normalizedParam.length - 1) throw new Error(`Invalid parameter declaration in ${filename}: ${moduleName}.${methodName}(${paramSource})`);
+        const rawName = normalizedParam.slice(0, colon).trim();
+        const optional = rawName.endsWith('?');
+        const name = optional ? rawName.slice(0, -1).trim() : rawName;
+        const typeSource = normalizedParam.slice(colon + 1).trim();
+        if (!IDENTIFIER_PATTERN.test(name)) throw new Error(`Invalid parameter name "${rawName}" in ${filename}: ${moduleName}.${methodName}`);
+        if (optional) throw new Error(`Optional parameter "${moduleName}.${methodName}.${name}" is not supported by Native Autolink codegen v1`);
+        const type = parseType(typeSource, filename, `${moduleName}.${methodName}.${name}`);
+        if ('void' === type.name) throw new Error(`Unsupported parameter type "void" for ${moduleName}.${methodName}.${name} in ${filename}. Native Autolink codegen v1 only supports void as a return type.`);
+        return {
+            name,
+            type
+        };
+    });
+}
+function resolveInside(root, filePath, label) {
+    const resolvedRoot = node_path.resolve(root);
+    const target = node_path.resolve(resolvedRoot, filePath);
+    const relativePath = node_path.relative(resolvedRoot, target);
+    if ('..' === relativePath || relativePath.startsWith(`..${node_path.sep}`) || node_path.isAbsolute(relativePath)) throw new Error(`Generated path escapes ${label}: ${filePath}`);
+    return target;
+}
+function assertNoSymlinkTraversal(root, target) {
+    const resolvedRoot = node_path.resolve(root);
+    const relativePath = node_path.relative(resolvedRoot, target);
+    if (0 === relativePath.length) return;
+    let current = resolvedRoot;
+    for (const segment of relativePath.split(node_path.sep)){
+        current = node_path.join(current, segment);
+        if (node_fs.existsSync(current) && node_fs.lstatSync(current).isSymbolicLink()) throw new Error(`Generated path escapes package root via symlink: ${node_path.relative(resolvedRoot, current)}`);
+    }
+}
+function parseType(source, filename, context) {
+    const parts = source.split('|').map((part)=>part.trim()).filter(Boolean);
+    const nullable = parts.includes('null');
+    const nonNullParts = parts.filter((part)=>'null' !== part);
+    if (1 !== nonNullParts.length) throw unsupportedType(source, filename, context);
+    const name = nonNullParts[0];
+    if (void 0 === name || 'void' !== name && 'string' !== name && 'number' !== name && 'boolean' !== name) throw unsupportedType(source, filename, context);
+    if (nullable && 'void' === name) throw unsupportedType(source, filename, context);
+    return {
+        name,
+        nullable
+    };
+}
+function unsupportedType(source, filename, context) {
+    return new Error(`Unsupported type "${source}" for ${context} in ${filename}. Native Autolink codegen v1 supports void, string, number, boolean, and unions with null.`);
+}
+function readNativeModuleSpecs(root) {
+    const typesDir = node_path.join(root, 'types');
+    if (!node_fs.existsSync(typesDir)) return [];
+    const modules = [];
+    for (const file of walkFiles(typesDir)){
+        if (!file.endsWith('.d.ts')) continue;
+        const source = node_fs.readFileSync(file, 'utf8');
+        modules.push(...parseNativeModules(source, node_path.relative(root, file)));
+    }
+    return modules;
+}
+function walkFiles(dir) {
+    const entries = node_fs.readdirSync(dir, {
+        withFileTypes: true
+    });
+    const files = [];
+    for (const entry of entries){
+        const entryPath = node_path.join(dir, entry.name);
+        if (entry.isDirectory()) files.push(...walkFiles(entryPath));
+        else if (entry.isFile()) files.push(entryPath);
+    }
+    return files.sort();
+}
+function readManifest(root) {
+    const manifestPath = node_path.join(root, 'lynx.ext.json');
+    if (!node_fs.existsSync(manifestPath)) throw new Error(`Missing lynx.ext.json in ${root}. Native Autolink codegen must run from an extension package root.`);
+    const json = JSON.parse(node_fs.readFileSync(manifestPath, 'utf8'));
+    const platforms = readObject(json, 'platforms', manifestPath);
+    const android = readObject(platforms, 'android', manifestPath);
+    const ios = readObject(platforms, 'ios', manifestPath);
+    const packageName = readRequiredString(android, 'packageName', manifestPath, 'platforms.android.packageName');
+    if (!JAVA_PACKAGE_NAME_PATTERN.test(packageName)) throw new Error(`${manifestPath} must define "platforms.android.packageName" as a valid Java package identifier (got "${packageName}")`);
+    return {
+        platforms: {
+            android: {
+                packageName,
+                sourceDir: readOptionalString(android, 'sourceDir', manifestPath, 'platforms.android.sourceDir') ?? 'android'
+            },
+            ios: {
+                sourceDir: readOptionalString(ios, 'sourceDir', manifestPath, 'platforms.ios.sourceDir') ?? 'ios'
+            }
+        }
+    };
+}
+function readObject(value, key, manifestPath) {
+    if (!isRecord(value)) throw new Error(`${manifestPath} must be a JSON object`);
+    const child = value[key];
+    if (!isRecord(child)) throw new Error(`${manifestPath} must define object "${key}"`);
+    return child;
+}
+function readRequiredString(value, key, manifestPath, displayPath) {
+    const child = value[key];
+    if ('string' != typeof child || 0 === child.trim().length) throw new Error(`${manifestPath} must define string "${displayPath}"`);
+    return child;
+}
+function readOptionalString(value, key, manifestPath, displayPath) {
+    const child = value[key];
+    if (void 0 === child) return;
+    if ('string' == typeof child && child.trim().length > 0) return child;
+    throw new Error(`${manifestPath} must define non-empty string "${displayPath}"`);
+}
+function isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function generateJsFacade(module) {
+    const methods = module.methods.map((method)=>`  ${method.name}(${method.params.map((param)=>`${param.name}: ${toTsType(param.type)}`).join(', ')}): ${toTsType(method.returnType)};`).join('\n');
+    return `// Generated by @lynx-js/autolink-codegen. Do not edit.
+
+declare const NativeModules: {
+  ${module.name}: {
+${methods}
+  };
+};
+
+export const ${module.name}: typeof NativeModules.${module.name} = NativeModules.${module.name};
+export default ${module.name};
+`;
+}
+function generateAndroidSpec(module, packageName) {
+    const methods = module.methods.map((method)=>`  @LynxMethod\n  public abstract ${toJavaType(method.returnType)} ${method.name}(${method.params.map((param)=>`${toJavaType(param.type)} ${param.name}`).join(', ')});`).join('\n\n');
+    return `// Generated by @lynx-js/autolink-codegen. Do not edit.
+package ${packageName}.generated;
+
+import androidx.annotation.Nullable;
+import com.lynx.jsbridge.LynxContextModule;
+import com.lynx.jsbridge.LynxMethod;
+import com.lynx.tasm.behavior.LynxContext;
+
+public abstract class ${module.name}Spec extends LynxContextModule {
+  public ${module.name}Spec(LynxContext context) {
+    super(context);
+  }
+
+${methods}
+}
+`;
+}
+function generateIosHeader(module) {
+    const methods = module.methods.map((method)=>`- (${toObjCReturnType(method.returnType)})${method.name}${0 === method.params.length ? '' : toObjCParams(method.params)};`).join('\n');
+    return `// Generated by @lynx-js/autolink-codegen. Do not edit.
+#import <Foundation/Foundation.h>
+#import <Lynx/LynxModule.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol ${module.name}Spec <LynxModule>
+
+${methods}
+
+@end
+
+NS_ASSUME_NONNULL_END
+`;
+}
+function generateIosImplementation(module) {
+    return `// Generated by @lynx-js/autolink-codegen. Do not edit.
+#import "${module.name}Spec.h"
+`;
+}
+function toTsType(type) {
+    const base = 'void' === type.name ? 'void' : type.name;
+    return type.nullable ? `${base} | null` : base;
+}
+function toJavaType(type) {
+    switch(type.name){
+        case 'void':
+            return 'void';
+        case 'string':
+            return type.nullable ? '@Nullable String' : 'String';
+        case 'number':
+            return type.nullable ? '@Nullable Double' : 'double';
+        case 'boolean':
+            return type.nullable ? '@Nullable Boolean' : 'boolean';
+    }
+}
+function toObjCReturnType(type) {
+    switch(type.name){
+        case 'void':
+            return 'void';
+        case 'string':
+            return type.nullable ? 'nullable NSString *' : 'NSString *';
+        case 'number':
+            return type.nullable ? 'nullable NSNumber *' : 'double';
+        case 'boolean':
+            return type.nullable ? 'nullable NSNumber *' : 'BOOL';
+    }
+}
+function toObjCParamType(type) {
+    switch(type.name){
+        case 'void':
+            throw new Error('void parameters are not supported');
+        case 'string':
+            return type.nullable ? 'nullable NSString *' : 'NSString *';
+        case 'number':
+            return type.nullable ? 'nullable NSNumber *' : 'double';
+        case 'boolean':
+            return type.nullable ? 'nullable NSNumber *' : 'BOOL';
+    }
+}
+function toObjCParams(params) {
+    return params.map((param, index)=>{
+        const prefix = 0 === index ? ':' : ` ${param.name}:`;
+        return `${prefix}(${toObjCParamType(param.type)})${param.name}`;
+    }).join('');
+}
+export { generate, node_path, parseNativeModules, runCodegen };

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export { }

package/dist/cli.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import { node_path, runCodegen } from "./131.js";
+function parseArgs(argv) {
+    const options = {
+        help: false
+    };
+    for(let index = 0; index < argv.length; index += 1){
+        const arg = argv[index];
+        if ('--help' === arg || '-h' === arg) {
+            options.help = true;
+            continue;
+        }
+        if ('--root' === arg || '-r' === arg) {
+            const value = argv[index + 1];
+            if (void 0 === value || value.startsWith('-')) throw new Error(`${arg} requires a value`);
+            options.root = value;
+            index += 1;
+            continue;
+        }
+        throw new Error(`Unknown option "${arg ?? ''}"`);
+    }
+    return options;
+}
+function printHelp() {
+    console.info(`Usage: lynx-autolink-codegen [--root <dir>]
+
+Generate Native Autolink JS, Android, and iOS specs from types/**/*.d.ts.
+
+Options:
+  --root, -r <dir>  Extension package root. Defaults to the current directory.
+  --help, -h        Show this help message.
+`);
+}
+function main() {
+    const cliOptions = parseArgs(process.argv.slice(2));
+    if (cliOptions.help) return void printHelp();
+    const options = {};
+    if (void 0 !== cliOptions.root) options.root = node_path.resolve(cliOptions.root);
+    const files = runCodegen(options);
+    for (const file of files)console.info(`generated ${file.path}`);
+}
+try {
+    main();
+} catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+}

package/dist/index.d.ts

@@ -0,0 +1,48 @@
+export declare interface CodegenOptions {
+    root?: string;
+}
+
+/**
+ * Builds the generated JS facade, Android spec, and iOS spec file contents for an extension package.
+ */
+export declare function generate(options?: CodegenOptions): GeneratedFile[];
+
+export declare interface GeneratedFile {
+    path: string;
+    content: string;
+}
+
+export declare interface NativeModuleMethod {
+    name: string;
+    params: NativeModuleParam[];
+    returnType: NativeModuleType;
+}
+
+export declare interface NativeModuleParam {
+    name: string;
+    type: NativeModuleType;
+}
+
+export declare interface NativeModuleSpec {
+    name: string;
+    methods: NativeModuleMethod[];
+}
+
+export declare interface NativeModuleType {
+    name: NativeModuleTypeName;
+    nullable: boolean;
+}
+
+export declare type NativeModuleTypeName = 'void' | 'string' | 'number' | 'boolean';
+
+/**
+ * Parses native module declarations marked with `@lynxmodule` from a TypeScript declaration source.
+ */
+export declare function parseNativeModules(source: string, filename?: string): NativeModuleSpec[];
+
+/**
+ * Writes generated files to disk and returns the generated file descriptors.
+ */
+export declare function runCodegen(options?: CodegenOptions): GeneratedFile[];
+
+export { }

package/dist/index.js

@@ -0,0 +1 @@
+export { generate, parseNativeModules, runCodegen } from "./131.js";

package/package.json

@@ -1,9 +1,40 @@
 {
   "name": "@lynx-js/autolink-codegen",
-  "version": "0.0.0",
+  "version": "0.1.0",
   "description": "Native Autolink code generator for Lynx extensions",
-  "keywords": [],
+  "keywords": [
+    "Lynx",
+    "Autolink",
+    "codegen"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lynx-family/lynx-stack.git",
+    "directory": "packages/lynx/autolink-codegen"
+  },
   "license": "Apache-2.0",
+  "sideEffects": false,
   "type": "module",
-  "main": "index.js"
-}
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "lynx-autolink-codegen": "./dist/cli.js"
+  },
+  "files": [
+    "CHANGELOG.md",
+    "README.md",
+    "dist"
+  ],
+  "engines": {
+    "node": "^20 || ^22 || ^24"
+  },
+  "scripts": {
+    "build": "rslib build",
+    "dev": "rslib build --watch",
+    "test": "vitest run"
+  }
+}

package/index.js

@@ -1 +0,0 @@
-export {}