@jay-framework/rollup-plugin 0.5.0

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+import { CompiledPattern, FunctionRepositoryBuilder } from '@jay-framework/compiler';
+export * from '@jay-framework/compiler';
+import { LoadResult, TransformResult, CustomPluginOptions, ResolveIdResult } from 'rollup';
+import * as ts from 'typescript';
+import { CompilerOptions } from 'typescript';
+import { GenerateTarget, CompilerSourceFile } from '@jay-framework/compiler-shared';
+
+declare function jayDefinitions(): {
+    name: string;
+    load(id: string): Promise<LoadResult>;
+    transform(code: string, id: string): Promise<TransformResult>;
+};
+
+interface ResolveIdOptions {
+    attributes: Record<string, string>;
+    custom?: CustomPluginOptions;
+    isEntry: boolean;
+    skipSelf?: boolean;
+}
+
+interface JayRollupConfig {
+    tsConfigFilePath?: string;
+    tsCompilerOptionsOverrides?: CompilerOptions;
+    outputDir?: string;
+    isWorker?: boolean;
+    compilerPatternFiles?: string[];
+    generationTarget?: GenerateTarget;
+}
+
+declare class JayPluginContext {
+    readonly jayOptions: JayRollupConfig;
+    readonly projectRoot: string;
+    readonly outputDir: string;
+    readonly tsPrinter: ts.Printer;
+    readonly compilerPatterns: CompiledPattern[];
+    readonly jayFileCache: Map<string, CompilerSourceFile>;
+    readonly globalFunctionsRepository: FunctionRepositoryBuilder;
+    constructor(jayOptions?: JayRollupConfig);
+    cacheJayFile(id: string, jayFile: CompilerSourceFile): CompilerSourceFile;
+    getCachedJayFile(id: string): CompilerSourceFile;
+    deleteCachedJayFile(id: string): boolean;
+}
+
+declare function jayRuntime(jayOptions?: JayRollupConfig, givenJayContext?: JayPluginContext): {
+    name: string;
+    resolveId(source: string, importer: string | undefined, options: ResolveIdOptions): Promise<ResolveIdResult>;
+    load(id: string): Promise<LoadResult>;
+    transform(code: string, id: string): Promise<TransformResult>;
+    watchChange(id: string, change: {
+        event: 'create' | 'update' | 'delete';
+    }): void;
+};
+
+export { JayPluginContext, type JayRollupConfig, jayDefinitions, jayRuntime };

package/dist/index.js

@@ -0,0 +1,487 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const compiler = require("@jay-framework/compiler");
+const path = require("node:path");
+const compilerShared = require("@jay-framework/compiler-shared");
+const promises = require("node:fs/promises");
+const promises$1 = require("fs/promises");
+const compilerJayHtml = require("@jay-framework/compiler-jay-html");
+const ts = require("typescript");
+const fs = require("fs");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const ts__namespace = /* @__PURE__ */ _interopNamespaceDefault(ts);
+function getFileContext(filename, extension = compilerShared.JAY_EXTENSION) {
+  return {
+    filename: path.basename(filename).replace(extension, ""),
+    dirname: path.dirname(filename)
+  };
+}
+async function readFileAsString(filePath) {
+  return (await promises.readFile(filePath)).toString();
+}
+async function writeDefinitionFile(dirname, filename, source, extension) {
+  const name = path.resolve(dirname, `${filename}${extension}`);
+  await promises$1.writeFile(name, source, { encoding: "utf8", flag: "w" });
+  return name;
+}
+async function writeGeneratedFile(jayContext, context, id, code) {
+  if (!jayContext.outputDir)
+    return;
+  const relativePath = path.dirname(path.relative(jayContext.projectRoot, id));
+  const filePath = path.resolve(jayContext.outputDir, relativePath, path.basename(id));
+  await promises.mkdir(path.dirname(filePath), { recursive: true });
+  await promises$1.writeFile(filePath, code, { encoding: "utf8", flag: "w" });
+  console.info(["[transform] written", filePath].join(" "));
+  return filePath;
+}
+function checkCodeErrors(code) {
+  if (code.length === 0)
+    throw new Error("Empty code file");
+  return code;
+}
+function jayDefinitions() {
+  return {
+    name: "jay:definitions",
+    // this name will show up in warnings and errors
+    async load(id) {
+      if (compilerShared.hasExtension(id, compilerShared.JAY_EXTENSION) || compilerShared.hasExtension(id, compilerShared.JAY_CONTRACT_EXTENSION)) {
+        const code = await readFileAsString(id);
+        checkCodeErrors(code);
+        return { code };
+      }
+      return null;
+    },
+    async transform(code, id) {
+      if (compilerShared.hasExtension(id, compilerShared.JAY_EXTENSION)) {
+        const context = this;
+        const { filename, dirname } = getFileContext(id);
+        const imports = compilerJayHtml.getJayHtmlImports(code).filter(
+          (module2) => module2.endsWith("jay-html.d")
+        );
+        await Promise.all(
+          imports.map(
+            (imported) => context.load({
+              id: path.resolve(dirname, imported.slice(0, -2)),
+              resolveDependencies: true
+            })
+          )
+        );
+        const parsedFile = await compilerJayHtml.parseJayFile(
+          code,
+          filename,
+          dirname,
+          {},
+          compilerJayHtml.JAY_IMPORT_RESOLVER
+        );
+        const tsCode = compilerShared.checkValidationErrors(compiler.generateElementDefinitionFile(parsedFile));
+        const generatedFilename = await writeDefinitionFile(
+          dirname,
+          filename,
+          tsCode,
+          compilerShared.JAY_DTS_EXTENSION
+        );
+        context.info(`[transform] generated ${generatedFilename}`);
+        return { code: "", map: null };
+      } else if (compilerShared.hasExtension(id, compilerShared.JAY_CONTRACT_EXTENSION)) {
+        const context = this;
+        const { filename, dirname } = getFileContext(id, compilerShared.JAY_CONTRACT_EXTENSION);
+        const parsedFile = compilerJayHtml.parseContract(code, filename);
+        const tsCode = await compilerJayHtml.compileContract(
+          parsedFile,
+          `${dirname}/${filename}`,
+          compilerJayHtml.JAY_IMPORT_RESOLVER
+        );
+        const generatedFilename = await writeDefinitionFile(
+          dirname,
+          filename,
+          tsCode.val,
+          compilerShared.JAY_CONTRACT_DTS_EXTENSION
+        );
+        context.info(`[transform] generated ${generatedFilename}`);
+        return { code: "", map: null };
+      }
+      return null;
+    }
+  };
+}
+const SANDBOX_ROOT_PREFIX = "jay-sandbox:";
+function getJayMetadata(context, id, { checkPresent = false } = {}) {
+  return jayMetadataFromModuleMetadata(id, context.getModuleInfo(id)?.meta, { checkPresent });
+}
+function jayMetadataFromModuleMetadata(id, meta, { checkPresent = false } = {}) {
+  const metadata = meta?.jay ?? {};
+  if (checkPresent) {
+    if (!metadata.originId)
+      throw new Error(`Unknown Jay originId for ${id}`);
+    if (!metadata.format)
+      throw new Error(`Unknown Jay format for ${id}`);
+  }
+  return metadata;
+}
+function appendJayMetadata(context, id, metadata, moduleMetadata) {
+  return { jay: { ...moduleMetadata ?? getJayMetadata(context, id), ...metadata } };
+}
+function getSourceJayMetadata(context, id) {
+  const metadata = getJayMetadata(context, id, { checkPresent: true });
+  const sourcePath = metadata.originId;
+  if (!sourcePath)
+    throw new Error(`Unknown Jay originId for ${id}`);
+  const sourceMetadata = getJayMetadata(context, sourcePath);
+  return sourceMetadata.originId ? sourceMetadata : metadata;
+}
+async function getJayFileStructure(jayContext, context, code, id) {
+  const meta = getSourceJayMetadata(context, id);
+  const sourceJayFile = jayContext.getCachedJayFile(meta.originId);
+  if (Boolean(sourceJayFile))
+    return { meta, jayFile: sourceJayFile };
+  const jayFile = compilerShared.checkValidationErrors(await getJayFile(jayContext, meta, code));
+  jayContext.cacheJayFile(meta.originId, jayFile);
+  return { meta, jayFile };
+}
+async function getJayFile(jayContext, meta, code) {
+  const { originId: id, format } = meta;
+  switch (format) {
+    case compilerShared.SourceFileFormat.JayHtml:
+      return await getJayStructureFromJayHtmlSource(jayContext, code, id);
+    case compilerShared.SourceFileFormat.TypeScript:
+      return await getJayStructureFromTypeScriptSource(code, id);
+    default:
+      throw new Error(`Unknown Jay format ${format}`);
+  }
+}
+async function getJayStructureFromJayHtmlSource(jayContext, code, id) {
+  const { filename, dirname } = getFileContext(id);
+  return await compilerJayHtml.parseJayFile(
+    code,
+    filename,
+    dirname,
+    {
+      relativePath: jayContext.jayOptions.tsConfigFilePath
+    },
+    compilerJayHtml.JAY_IMPORT_RESOLVER
+  );
+}
+async function getJayStructureFromTypeScriptSource(code, id) {
+  return await compiler.parseGenericTypescriptFile(id, code);
+}
+function checkDiagnosticsErrors(tsCode) {
+  if (tsCode.diagnostics.length > 0) {
+    throw new Error(
+      `typescript transpilation failed ${tsCode.diagnostics.map((diagnostic) => diagnostic.toString()).join("\n")}`
+    );
+  }
+}
+async function generateCodeFromStructure(jayContext, context, code, id, meta, jayFile) {
+  const { format } = meta;
+  const mode = compilerShared.getModeFromExtension(id);
+  const generationTarget = jayContext.jayOptions.generationTarget || compilerShared.GenerateTarget.jay;
+  const tsCode = format === compilerShared.SourceFileFormat.JayHtml ? generateCodeFromJayHtmlFile(mode, jayFile, generationTarget) : generateCodeFromTsFile(jayContext, mode, jayFile, id, code);
+  await writeGeneratedFile(jayContext, context, id, tsCode);
+  return tsCode;
+}
+function generateCodeFromJayHtmlFile(mode, jayFile, generationTarget) {
+  switch (mode) {
+    case compilerShared.RuntimeMode.MainTrusted:
+    case compilerShared.RuntimeMode.MainSandbox:
+      return compilerShared.checkValidationErrors(compiler.generateElementFile(jayFile, mode, generationTarget));
+    case compilerShared.RuntimeMode.WorkerSandbox:
+      return compilerJayHtml.generateElementBridgeFile(jayFile);
+    case compilerShared.RuntimeMode.WorkerTrusted:
+      return hasSandboxImport(jayFile) ? compilerJayHtml.generateSandboxRootFile(jayFile) : compiler.generateImportsFileFromJayFile(jayFile);
+  }
+}
+function hasSandboxImport(jayFile) {
+  return jayFile.imports.some((link) => link.sandbox);
+}
+function generateCodeFromTsFile(jayContext, mode, jayFile, id, code) {
+  switch (mode) {
+    case compilerShared.RuntimeMode.MainTrusted:
+      return code;
+    case compilerShared.RuntimeMode.MainSandbox: {
+      if (!code.includes("makeJayComponent"))
+        return code;
+      return transformTsCode(
+        jayContext,
+        [
+          compiler.transformComponentBridge(
+            mode,
+            jayContext.compilerPatterns,
+            jayContext.globalFunctionsRepository
+          )
+        ],
+        id,
+        code
+      );
+    }
+    case compilerShared.RuntimeMode.WorkerTrusted:
+      return compiler.generateImportsFileFromJayFile(jayFile);
+    case compilerShared.RuntimeMode.WorkerSandbox:
+      return transformTsCode(
+        jayContext,
+        [
+          compiler.transformComponent(
+            jayContext.compilerPatterns,
+            jayContext.globalFunctionsRepository
+          )
+        ],
+        id,
+        code
+      );
+  }
+}
+function transformTsCode(jayContext, transformers, id, code) {
+  const tsSource = ts__namespace.createSourceFile(id, code, ts__namespace.ScriptTarget.Latest, true, ts__namespace.ScriptKind.TS);
+  const tsCode = ts.transform(tsSource, transformers);
+  checkDiagnosticsErrors(tsCode);
+  const outputCode = jayContext.tsPrinter.printNode(
+    ts__namespace.EmitHint.Unspecified,
+    tsCode.transformed[0],
+    tsSource
+  );
+  return outputCode;
+}
+async function transformJayFile(jayContext, context, code, id) {
+  if (!Boolean(getJayMetadata(context, id).originId))
+    return null;
+  const mode = compilerShared.getModeFromExtension(id);
+  console.info(`[transform] start ${mode} ${id}`);
+  const { meta, jayFile } = await getJayFileStructure(jayContext, context, code, id);
+  const tsCode = await generateCodeFromStructure(jayContext, context, code, id, meta, jayFile);
+  console.info(`[transform] end ${mode} ${id}`);
+  return { code: tsCode };
+}
+function watchChangesFor(context, sourcePath) {
+  if (context.getWatchFiles().includes(sourcePath))
+    return;
+  context.addWatchFile(sourcePath);
+  console.info(`[watch] add ${sourcePath}`);
+}
+async function resolveJayHtml(context, source, importer, options, generationTarget = compilerShared.GenerateTarget.jay) {
+  const resolved = await context.resolve(source, importer, { ...options, skipSelf: true });
+  if (!resolved || compilerShared.hasExtension(resolved.id, compilerShared.TS_EXTENSION) || compilerShared.hasExtension(resolved.id, compilerShared.TSX_EXTENSION))
+    return null;
+  const resolvedJayMeta = jayMetadataFromModuleMetadata(resolved.id, resolved.meta);
+  const extension = generationTarget === compilerShared.GenerateTarget.react ? compilerShared.TSX_EXTENSION : compilerShared.TS_EXTENSION;
+  if (resolvedJayMeta.originId) {
+    const { format, originId } = resolvedJayMeta;
+    const id = `${originId}${extension}`;
+    console.info(`[resolveId] resolved ${id} as ${format}`);
+    return { id, meta: appendJayMetadata(context, id, { format, originId }) };
+  } else {
+    watchChangesFor(context, resolved.id);
+    const format = compilerShared.SourceFileFormat.JayHtml;
+    const originId = resolved.id;
+    const id = `${originId}${extension}`;
+    console.info(`[resolveId] resolved ${id} as ${format}`);
+    return { id, meta: appendJayMetadata(context, id, { format, originId }) };
+  }
+}
+async function resolveJayContract(context, source, importer, options) {
+  const resolved = await context.resolve(source, importer, { ...options, skipSelf: true });
+  const id = `${resolved.id}${compilerShared.TS_EXTENSION}`;
+  console.info(`[resolveId] resolved ${id}`);
+  return {
+    id,
+    meta: appendJayMetadata(context, id, {
+      format: compilerShared.SourceFileFormat.JayContract,
+      originId: resolved.id
+    })
+  };
+}
+async function resolveJayModeFile(context, source, importer, options) {
+  const idParts = source.split("?");
+  const idWithoutJayModeExtension = idParts.slice(0, -1).join("?");
+  const mode = idParts.slice(-1)[0];
+  const resolved = await context.resolve(idWithoutJayModeExtension, importer, {
+    ...options,
+    skipSelf: false
+  });
+  if (!resolved)
+    return null;
+  const resolvedJayMeta = jayMetadataFromModuleMetadata(resolved.id, resolved.meta);
+  const format = resolvedJayMeta.format || compilerShared.SourceFileFormat.TypeScript;
+  const originId = resolvedJayMeta.originId || resolved.id;
+  const id = getResolvedId(resolved, mode, originId);
+  console.info(`[resolveId] resolved ${id} as ${format}`);
+  return { id, meta: appendJayMetadata(context, id, { format, originId }, resolvedJayMeta) };
+}
+async function removeSandboxPrefixForWorkerRoot(context, source, importer, options) {
+  const sourceWithoutPrefix = source.replace(SANDBOX_ROOT_PREFIX, "");
+  const resolved = await context.resolve(sourceWithoutPrefix, importer, {
+    ...options,
+    skipSelf: true
+  });
+  if (!resolved)
+    return null;
+  const id = `${resolved.id}${compilerShared.JAY_QUERY_WORKER_TRUSTED_TS}`;
+  const originId = id.split("?")[0];
+  console.info(`[resolveId] resolved sandbox root ${id}`);
+  return {
+    id,
+    meta: appendJayMetadata(context, id, {
+      originId,
+      format: compilerShared.SourceFileFormat.TypeScript,
+      isWorkerRoot: true
+    })
+  };
+}
+function getResolvedId(resolved, mode, originId) {
+  const extension = resolved.id.split(".").pop();
+  const id = `${originId}?${mode}.${extension}`;
+  return id;
+}
+function stripTSExtension(id) {
+  return id.replace(compilerShared.TS_EXTENSION, "").replace(compilerShared.TSX_EXTENSION, "");
+}
+async function loadJayFile(context, id) {
+  console.info(`[load] start ${id}`);
+  let { originId } = getJayMetadata(context, id);
+  if (!Boolean(originId))
+    originId = stripTSExtension(id);
+  const code = checkCodeErrors(await readFileAsString(originId));
+  console.info(`[load] end ${id}`);
+  return { code };
+}
+async function loadContractFile(context, id) {
+  console.info(`[load] start ${id}`);
+  let { originId } = getJayMetadata(context, id);
+  if (!Boolean(originId))
+    originId = stripTSExtension(id);
+  const code = await readFileAsString(originId);
+  console.info(`[load] end ${id}`);
+  return { code };
+}
+class JayPluginContext {
+  constructor(jayOptions = {}) {
+    __publicField(this, "projectRoot");
+    __publicField(this, "outputDir");
+    __publicField(this, "tsPrinter");
+    __publicField(this, "compilerPatterns");
+    __publicField(this, "jayFileCache", /* @__PURE__ */ new Map());
+    __publicField(this, "globalFunctionsRepository");
+    this.jayOptions = jayOptions;
+    this.projectRoot = path.dirname(jayOptions.tsConfigFilePath ?? process.cwd());
+    this.outputDir = jayOptions.outputDir && path.join(this.projectRoot, jayOptions.outputDir);
+    this.tsPrinter = ts__namespace.createPrinter({ newLine: ts__namespace.NewLineKind.LineFeed });
+    let compilerPatternsParseResult = compiler.compileFunctionSplitPatternsBlock(
+      (jayOptions.compilerPatternFiles || []).map((fileName) => {
+        let fileContent = fs.readFileSync(fileName, { encoding: "utf8" });
+        return compiler.createTsSourceFileFromSource(fileName, fileContent);
+      })
+    );
+    if (compilerPatternsParseResult.validations.length > 0)
+      throw new Error(
+        "failed to parse or validate compilerPatternFiles. \n" + compilerPatternsParseResult.validations.join("\n")
+      );
+    this.compilerPatterns = compilerPatternsParseResult.val;
+    this.globalFunctionsRepository = new compiler.FunctionRepositoryBuilder();
+  }
+  cacheJayFile(id, jayFile) {
+    console.info("[cache] set", id);
+    this.jayFileCache.set(id, jayFile);
+    return jayFile;
+  }
+  getCachedJayFile(id) {
+    const jayFile = this.jayFileCache.get(id);
+    if (Boolean(jayFile)) {
+      console.info("[cache] hit", id);
+    }
+    return jayFile;
+  }
+  deleteCachedJayFile(id) {
+    return this.jayFileCache.delete(id);
+  }
+}
+const GLOBAL_FUNC_REPOSITORY = "GLOBAL_FUNC_REPOSITORY.ts";
+function jayRuntime(jayOptions = {}, givenJayContext) {
+  const jayContext = givenJayContext || new JayPluginContext(jayOptions);
+  return {
+    name: "jay:runtime",
+    // this name will show up in warnings and errors
+    async resolveId(source, importer, options) {
+      if (compilerShared.hasExtension(source, compilerShared.JAY_EXTENSION))
+        return await resolveJayHtml(
+          this,
+          source,
+          importer,
+          options,
+          jayOptions.generationTarget
+        );
+      if (compilerShared.hasExtension(source, compilerShared.JAY_CONTRACT_EXTENSION))
+        return await resolveJayContract(this, source, importer, options);
+      if (compilerShared.hasJayModeExtension(source))
+        return await resolveJayModeFile(this, source, importer, options);
+      if (source.includes(SANDBOX_ROOT_PREFIX) || jayOptions.isWorker && importer === void 0)
+        return await removeSandboxPrefixForWorkerRoot(this, source, importer, options);
+      if (source === compilerShared.Import.functionRepository.module)
+        return Promise.resolve(GLOBAL_FUNC_REPOSITORY);
+      return null;
+    },
+    async load(id) {
+      if (compilerShared.hasExtension(id, compilerShared.JAY_EXTENSION, { withTs: true }) || compilerShared.hasJayModeExtension(id, { withTs: true }))
+        return await loadJayFile(this, id);
+      else if (compilerShared.hasExtension(id, compilerShared.JAY_CONTRACT_EXTENSION, { withTs: true })) {
+        return await loadContractFile(this, id);
+      } else if (id === GLOBAL_FUNC_REPOSITORY) {
+        const { functionRepository } = jayContext.globalFunctionsRepository.generateGlobalFile();
+        return functionRepository;
+      }
+      return null;
+    },
+    async transform(code, id) {
+      if (compilerShared.hasExtension(id, compilerShared.JAY_EXTENSION, { withTs: true }) || compilerShared.hasJayModeExtension(id, { withTs: true }))
+        return await transformJayFile(jayContext, this, code, id);
+      else if (compilerShared.hasExtension(id, compilerShared.JAY_CONTRACT_EXTENSION, { withTs: true })) {
+        const { filename, dirname } = getFileContext(id, compilerShared.JAY_CONTRACT_EXTENSION);
+        const parsedFile = compilerJayHtml.parseContract(code, filename);
+        const tsCode = await compilerJayHtml.compileContract(
+          parsedFile,
+          `${dirname}/${filename}`,
+          compilerJayHtml.JAY_IMPORT_RESOLVER
+        );
+        if (tsCode.val)
+          return Promise.resolve({
+            code: tsCode.val
+          });
+        else
+          return Promise.reject(tsCode.validations);
+      }
+      return null;
+    },
+    watchChange(id, change) {
+      console.log(`[watchChange] ${id} ${change.event}`);
+      jayContext.deleteCachedJayFile(id);
+    }
+  };
+}
+exports.JayPluginContext = JayPluginContext;
+exports.jayDefinitions = jayDefinitions;
+exports.jayRuntime = jayRuntime;
+Object.keys(compiler).forEach((k) => {
+  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k))
+    Object.defineProperty(exports, k, {
+      enumerable: true,
+      get: () => compiler[k]
+    });
+});

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@jay-framework/rollup-plugin",
+  "version": "0.5.0",
+  "license": "Apache-2.0",
+  "main": "dist/index.js",
+  "keywords": [
+    "jay",
+    "secure",
+    "rollup-plugin"
+  ],
+  "files": [
+    "dist",
+    "readme.md"
+  ],
+  "scripts": {
+    "build": "npm run build:js && npm run build:types",
+    "build:watch": "npm run build:js -- --watch & npm run build:types -- --watch",
+    "build:watch:sandbox-counter": "vite -c test/jayRuntime/fixtures/counter/source/vite.config.ts",
+    "build:js": "vite build",
+    "build:types": "tsup lib/index.ts --dts-only --format cjs",
+    "build:check-types": "tsc",
+    "build:executable-bin": "chmod +x dist/index.js",
+    "clean": "rimraf dist && rimraf test/jayRuntime/fixtures/counter/dist && rimraf test/jayRuntime/fixtures/exec/dist",
+    "confirm": "npm run clean && npm run build && npm run build:check-types && npm run test",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@jay-framework/compiler": "workspace:^",
+    "@jay-framework/compiler-jay-html": "workspace:^",
+    "fast-glob": "^3.3.2",
+    "typescript": "^5.3.3"
+  },
+  "devDependencies": {
+    "@jay-framework/component": "workspace:^",
+    "@jay-framework/dev-environment": "workspace:^",
+    "@jay-framework/runtime": "workspace:^",
+    "@jay-framework/secure": "workspace:^",
+    "@types/node": "^20.11.5",
+    "rimraf": "^5.0.5",
+    "rollup": "^4.9.5",
+    "rollup-plugin-typescript2": "^0.36.0",
+    "tsup": "^8.0.1",
+    "vite": "^5.0.11",
+    "vitest": "^1.2.1",
+    "vitest-mock-extended": "^1.3.1"
+  }
+}