@autometa/app 0.0.0 → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# @autometa/app
+
+## 0.1.0
+
+### Minor Changes
+
+- 554b77e: Releasing packages
+
+### Patch Changes
+
+- Updated dependencies [554b77e]
+  - @autometa/asserters@0.1.0
+  - @autometa/errors@0.1.0
+  - @autometa/phrases@0.1.0

package/dist/esm/index.js

@@ -1,5 +1,85 @@
-// src/index.ts
-var src_default = {};
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+
+// src/autometa-app.ts
+var AutometaApp = class {
+};
+
+// src/autometa-world.ts
+import { PhraseParser } from "@autometa/phrases";
+var AutometaWorld = class {
+};
+AutometaWorld = __decorateClass([
+  PhraseParser
+], AutometaWorld);
+
+// src/get-app.ts
+import { container } from "tsyringe";
+import { AutomationError } from "@autometa/errors";
+function getApp(appType, worldType, ...instances) {
+  if (!appType) {
+    throw new AutomationError(`A reference to an 'app' and 'world' is required to run tests.
+
+Configure the app by extending 'AutometaApp' and adding it to your
+'autometa.config.ts' file:
+
+@AppType(MyWorld)
+export class MyAutometaApp extends AutometaApp {
+    ...
+}
+defineConfig({
+   roots: {
+    app: './src/apps'
+   }
+})`);
+  }
+  container.registerType(worldType, worldType);
+  instances.forEach(
+    ({ token, instance, cls }) => instance ? child.registerInstance(token, instance) : cls ? child.registerType(token, cls) : null
+  );
+  const child = container.createChildContainer();
+  const app = child.resolve(appType);
+  app.world = child.resolve(worldType);
+  return app;
+}
+
+// src/decorators/fixture.ts
+import "reflect-metadata";
+import { scoped, inject, Lifecycle, injectable } from "tsyringe";
+function Fixture(scope = Lifecycle.ContainerScoped) {
+  return (target) => {
+    injectable()(target);
+    scoped(scope)(
+      target
+    );
+  };
+}
+var Inject = inject;
+
+// src/decorators/app-type.ts
+import { Lifecycle as Lifecycle2 } from "tsyringe";
+function AppType(container2, world, environment = "default") {
+  const env = environment ?? "default";
+  return (target) => {
+    Fixture(Lifecycle2.ContainerScoped)(target);
+    container2[env] = { app: target, world };
+  };
+}
 export {
-  src_default as default
+  AppType,
+  AutometaApp,
+  AutometaWorld,
+  Fixture,
+  Inject,
+  getApp
 };
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/autometa-app.ts","../../src/autometa-world.ts","../../src/get-app.ts","../../src/decorators/fixture.ts","../../src/decorators/app-type.ts"],"sourcesContent":["import { World } from \"./fixtures.typings\";\n\nexport abstract class AutometaApp {\n  [key: string]: unknown;\n  world: World\n}\n","import { PhraseParser, IFromPhrase } from \"@autometa/phrases\";\n\n@PhraseParser\nexport class AutometaWorld {\n  [key: string]: unknown;\n\n  fromPhrase: IFromPhrase;\n}\n","import { container } from \"tsyringe\";\nimport { AutometaApp } from \"./autometa-app\";\nimport { Class } from \"@autometa/types\";\nimport { AutomationError } from \"@autometa/errors\";\nimport { AutometaWorld } from \".\";\n\nexport function getApp<T extends AutometaApp, K extends AutometaWorld>(\n  appType: Class<T>,\n  worldType: Class<K>,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ...instances: { token: any; instance?: any; cls?: Class<any> }[]\n) {\n  if (!appType) {\n    throw new AutomationError(`A reference to an 'app' and 'world' is required to run tests.\n\nConfigure the app by extending 'AutometaApp' and adding it to your\n'autometa.config.ts' file:\n\n@AppType(MyWorld)\nexport class MyAutometaApp extends AutometaApp {\n    ...\n}\ndefineConfig({\n   roots: {\n    app: './src/apps'\n   }\n})`);\n  }\n  container.registerType(worldType, worldType);\n  instances.forEach(({ token, instance, cls }) =>\n    instance\n      ? child.registerInstance(token, instance)\n      : cls\n      ? child.registerType(token, cls)\n      : null\n  );\n\n  const child = container.createChildContainer();\n  const app = child.resolve(appType);\n  app.world = child.resolve(worldType);\n  return app;\n}\n","import \"reflect-metadata\";\n\nimport { Class } from \"@autometa/types\";\nimport { scoped, inject, Lifecycle, injectable } from \"tsyringe\";\n/**\n * Marks a class as an injectable fixture. Constructor parameters\n * which are also injectable will be automatically constructed\n * and passed to the constructor.\n *\n * Example fixtures are the `App` which acts as  shared\n * entry point for all steps in a test, and the World,\n * which stores persistent data across tests.\n *\n * Fixtures are persistent by default, meaning each class\n * will exist as a singleton for the duration of the test\n * ```ts\n * ＠Fixture\n * export class World {\n *  [key: string]: unknown;\n *\n *  declare someExpectedData: MyDataType\n * }\n *\n * ＠Fixture\n * export class MyClient {\n *   constructor(world: MyWorld){}\n *\n *    login = async ()=>{\n *      this.world.someExpectedData = await fetch(...)\n *    }\n * }\n *\n * ＠Fixture\n * export class App {\n *    constructor(\n *      world: MyWorld,\n *      client: MyClient\n *    ){}\n * }\n * ```\n */\nexport function Fixture(scope = Lifecycle.ContainerScoped) {\n  return (target: Class<unknown>) => {\n    injectable()(target);\n    scoped(scope as Lifecycle.ContainerScoped | Lifecycle.ResolutionScoped)(\n      target\n    );\n  };\n}\n\nexport const Inject = inject;\n\n\n","import { Class } from \"@autometa/types\";\nimport { Lifecycle } from \"tsyringe\";\nimport { AutometaWorld } from \"..\";\nimport { Fixture } from \"./fixture\";\n\n\nexport function AppType(\n  container: Record<string, { app: unknown; world: unknown; }>,\n  world: Class<AutometaWorld>,\n  environment = \"default\"\n) {\n  const env = environment ?? \"default\";\n  return (target: Class<unknown>) => {\n    Fixture(Lifecycle.ContainerScoped)(target);\n    container[env] = { app: target, world };\n  };\n}\n"],"mappings":";;;;;;;;;;;;;AAEO,IAAe,cAAf,MAA2B;AAGlC;;;ACLA,SAAS,oBAAiC;AAGnC,IAAM,gBAAN,MAAoB;AAI3B;AAJa,gBAAN;AAAA,EADN;AAAA,GACY;;;ACHb,SAAS,iBAAiB;AAG1B,SAAS,uBAAuB;AAGzB,SAAS,OACd,SACA,cAEG,WACH;AACA,MAAI,CAAC,SAAS;AACZ,UAAM,IAAI,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,GAa3B;AAAA,EACD;AACA,YAAU,aAAa,WAAW,SAAS;AAC3C,YAAU;AAAA,IAAQ,CAAC,EAAE,OAAO,UAAU,IAAI,MACxC,WACI,MAAM,iBAAiB,OAAO,QAAQ,IACtC,MACA,MAAM,aAAa,OAAO,GAAG,IAC7B;AAAA,EACN;AAEA,QAAM,QAAQ,UAAU,qBAAqB;AAC7C,QAAM,MAAM,MAAM,QAAQ,OAAO;AACjC,MAAI,QAAQ,MAAM,QAAQ,SAAS;AACnC,SAAO;AACT;;;ACzCA,OAAO;AAGP,SAAS,QAAQ,QAAQ,WAAW,kBAAkB;AAsC/C,SAAS,QAAQ,QAAQ,UAAU,iBAAiB;AACzD,SAAO,CAAC,WAA2B;AACjC,eAAW,EAAE,MAAM;AACnB,WAAO,KAA+D;AAAA,MACpE;AAAA,IACF;AAAA,EACF;AACF;AAEO,IAAM,SAAS;;;ACjDtB,SAAS,aAAAA,kBAAiB;AAKnB,SAAS,QACdC,YACA,OACA,cAAc,WACd;AACA,QAAM,MAAM,eAAe;AAC3B,SAAO,CAAC,WAA2B;AACjC,YAAQC,WAAU,eAAe,EAAE,MAAM;AACzC,IAAAD,WAAU,GAAG,IAAI,EAAE,KAAK,QAAQ,MAAM;AAAA,EACxC;AACF;","names":["Lifecycle","container","Lifecycle"]}

package/dist/index.d.cts

@@ -0,0 +1,72 @@
+import { IFromPhrase } from '@autometa/phrases';
+import { Class } from '@autometa/types';
+import { Lifecycle, inject } from 'tsyringe';
+
+interface World {
+}
+interface App {
+    world: World;
+}
+
+declare abstract class AutometaApp {
+    [key: string]: unknown;
+    world: World;
+}
+
+declare class AutometaWorld {
+    [key: string]: unknown;
+    fromPhrase: IFromPhrase;
+}
+
+declare function getApp<T extends AutometaApp, K extends AutometaWorld>(appType: Class<T>, worldType: Class<K>, ...instances: {
+    token: any;
+    instance?: any;
+    cls?: Class<any>;
+}[]): T;
+
+/**
+ * Marks a class as an injectable fixture. Constructor parameters
+ * which are also injectable will be automatically constructed
+ * and passed to the constructor.
+ *
+ * Example fixtures are the `App` which acts as  shared
+ * entry point for all steps in a test, and the World,
+ * which stores persistent data across tests.
+ *
+ * Fixtures are persistent by default, meaning each class
+ * will exist as a singleton for the duration of the test
+ * ```ts
+ * ＠Fixture
+ * export class World {
+ *  [key: string]: unknown;
+ *
+ *  declare someExpectedData: MyDataType
+ * }
+ *
+ * ＠Fixture
+ * export class MyClient {
+ *   constructor(world: MyWorld){}
+ *
+ *    login = async ()=>{
+ *      this.world.someExpectedData = await fetch(...)
+ *    }
+ * }
+ *
+ * ＠Fixture
+ * export class App {
+ *    constructor(
+ *      world: MyWorld,
+ *      client: MyClient
+ *    ){}
+ * }
+ * ```
+ */
+declare function Fixture(scope?: Lifecycle): (target: Class<unknown>) => void;
+declare const Inject: typeof inject;
+
+declare function AppType(container: Record<string, {
+    app: unknown;
+    world: unknown;
+}>, world: Class<AutometaWorld>, environment?: string): (target: Class<unknown>) => void;
+
+export { App, AppType, AutometaApp, AutometaWorld, Fixture, Inject, World, getApp };

package/dist/index.d.ts

@@ -1,3 +1,72 @@
-declare const _default: {};
+import { IFromPhrase } from '@autometa/phrases';
+import { Class } from '@autometa/types';
+import { Lifecycle, inject } from 'tsyringe';
 
-export { _default as default };
+interface World {
+}
+interface App {
+    world: World;
+}
+
+declare abstract class AutometaApp {
+    [key: string]: unknown;
+    world: World;
+}
+
+declare class AutometaWorld {
+    [key: string]: unknown;
+    fromPhrase: IFromPhrase;
+}
+
+declare function getApp<T extends AutometaApp, K extends AutometaWorld>(appType: Class<T>, worldType: Class<K>, ...instances: {
+    token: any;
+    instance?: any;
+    cls?: Class<any>;
+}[]): T;
+
+/**
+ * Marks a class as an injectable fixture. Constructor parameters
+ * which are also injectable will be automatically constructed
+ * and passed to the constructor.
+ *
+ * Example fixtures are the `App` which acts as  shared
+ * entry point for all steps in a test, and the World,
+ * which stores persistent data across tests.
+ *
+ * Fixtures are persistent by default, meaning each class
+ * will exist as a singleton for the duration of the test
+ * ```ts
+ * ＠Fixture
+ * export class World {
+ *  [key: string]: unknown;
+ *
+ *  declare someExpectedData: MyDataType
+ * }
+ *
+ * ＠Fixture
+ * export class MyClient {
+ *   constructor(world: MyWorld){}
+ *
+ *    login = async ()=>{
+ *      this.world.someExpectedData = await fetch(...)
+ *    }
+ * }
+ *
+ * ＠Fixture
+ * export class App {
+ *    constructor(
+ *      world: MyWorld,
+ *      client: MyClient
+ *    ){}
+ * }
+ * ```
+ */
+declare function Fixture(scope?: Lifecycle): (target: Class<unknown>) => void;
+declare const Inject: typeof inject;
+
+declare function AppType(container: Record<string, {
+    app: unknown;
+    world: unknown;
+}>, world: Class<AutometaWorld>, environment?: string): (target: Class<unknown>) => void;
+
+export { App, AppType, AutometaApp, AutometaWorld, Fixture, Inject, World, getApp };

package/dist/index.js

@@ -16,11 +16,99 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  default: () => src_default
+  AppType: () => AppType,
+  AutometaApp: () => AutometaApp,
+  AutometaWorld: () => AutometaWorld,
+  Fixture: () => Fixture,
+  Inject: () => Inject,
+  getApp: () => getApp
 });
 module.exports = __toCommonJS(src_exports);
-var src_default = {};
+
+// src/autometa-app.ts
+var AutometaApp = class {
+};
+
+// src/autometa-world.ts
+var import_phrases = require("@autometa/phrases");
+var AutometaWorld = class {
+};
+AutometaWorld = __decorateClass([
+  import_phrases.PhraseParser
+], AutometaWorld);
+
+// src/get-app.ts
+var import_tsyringe = require("tsyringe");
+var import_errors = require("@autometa/errors");
+function getApp(appType, worldType, ...instances) {
+  if (!appType) {
+    throw new import_errors.AutomationError(`A reference to an 'app' and 'world' is required to run tests.
+
+Configure the app by extending 'AutometaApp' and adding it to your
+'autometa.config.ts' file:
+
+@AppType(MyWorld)
+export class MyAutometaApp extends AutometaApp {
+    ...
+}
+defineConfig({
+   roots: {
+    app: './src/apps'
+   }
+})`);
+  }
+  import_tsyringe.container.registerType(worldType, worldType);
+  instances.forEach(
+    ({ token, instance, cls }) => instance ? child.registerInstance(token, instance) : cls ? child.registerType(token, cls) : null
+  );
+  const child = import_tsyringe.container.createChildContainer();
+  const app = child.resolve(appType);
+  app.world = child.resolve(worldType);
+  return app;
+}
+
+// src/decorators/fixture.ts
+var import_reflect_metadata = require("reflect-metadata");
+var import_tsyringe2 = require("tsyringe");
+function Fixture(scope = import_tsyringe2.Lifecycle.ContainerScoped) {
+  return (target) => {
+    (0, import_tsyringe2.injectable)()(target);
+    (0, import_tsyringe2.scoped)(scope)(
+      target
+    );
+  };
+}
+var Inject = import_tsyringe2.inject;
+
+// src/decorators/app-type.ts
+var import_tsyringe3 = require("tsyringe");
+function AppType(container2, world, environment = "default") {
+  const env = environment ?? "default";
+  return (target) => {
+    Fixture(import_tsyringe3.Lifecycle.ContainerScoped)(target);
+    container2[env] = { app: target, world };
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AppType,
+  AutometaApp,
+  AutometaWorld,
+  Fixture,
+  Inject,
+  getApp
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/autometa-app.ts","../src/autometa-world.ts","../src/get-app.ts","../src/decorators/fixture.ts","../src/decorators/app-type.ts"],"sourcesContent":["export * from './autometa-app'\nexport * from './autometa-world'\nexport * from './get-app'\nexport * from './decorators'\nexport * from './fixtures.typings'","import { World } from \"./fixtures.typings\";\n\nexport abstract class AutometaApp {\n  [key: string]: unknown;\n  world: World\n}\n","import { PhraseParser, IFromPhrase } from \"@autometa/phrases\";\n\n@PhraseParser\nexport class AutometaWorld {\n  [key: string]: unknown;\n\n  fromPhrase: IFromPhrase;\n}\n","import { container } from \"tsyringe\";\nimport { AutometaApp } from \"./autometa-app\";\nimport { Class } from \"@autometa/types\";\nimport { AutomationError } from \"@autometa/errors\";\nimport { AutometaWorld } from \".\";\n\nexport function getApp<T extends AutometaApp, K extends AutometaWorld>(\n  appType: Class<T>,\n  worldType: Class<K>,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ...instances: { token: any; instance?: any; cls?: Class<any> }[]\n) {\n  if (!appType) {\n    throw new AutomationError(`A reference to an 'app' and 'world' is required to run tests.\n\nConfigure the app by extending 'AutometaApp' and adding it to your\n'autometa.config.ts' file:\n\n@AppType(MyWorld)\nexport class MyAutometaApp extends AutometaApp {\n    ...\n}\ndefineConfig({\n   roots: {\n    app: './src/apps'\n   }\n})`);\n  }\n  container.registerType(worldType, worldType);\n  instances.forEach(({ token, instance, cls }) =>\n    instance\n      ? child.registerInstance(token, instance)\n      : cls\n      ? child.registerType(token, cls)\n      : null\n  );\n\n  const child = container.createChildContainer();\n  const app = child.resolve(appType);\n  app.world = child.resolve(worldType);\n  return app;\n}\n","import \"reflect-metadata\";\n\nimport { Class } from \"@autometa/types\";\nimport { scoped, inject, Lifecycle, injectable } from \"tsyringe\";\n/**\n * Marks a class as an injectable fixture. Constructor parameters\n * which are also injectable will be automatically constructed\n * and passed to the constructor.\n *\n * Example fixtures are the `App` which acts as  shared\n * entry point for all steps in a test, and the World,\n * which stores persistent data across tests.\n *\n * Fixtures are persistent by default, meaning each class\n * will exist as a singleton for the duration of the test\n * ```ts\n * ＠Fixture\n * export class World {\n *  [key: string]: unknown;\n *\n *  declare someExpectedData: MyDataType\n * }\n *\n * ＠Fixture\n * export class MyClient {\n *   constructor(world: MyWorld){}\n *\n *    login = async ()=>{\n *      this.world.someExpectedData = await fetch(...)\n *    }\n * }\n *\n * ＠Fixture\n * export class App {\n *    constructor(\n *      world: MyWorld,\n *      client: MyClient\n *    ){}\n * }\n * ```\n */\nexport function Fixture(scope = Lifecycle.ContainerScoped) {\n  return (target: Class<unknown>) => {\n    injectable()(target);\n    scoped(scope as Lifecycle.ContainerScoped | Lifecycle.ResolutionScoped)(\n      target\n    );\n  };\n}\n\nexport const Inject = inject;\n\n\n","import { Class } from \"@autometa/types\";\nimport { Lifecycle } from \"tsyringe\";\nimport { AutometaWorld } from \"..\";\nimport { Fixture } from \"./fixture\";\n\n\nexport function AppType(\n  container: Record<string, { app: unknown; world: unknown; }>,\n  world: Class<AutometaWorld>,\n  environment = \"default\"\n) {\n  const env = environment ?? \"default\";\n  return (target: Class<unknown>) => {\n    Fixture(Lifecycle.ContainerScoped)(target);\n    container[env] = { app: target, world };\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACEO,IAAe,cAAf,MAA2B;AAGlC;;;ACLA,qBAA0C;AAGnC,IAAM,gBAAN,MAAoB;AAI3B;AAJa,gBAAN;AAAA,EADN;AAAA,GACY;;;ACHb,sBAA0B;AAG1B,oBAAgC;AAGzB,SAAS,OACd,SACA,cAEG,WACH;AACA,MAAI,CAAC,SAAS;AACZ,UAAM,IAAI,8BAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,GAa3B;AAAA,EACD;AACA,4BAAU,aAAa,WAAW,SAAS;AAC3C,YAAU;AAAA,IAAQ,CAAC,EAAE,OAAO,UAAU,IAAI,MACxC,WACI,MAAM,iBAAiB,OAAO,QAAQ,IACtC,MACA,MAAM,aAAa,OAAO,GAAG,IAC7B;AAAA,EACN;AAEA,QAAM,QAAQ,0BAAU,qBAAqB;AAC7C,QAAM,MAAM,MAAM,QAAQ,OAAO;AACjC,MAAI,QAAQ,MAAM,QAAQ,SAAS;AACnC,SAAO;AACT;;;ACzCA,8BAAO;AAGP,IAAAA,mBAAsD;AAsC/C,SAAS,QAAQ,QAAQ,2BAAU,iBAAiB;AACzD,SAAO,CAAC,WAA2B;AACjC,qCAAW,EAAE,MAAM;AACnB,iCAAO,KAA+D;AAAA,MACpE;AAAA,IACF;AAAA,EACF;AACF;AAEO,IAAM,SAAS;;;ACjDtB,IAAAC,mBAA0B;AAKnB,SAAS,QACdC,YACA,OACA,cAAc,WACd;AACA,QAAM,MAAM,eAAe;AAC3B,SAAO,CAAC,WAA2B;AACjC,YAAQ,2BAAU,eAAe,EAAE,MAAM;AACzC,IAAAA,WAAU,GAAG,IAAI,EAAE,KAAK,QAAQ,MAAM;AAAA,EACxC;AACF;","names":["import_tsyringe","import_tsyringe","container"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autometa/app",
-  "version": "0.0.0",
+  "version": "0.1.0",
   "description": "App and World container for Autometa",
   "type": "module",
   "main": "dist/index.js",
@@ -14,21 +14,47 @@
   },
   "license": "MIT",
   "devDependencies": {
+    "@autometa/types": "^0.4.0",
     "@types/node": "^18.11.18",
     "@types/uuid": "^9.0.1",
     "@typescript-eslint/eslint-plugin": "^5.54.1",
     "@typescript-eslint/parser": "^5.54.1",
+    "@vitest/coverage-istanbul": "^0.31.0",
+    "asserters": "link:packages/asserters",
+    "autometa": "link:packages/autometa",
+    "config": "link:packages/config",
+    "coordinator": "link:packages/coordinator",
+    "cucumber-expressions": "link:packages/cucumber-expressions",
+    "datetime": "link:packages/datetime",
+    "errors": "link:packages/errors",
     "eslint": "^8.37.0",
-    "eslint-config-custom": "0.5.1",
+    "eslint-config-custom": "0.6.0",
     "eslint-config-prettier": "^8.3.0",
+    "events": "link:packages/events",
+    "gherkin": "link:packages/gherkin",
+    "jest-executor": "link:packages/jest-executor",
+    "jest-transformer": "link:packages/jest-transformer",
+    "phrases": "link:packages/phrases",
+    "reflect-metadata": "^0.1.13",
     "rimraf": "^4.1.2",
+    "scopes": "link:packages/scopes",
+    "test-builder": "link:packages/test-builder",
+    "test-executor": "link:packages/test-executor",
     "tsconfig": " *",
-    "tsup": "^6.7.0",
+    "tsup": "^7.2.0",
+    "types": "link:packages/types",
     "typescript": "^4.9.5",
-    "vitest": "^0.29.8"
+    "vitest": "0.33.0"
+  },
+  "dependencies": {
+    "@autometa/asserters": "0.1.0",
+    "@autometa/errors": "0.1.0",
+    "@autometa/phrases": "0.1.0",
+    "tsyringe": "^4.8.0"
   },
   "scripts": {
     "test": "vitest run --passWithNoTests",
+    "coverage": "vitest run --coverage",
     "prettify": "prettier --config .prettierrc 'src/**/*.ts' --write",
     "lint": "eslint . --max-warnings 0",
     "lint:fix": "eslint . --fix",

package/tsup.config.ts

@@ -4,6 +4,7 @@ export default defineConfig({
   clean: true, // clean up the dist folder
   format: ["cjs", "esm"], // generate cjs and esm files
   dts: true,
+  sourcemap:true, // generate sourcemaps
   skipNodeModulesBundle: true,
   entryPoints: ["src/index.ts"],
   target: "es2020",