@xframework/x 0.4.0

package/dist/core/x.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/adapters.ts","../../src/core/x.ts"],"sourcesContent":["import type { SyncAdapterType, AsyncAdapterType } from \"./types\";\n\nexport abstract class SyncAdapter<TExport> implements SyncAdapterType<TExport> {\n  readonly __type = \"sync\" as const;\n  init?(): void;\n  abstract export(): TExport;\n}\n\nexport abstract class AsyncAdapter<TExport>\n  implements AsyncAdapterType<TExport>\n{\n  readonly __type = \"async\" as const;\n  init?(): Promise<void>;\n  abstract export(): Promise<TExport>;\n}\n\nexport class AdapterError extends Error {\n  constructor(\n    message: string,\n    public readonly adapterName: string,\n    public readonly cause?: unknown,\n  ) {\n    super(message);\n    this.name = \"AdapterError\";\n  }\n}\n","import { AdapterError } from \"./adapters\";\nimport type {\n  SyncAdapterCreator,\n  SyncAdapterType,\n  AsyncAdapterCreator,\n  AsyncAdapterType,\n  AdapterRegistry,\n  AdapterResult,\n  BuildOutput,\n} from \"./types\";\n\ntype AdapterFactory<T extends AdapterRegistry> =\n  | [(deps: AdapterResult<T>) => SyncAdapterType<unknown>, false]\n  | [(deps: AdapterResult<T>) => Promise<AsyncAdapterType<unknown>>, true];\n\nclass X<\n  TAdapters extends AdapterRegistry = Record<string, never>,\n  TIsAsync extends boolean = false,\n> {\n  constructor(\n    private readonly adapterFactories: Record<\n      string,\n      AdapterFactory<TAdapters>\n    > = {} as Record<string, AdapterFactory<TAdapters>>,\n    private readonly isAsync: TIsAsync = false as TIsAsync,\n  ) {}\n\n  syncAdapter<TKey extends string, TExport>(\n    name: TKey,\n    factory: SyncAdapterCreator<TExport, TAdapters>,\n  ): X<TAdapters & Record<TKey, SyncAdapterType<TExport>>, TIsAsync> {\n    type NewAdapters = TAdapters & Record<TKey, SyncAdapterType<TExport>>;\n    const newFactories = { ...this.adapterFactories };\n    // We know this is safe because factory is a SyncAdapterCreator\n    (newFactories as Record<string, unknown>)[name] = [\n      factory,\n      false,\n    ] as AdapterFactory<NewAdapters>;\n    return new X(\n      newFactories as Record<string, AdapterFactory<NewAdapters>>,\n      this.isAsync,\n    );\n  }\n\n  asyncAdapter<TKey extends string, TExport>(\n    name: TKey,\n    factory: AsyncAdapterCreator<TExport, TAdapters>,\n  ): X<TAdapters & Record<TKey, AsyncAdapterType<TExport>>, true> {\n    type NewAdapters = TAdapters & Record<TKey, AsyncAdapterType<TExport>>;\n    const wrappedFactory = async (deps: AdapterResult<TAdapters>) => {\n      const result = factory(deps);\n      return result instanceof Promise ? await result : result;\n    };\n\n    const newFactories = { ...this.adapterFactories };\n    // We know this is safe because wrappedFactory returns a Promise<AsyncAdapterType>\n    (newFactories as Record<string, unknown>)[name] = [\n      wrappedFactory,\n      true,\n    ] as AdapterFactory<NewAdapters>;\n    return new X(\n      newFactories as Record<string, AdapterFactory<NewAdapters>>,\n      true,\n    );\n  }\n\n  use<TOtherAdapters extends AdapterRegistry, TOtherAsync extends boolean>(\n    other: X<TOtherAdapters, TOtherAsync>,\n  ): X<TAdapters & TOtherAdapters, TIsAsync | TOtherAsync> {\n    type CombinedAdapters = TAdapters & TOtherAdapters;\n    const newFactories = {\n      ...this.adapterFactories,\n      ...other[\"adapterFactories\"],\n    } as Record<string, AdapterFactory<CombinedAdapters>>;\n    return new X(newFactories, this.isAsync || other[\"isAsync\"]);\n  }\n\n  build(): BuildOutput<TAdapters, TIsAsync> {\n    return this.isAsync\n      ? (this.buildAsync() as BuildOutput<TAdapters, TIsAsync>)\n      : (this.buildSync() as BuildOutput<TAdapters, TIsAsync>);\n  }\n\n  private buildSync(): AdapterResult<TAdapters> {\n    const result = {\n      _: { adapters: {} as TAdapters },\n    } as AdapterResult<TAdapters>;\n\n    for (const [key, [factory, isAsync]] of Object.entries(\n      this.adapterFactories,\n    )) {\n      if (isAsync) {\n        throw new AdapterError(\n          `Cannot use async adapter \"${key}\" in sync build`,\n          key,\n        );\n      }\n\n      const adapter = factory(result) as SyncAdapterType<unknown>;\n\n      if (adapter.__type !== \"sync\") {\n        throw new AdapterError(\n          `Factory returned async adapter \"${key}\" in sync build`,\n          key,\n        );\n      }\n\n      (result._.adapters as Record<string, SyncAdapterType<unknown>>)[key] =\n        adapter;\n      adapter.init?.();\n      (result as Record<string, unknown>)[key] = adapter.export();\n    }\n\n    return result;\n  }\n\n  private async buildAsync(): Promise<AdapterResult<TAdapters>> {\n    const result = {\n      _: { adapters: {} as TAdapters },\n    } as AdapterResult<TAdapters>;\n\n    for (const [key, [factory, isAsync]] of Object.entries(\n      this.adapterFactories,\n    )) {\n      const currentResult = { ...result };\n      const adapter = isAsync\n        ? await (\n            factory as (\n              deps: AdapterResult<TAdapters>,\n            ) => Promise<AsyncAdapterType<unknown>>\n          )(currentResult)\n        : (\n            factory as (\n              deps: AdapterResult<TAdapters>,\n            ) => SyncAdapterType<unknown>\n          )(currentResult);\n\n      (\n        result._.adapters as Record<\n          string,\n          SyncAdapterType<unknown> | AsyncAdapterType<unknown>\n        >\n      )[key] = adapter;\n\n      if (adapter.init) {\n        if (adapter.__type === \"async\") {\n          await adapter.init();\n        } else {\n          adapter.init();\n        }\n      }\n\n      (result as Record<string, unknown>)[key] =\n        adapter.__type === \"async\" ? await adapter.export() : adapter.export();\n    }\n\n    return result;\n  }\n}\n\nexport function createX() {\n  return new X();\n}\n"],"mappings":";AAgBO,IAAM,eAAN,cAA2B,MAAM;AAAA,EACtC,YACE,SACgB,aACA,OAChB;AACA,UAAM,OAAO;AAHG;AACA;AAGhB,SAAK,OAAO;AAAA,EACd;AACF;;;ACVA,IAAM,IAAN,MAAM,GAGJ;AAAA,EACA,YACmB,mBAGb,CAAC,GACY,UAAoB,OACrC;AALiB;AAIA;AAAA,EAChB;AAAA,EAEH,YACE,MACA,SACiE;AAEjE,UAAM,eAAe,EAAE,GAAG,KAAK,iBAAiB;AAEhD,IAAC,aAAyC,IAAI,IAAI;AAAA,MAChD;AAAA,MACA;AAAA,IACF;AACA,WAAO,IAAI;AAAA,MACT;AAAA,MACA,KAAK;AAAA,IACP;AAAA,EACF;AAAA,EAEA,aACE,MACA,SAC8D;AAE9D,UAAM,iBAAiB,OAAO,SAAmC;AAC/D,YAAM,SAAS,QAAQ,IAAI;AAC3B,aAAO,kBAAkB,UAAU,MAAM,SAAS;AAAA,IACpD;AAEA,UAAM,eAAe,EAAE,GAAG,KAAK,iBAAiB;AAEhD,IAAC,aAAyC,IAAI,IAAI;AAAA,MAChD;AAAA,MACA;AAAA,IACF;AACA,WAAO,IAAI;AAAA,MACT;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAAA,EAEA,IACE,OACuD;AAEvD,UAAM,eAAe;AAAA,MACnB,GAAG,KAAK;AAAA,MACR,GAAG,MAAM,kBAAkB;AAAA,IAC7B;AACA,WAAO,IAAI,GAAE,cAAc,KAAK,WAAW,MAAM,SAAS,CAAC;AAAA,EAC7D;AAAA,EAEA,QAA0C;AACxC,WAAO,KAAK,UACP,KAAK,WAAW,IAChB,KAAK,UAAU;AAAA,EACtB;AAAA,EAEQ,YAAsC;AAC5C,UAAM,SAAS;AAAA,MACb,GAAG,EAAE,UAAU,CAAC,EAAe;AAAA,IACjC;AAEA,eAAW,CAAC,KAAK,CAAC,SAAS,OAAO,CAAC,KAAK,OAAO;AAAA,MAC7C,KAAK;AAAA,IACP,GAAG;AACD,UAAI,SAAS;AACX,cAAM,IAAI;AAAA,UACR,6BAA6B,GAAG;AAAA,UAChC;AAAA,QACF;AAAA,MACF;AAEA,YAAM,UAAU,QAAQ,MAAM;AAE9B,UAAI,QAAQ,WAAW,QAAQ;AAC7B,cAAM,IAAI;AAAA,UACR,mCAAmC,GAAG;AAAA,UACtC;AAAA,QACF;AAAA,MACF;AAEA,MAAC,OAAO,EAAE,SAAsD,GAAG,IACjE;AACF,cAAQ,OAAO;AACf,MAAC,OAAmC,GAAG,IAAI,QAAQ,OAAO;AAAA,IAC5D;AAEA,WAAO;AAAA,EACT;AAAA,EAEA,MAAc,aAAgD;AAC5D,UAAM,SAAS;AAAA,MACb,GAAG,EAAE,UAAU,CAAC,EAAe;AAAA,IACjC;AAEA,eAAW,CAAC,KAAK,CAAC,SAAS,OAAO,CAAC,KAAK,OAAO;AAAA,MAC7C,KAAK;AAAA,IACP,GAAG;AACD,YAAM,gBAAgB,EAAE,GAAG,OAAO;AAClC,YAAM,UAAU,UACZ,MACE,QAGA,aAAa,IAEb,QAGA,aAAa;AAEnB,MACE,OAAO,EAAE,SAIT,GAAG,IAAI;AAET,UAAI,QAAQ,MAAM;AAChB,YAAI,QAAQ,WAAW,SAAS;AAC9B,gBAAM,QAAQ,KAAK;AAAA,QACrB,OAAO;AACL,kBAAQ,KAAK;AAAA,QACf;AAAA,MACF;AAEA,MAAC,OAAmC,GAAG,IACrC,QAAQ,WAAW,UAAU,MAAM,QAAQ,OAAO,IAAI,QAAQ,OAAO;AAAA,IACzE;AAEA,WAAO;AAAA,EACT;AACF;AAEO,SAAS,UAAU;AACxB,SAAO,IAAI,EAAE;AACf;","names":[]}

package/dist/index.cjs

@@ -0,0 +1,134 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createX: () => createX
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/adapters.ts
+var AdapterError = class extends Error {
+  constructor(message, adapterName, cause) {
+    super(message);
+    this.adapterName = adapterName;
+    this.cause = cause;
+    this.name = "AdapterError";
+  }
+};
+
+// src/core/x.ts
+var X = class _X {
+  constructor(adapterFactories = {}, isAsync = false) {
+    this.adapterFactories = adapterFactories;
+    this.isAsync = isAsync;
+  }
+  syncAdapter(name, factory) {
+    const newFactories = { ...this.adapterFactories };
+    newFactories[name] = [
+      factory,
+      false
+    ];
+    return new _X(
+      newFactories,
+      this.isAsync
+    );
+  }
+  asyncAdapter(name, factory) {
+    const wrappedFactory = async (deps) => {
+      const result = factory(deps);
+      return result instanceof Promise ? await result : result;
+    };
+    const newFactories = { ...this.adapterFactories };
+    newFactories[name] = [
+      wrappedFactory,
+      true
+    ];
+    return new _X(
+      newFactories,
+      true
+    );
+  }
+  use(other) {
+    const newFactories = {
+      ...this.adapterFactories,
+      ...other["adapterFactories"]
+    };
+    return new _X(newFactories, this.isAsync || other["isAsync"]);
+  }
+  build() {
+    return this.isAsync ? this.buildAsync() : this.buildSync();
+  }
+  buildSync() {
+    const result = {
+      _: { adapters: {} }
+    };
+    for (const [key, [factory, isAsync]] of Object.entries(
+      this.adapterFactories
+    )) {
+      if (isAsync) {
+        throw new AdapterError(
+          `Cannot use async adapter "${key}" in sync build`,
+          key
+        );
+      }
+      const adapter = factory(result);
+      if (adapter.__type !== "sync") {
+        throw new AdapterError(
+          `Factory returned async adapter "${key}" in sync build`,
+          key
+        );
+      }
+      result._.adapters[key] = adapter;
+      adapter.init?.();
+      result[key] = adapter.export();
+    }
+    return result;
+  }
+  async buildAsync() {
+    const result = {
+      _: { adapters: {} }
+    };
+    for (const [key, [factory, isAsync]] of Object.entries(
+      this.adapterFactories
+    )) {
+      const currentResult = { ...result };
+      const adapter = isAsync ? await factory(currentResult) : factory(currentResult);
+      result._.adapters[key] = adapter;
+      if (adapter.init) {
+        if (adapter.__type === "async") {
+          await adapter.init();
+        } else {
+          adapter.init();
+        }
+      }
+      result[key] = adapter.__type === "async" ? await adapter.export() : adapter.export();
+    }
+    return result;
+  }
+};
+function createX() {
+  return new X();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createX
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/core/adapters.ts","../src/core/x.ts"],"sourcesContent":["export { createX } from \"./core/x\";\n","import type { SyncAdapterType, AsyncAdapterType } from \"./types\";\n\nexport abstract class SyncAdapter<TExport> implements SyncAdapterType<TExport> {\n  readonly __type = \"sync\" as const;\n  init?(): void;\n  abstract export(): TExport;\n}\n\nexport abstract class AsyncAdapter<TExport>\n  implements AsyncAdapterType<TExport>\n{\n  readonly __type = \"async\" as const;\n  init?(): Promise<void>;\n  abstract export(): Promise<TExport>;\n}\n\nexport class AdapterError extends Error {\n  constructor(\n    message: string,\n    public readonly adapterName: string,\n    public readonly cause?: unknown,\n  ) {\n    super(message);\n    this.name = \"AdapterError\";\n  }\n}\n","import { AdapterError } from \"./adapters\";\nimport type {\n  SyncAdapterCreator,\n  SyncAdapterType,\n  AsyncAdapterCreator,\n  AsyncAdapterType,\n  AdapterRegistry,\n  AdapterResult,\n  BuildOutput,\n} from \"./types\";\n\ntype AdapterFactory<T extends AdapterRegistry> =\n  | [(deps: AdapterResult<T>) => SyncAdapterType<unknown>, false]\n  | [(deps: AdapterResult<T>) => Promise<AsyncAdapterType<unknown>>, true];\n\nclass X<\n  TAdapters extends AdapterRegistry = Record<string, never>,\n  TIsAsync extends boolean = false,\n> {\n  constructor(\n    private readonly adapterFactories: Record<\n      string,\n      AdapterFactory<TAdapters>\n    > = {} as Record<string, AdapterFactory<TAdapters>>,\n    private readonly isAsync: TIsAsync = false as TIsAsync,\n  ) {}\n\n  syncAdapter<TKey extends string, TExport>(\n    name: TKey,\n    factory: SyncAdapterCreator<TExport, TAdapters>,\n  ): X<TAdapters & Record<TKey, SyncAdapterType<TExport>>, TIsAsync> {\n    type NewAdapters = TAdapters & Record<TKey, SyncAdapterType<TExport>>;\n    const newFactories = { ...this.adapterFactories };\n    // We know this is safe because factory is a SyncAdapterCreator\n    (newFactories as Record<string, unknown>)[name] = [\n      factory,\n      false,\n    ] as AdapterFactory<NewAdapters>;\n    return new X(\n      newFactories as Record<string, AdapterFactory<NewAdapters>>,\n      this.isAsync,\n    );\n  }\n\n  asyncAdapter<TKey extends string, TExport>(\n    name: TKey,\n    factory: AsyncAdapterCreator<TExport, TAdapters>,\n  ): X<TAdapters & Record<TKey, AsyncAdapterType<TExport>>, true> {\n    type NewAdapters = TAdapters & Record<TKey, AsyncAdapterType<TExport>>;\n    const wrappedFactory = async (deps: AdapterResult<TAdapters>) => {\n      const result = factory(deps);\n      return result instanceof Promise ? await result : result;\n    };\n\n    const newFactories = { ...this.adapterFactories };\n    // We know this is safe because wrappedFactory returns a Promise<AsyncAdapterType>\n    (newFactories as Record<string, unknown>)[name] = [\n      wrappedFactory,\n      true,\n    ] as AdapterFactory<NewAdapters>;\n    return new X(\n      newFactories as Record<string, AdapterFactory<NewAdapters>>,\n      true,\n    );\n  }\n\n  use<TOtherAdapters extends AdapterRegistry, TOtherAsync extends boolean>(\n    other: X<TOtherAdapters, TOtherAsync>,\n  ): X<TAdapters & TOtherAdapters, TIsAsync | TOtherAsync> {\n    type CombinedAdapters = TAdapters & TOtherAdapters;\n    const newFactories = {\n      ...this.adapterFactories,\n      ...other[\"adapterFactories\"],\n    } as Record<string, AdapterFactory<CombinedAdapters>>;\n    return new X(newFactories, this.isAsync || other[\"isAsync\"]);\n  }\n\n  build(): BuildOutput<TAdapters, TIsAsync> {\n    return this.isAsync\n      ? (this.buildAsync() as BuildOutput<TAdapters, TIsAsync>)\n      : (this.buildSync() as BuildOutput<TAdapters, TIsAsync>);\n  }\n\n  private buildSync(): AdapterResult<TAdapters> {\n    const result = {\n      _: { adapters: {} as TAdapters },\n    } as AdapterResult<TAdapters>;\n\n    for (const [key, [factory, isAsync]] of Object.entries(\n      this.adapterFactories,\n    )) {\n      if (isAsync) {\n        throw new AdapterError(\n          `Cannot use async adapter \"${key}\" in sync build`,\n          key,\n        );\n      }\n\n      const adapter = factory(result) as SyncAdapterType<unknown>;\n\n      if (adapter.__type !== \"sync\") {\n        throw new AdapterError(\n          `Factory returned async adapter \"${key}\" in sync build`,\n          key,\n        );\n      }\n\n      (result._.adapters as Record<string, SyncAdapterType<unknown>>)[key] =\n        adapter;\n      adapter.init?.();\n      (result as Record<string, unknown>)[key] = adapter.export();\n    }\n\n    return result;\n  }\n\n  private async buildAsync(): Promise<AdapterResult<TAdapters>> {\n    const result = {\n      _: { adapters: {} as TAdapters },\n    } as AdapterResult<TAdapters>;\n\n    for (const [key, [factory, isAsync]] of Object.entries(\n      this.adapterFactories,\n    )) {\n      const currentResult = { ...result };\n      const adapter = isAsync\n        ? await (\n            factory as (\n              deps: AdapterResult<TAdapters>,\n            ) => Promise<AsyncAdapterType<unknown>>\n          )(currentResult)\n        : (\n            factory as (\n              deps: AdapterResult<TAdapters>,\n            ) => SyncAdapterType<unknown>\n          )(currentResult);\n\n      (\n        result._.adapters as Record<\n          string,\n          SyncAdapterType<unknown> | AsyncAdapterType<unknown>\n        >\n      )[key] = adapter;\n\n      if (adapter.init) {\n        if (adapter.__type === \"async\") {\n          await adapter.init();\n        } else {\n          adapter.init();\n        }\n      }\n\n      (result as Record<string, unknown>)[key] =\n        adapter.__type === \"async\" ? await adapter.export() : adapter.export();\n    }\n\n    return result;\n  }\n}\n\nexport function createX() {\n  return new X();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACgBO,IAAM,eAAN,cAA2B,MAAM;AAAA,EACtC,YACE,SACgB,aACA,OAChB;AACA,UAAM,OAAO;AAHG;AACA;AAGhB,SAAK,OAAO;AAAA,EACd;AACF;;;ACVA,IAAM,IAAN,MAAM,GAGJ;AAAA,EACA,YACmB,mBAGb,CAAC,GACY,UAAoB,OACrC;AALiB;AAIA;AAAA,EAChB;AAAA,EAEH,YACE,MACA,SACiE;AAEjE,UAAM,eAAe,EAAE,GAAG,KAAK,iBAAiB;AAEhD,IAAC,aAAyC,IAAI,IAAI;AAAA,MAChD;AAAA,MACA;AAAA,IACF;AACA,WAAO,IAAI;AAAA,MACT;AAAA,MACA,KAAK;AAAA,IACP;AAAA,EACF;AAAA,EAEA,aACE,MACA,SAC8D;AAE9D,UAAM,iBAAiB,OAAO,SAAmC;AAC/D,YAAM,SAAS,QAAQ,IAAI;AAC3B,aAAO,kBAAkB,UAAU,MAAM,SAAS;AAAA,IACpD;AAEA,UAAM,eAAe,EAAE,GAAG,KAAK,iBAAiB;AAEhD,IAAC,aAAyC,IAAI,IAAI;AAAA,MAChD;AAAA,MACA;AAAA,IACF;AACA,WAAO,IAAI;AAAA,MACT;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAAA,EAEA,IACE,OACuD;AAEvD,UAAM,eAAe;AAAA,MACnB,GAAG,KAAK;AAAA,MACR,GAAG,MAAM,kBAAkB;AAAA,IAC7B;AACA,WAAO,IAAI,GAAE,cAAc,KAAK,WAAW,MAAM,SAAS,CAAC;AAAA,EAC7D;AAAA,EAEA,QAA0C;AACxC,WAAO,KAAK,UACP,KAAK,WAAW,IAChB,KAAK,UAAU;AAAA,EACtB;AAAA,EAEQ,YAAsC;AAC5C,UAAM,SAAS;AAAA,MACb,GAAG,EAAE,UAAU,CAAC,EAAe;AAAA,IACjC;AAEA,eAAW,CAAC,KAAK,CAAC,SAAS,OAAO,CAAC,KAAK,OAAO;AAAA,MAC7C,KAAK;AAAA,IACP,GAAG;AACD,UAAI,SAAS;AACX,cAAM,IAAI;AAAA,UACR,6BAA6B,GAAG;AAAA,UAChC;AAAA,QACF;AAAA,MACF;AAEA,YAAM,UAAU,QAAQ,MAAM;AAE9B,UAAI,QAAQ,WAAW,QAAQ;AAC7B,cAAM,IAAI;AAAA,UACR,mCAAmC,GAAG;AAAA,UACtC;AAAA,QACF;AAAA,MACF;AAEA,MAAC,OAAO,EAAE,SAAsD,GAAG,IACjE;AACF,cAAQ,OAAO;AACf,MAAC,OAAmC,GAAG,IAAI,QAAQ,OAAO;AAAA,IAC5D;AAEA,WAAO;AAAA,EACT;AAAA,EAEA,MAAc,aAAgD;AAC5D,UAAM,SAAS;AAAA,MACb,GAAG,EAAE,UAAU,CAAC,EAAe;AAAA,IACjC;AAEA,eAAW,CAAC,KAAK,CAAC,SAAS,OAAO,CAAC,KAAK,OAAO;AAAA,MAC7C,KAAK;AAAA,IACP,GAAG;AACD,YAAM,gBAAgB,EAAE,GAAG,OAAO;AAClC,YAAM,UAAU,UACZ,MACE,QAGA,aAAa,IAEb,QAGA,aAAa;AAEnB,MACE,OAAO,EAAE,SAIT,GAAG,IAAI;AAET,UAAI,QAAQ,MAAM;AAChB,YAAI,QAAQ,WAAW,SAAS;AAC9B,gBAAM,QAAQ,KAAK;AAAA,QACrB,OAAO;AACL,kBAAQ,KAAK;AAAA,QACf;AAAA,MACF;AAEA,MAAC,OAAmC,GAAG,IACrC,QAAQ,WAAW,UAAU,MAAM,QAAQ,OAAO,IAAI,QAAQ,OAAO;AAAA,IACzE;AAEA,WAAO;AAAA,EACT;AACF;AAEO,SAAS,UAAU;AACxB,SAAO,IAAI,EAAE;AACf;","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,2 @@
+export { createX } from './core/x.cjs';
+import './core/types.cjs';

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { createX } from './core/x.js';
+import './core/types.js';

package/dist/index.js

@@ -0,0 +1,107 @@
+// src/core/adapters.ts
+var AdapterError = class extends Error {
+  constructor(message, adapterName, cause) {
+    super(message);
+    this.adapterName = adapterName;
+    this.cause = cause;
+    this.name = "AdapterError";
+  }
+};
+
+// src/core/x.ts
+var X = class _X {
+  constructor(adapterFactories = {}, isAsync = false) {
+    this.adapterFactories = adapterFactories;
+    this.isAsync = isAsync;
+  }
+  syncAdapter(name, factory) {
+    const newFactories = { ...this.adapterFactories };
+    newFactories[name] = [
+      factory,
+      false
+    ];
+    return new _X(
+      newFactories,
+      this.isAsync
+    );
+  }
+  asyncAdapter(name, factory) {
+    const wrappedFactory = async (deps) => {
+      const result = factory(deps);
+      return result instanceof Promise ? await result : result;
+    };
+    const newFactories = { ...this.adapterFactories };
+    newFactories[name] = [
+      wrappedFactory,
+      true
+    ];
+    return new _X(
+      newFactories,
+      true
+    );
+  }
+  use(other) {
+    const newFactories = {
+      ...this.adapterFactories,
+      ...other["adapterFactories"]
+    };
+    return new _X(newFactories, this.isAsync || other["isAsync"]);
+  }
+  build() {
+    return this.isAsync ? this.buildAsync() : this.buildSync();
+  }
+  buildSync() {
+    const result = {
+      _: { adapters: {} }
+    };
+    for (const [key, [factory, isAsync]] of Object.entries(
+      this.adapterFactories
+    )) {
+      if (isAsync) {
+        throw new AdapterError(
+          `Cannot use async adapter "${key}" in sync build`,
+          key
+        );
+      }
+      const adapter = factory(result);
+      if (adapter.__type !== "sync") {
+        throw new AdapterError(
+          `Factory returned async adapter "${key}" in sync build`,
+          key
+        );
+      }
+      result._.adapters[key] = adapter;
+      adapter.init?.();
+      result[key] = adapter.export();
+    }
+    return result;
+  }
+  async buildAsync() {
+    const result = {
+      _: { adapters: {} }
+    };
+    for (const [key, [factory, isAsync]] of Object.entries(
+      this.adapterFactories
+    )) {
+      const currentResult = { ...result };
+      const adapter = isAsync ? await factory(currentResult) : factory(currentResult);
+      result._.adapters[key] = adapter;
+      if (adapter.init) {
+        if (adapter.__type === "async") {
+          await adapter.init();
+        } else {
+          adapter.init();
+        }
+      }
+      result[key] = adapter.__type === "async" ? await adapter.export() : adapter.export();
+    }
+    return result;
+  }
+};
+function createX() {
+  return new X();
+}
+export {
+  createX
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/adapters.ts","../src/core/x.ts"],"sourcesContent":["import type { SyncAdapterType, AsyncAdapterType } from \"./types\";\n\nexport abstract class SyncAdapter<TExport> implements SyncAdapterType<TExport> {\n  readonly __type = \"sync\" as const;\n  init?(): void;\n  abstract export(): TExport;\n}\n\nexport abstract class AsyncAdapter<TExport>\n  implements AsyncAdapterType<TExport>\n{\n  readonly __type = \"async\" as const;\n  init?(): Promise<void>;\n  abstract export(): Promise<TExport>;\n}\n\nexport class AdapterError extends Error {\n  constructor(\n    message: string,\n    public readonly adapterName: string,\n    public readonly cause?: unknown,\n  ) {\n    super(message);\n    this.name = \"AdapterError\";\n  }\n}\n","import { AdapterError } from \"./adapters\";\nimport type {\n  SyncAdapterCreator,\n  SyncAdapterType,\n  AsyncAdapterCreator,\n  AsyncAdapterType,\n  AdapterRegistry,\n  AdapterResult,\n  BuildOutput,\n} from \"./types\";\n\ntype AdapterFactory<T extends AdapterRegistry> =\n  | [(deps: AdapterResult<T>) => SyncAdapterType<unknown>, false]\n  | [(deps: AdapterResult<T>) => Promise<AsyncAdapterType<unknown>>, true];\n\nclass X<\n  TAdapters extends AdapterRegistry = Record<string, never>,\n  TIsAsync extends boolean = false,\n> {\n  constructor(\n    private readonly adapterFactories: Record<\n      string,\n      AdapterFactory<TAdapters>\n    > = {} as Record<string, AdapterFactory<TAdapters>>,\n    private readonly isAsync: TIsAsync = false as TIsAsync,\n  ) {}\n\n  syncAdapter<TKey extends string, TExport>(\n    name: TKey,\n    factory: SyncAdapterCreator<TExport, TAdapters>,\n  ): X<TAdapters & Record<TKey, SyncAdapterType<TExport>>, TIsAsync> {\n    type NewAdapters = TAdapters & Record<TKey, SyncAdapterType<TExport>>;\n    const newFactories = { ...this.adapterFactories };\n    // We know this is safe because factory is a SyncAdapterCreator\n    (newFactories as Record<string, unknown>)[name] = [\n      factory,\n      false,\n    ] as AdapterFactory<NewAdapters>;\n    return new X(\n      newFactories as Record<string, AdapterFactory<NewAdapters>>,\n      this.isAsync,\n    );\n  }\n\n  asyncAdapter<TKey extends string, TExport>(\n    name: TKey,\n    factory: AsyncAdapterCreator<TExport, TAdapters>,\n  ): X<TAdapters & Record<TKey, AsyncAdapterType<TExport>>, true> {\n    type NewAdapters = TAdapters & Record<TKey, AsyncAdapterType<TExport>>;\n    const wrappedFactory = async (deps: AdapterResult<TAdapters>) => {\n      const result = factory(deps);\n      return result instanceof Promise ? await result : result;\n    };\n\n    const newFactories = { ...this.adapterFactories };\n    // We know this is safe because wrappedFactory returns a Promise<AsyncAdapterType>\n    (newFactories as Record<string, unknown>)[name] = [\n      wrappedFactory,\n      true,\n    ] as AdapterFactory<NewAdapters>;\n    return new X(\n      newFactories as Record<string, AdapterFactory<NewAdapters>>,\n      true,\n    );\n  }\n\n  use<TOtherAdapters extends AdapterRegistry, TOtherAsync extends boolean>(\n    other: X<TOtherAdapters, TOtherAsync>,\n  ): X<TAdapters & TOtherAdapters, TIsAsync | TOtherAsync> {\n    type CombinedAdapters = TAdapters & TOtherAdapters;\n    const newFactories = {\n      ...this.adapterFactories,\n      ...other[\"adapterFactories\"],\n    } as Record<string, AdapterFactory<CombinedAdapters>>;\n    return new X(newFactories, this.isAsync || other[\"isAsync\"]);\n  }\n\n  build(): BuildOutput<TAdapters, TIsAsync> {\n    return this.isAsync\n      ? (this.buildAsync() as BuildOutput<TAdapters, TIsAsync>)\n      : (this.buildSync() as BuildOutput<TAdapters, TIsAsync>);\n  }\n\n  private buildSync(): AdapterResult<TAdapters> {\n    const result = {\n      _: { adapters: {} as TAdapters },\n    } as AdapterResult<TAdapters>;\n\n    for (const [key, [factory, isAsync]] of Object.entries(\n      this.adapterFactories,\n    )) {\n      if (isAsync) {\n        throw new AdapterError(\n          `Cannot use async adapter \"${key}\" in sync build`,\n          key,\n        );\n      }\n\n      const adapter = factory(result) as SyncAdapterType<unknown>;\n\n      if (adapter.__type !== \"sync\") {\n        throw new AdapterError(\n          `Factory returned async adapter \"${key}\" in sync build`,\n          key,\n        );\n      }\n\n      (result._.adapters as Record<string, SyncAdapterType<unknown>>)[key] =\n        adapter;\n      adapter.init?.();\n      (result as Record<string, unknown>)[key] = adapter.export();\n    }\n\n    return result;\n  }\n\n  private async buildAsync(): Promise<AdapterResult<TAdapters>> {\n    const result = {\n      _: { adapters: {} as TAdapters },\n    } as AdapterResult<TAdapters>;\n\n    for (const [key, [factory, isAsync]] of Object.entries(\n      this.adapterFactories,\n    )) {\n      const currentResult = { ...result };\n      const adapter = isAsync\n        ? await (\n            factory as (\n              deps: AdapterResult<TAdapters>,\n            ) => Promise<AsyncAdapterType<unknown>>\n          )(currentResult)\n        : (\n            factory as (\n              deps: AdapterResult<TAdapters>,\n            ) => SyncAdapterType<unknown>\n          )(currentResult);\n\n      (\n        result._.adapters as Record<\n          string,\n          SyncAdapterType<unknown> | AsyncAdapterType<unknown>\n        >\n      )[key] = adapter;\n\n      if (adapter.init) {\n        if (adapter.__type === \"async\") {\n          await adapter.init();\n        } else {\n          adapter.init();\n        }\n      }\n\n      (result as Record<string, unknown>)[key] =\n        adapter.__type === \"async\" ? await adapter.export() : adapter.export();\n    }\n\n    return result;\n  }\n}\n\nexport function createX() {\n  return new X();\n}\n"],"mappings":";AAgBO,IAAM,eAAN,cAA2B,MAAM;AAAA,EACtC,YACE,SACgB,aACA,OAChB;AACA,UAAM,OAAO;AAHG;AACA;AAGhB,SAAK,OAAO;AAAA,EACd;AACF;;;ACVA,IAAM,IAAN,MAAM,GAGJ;AAAA,EACA,YACmB,mBAGb,CAAC,GACY,UAAoB,OACrC;AALiB;AAIA;AAAA,EAChB;AAAA,EAEH,YACE,MACA,SACiE;AAEjE,UAAM,eAAe,EAAE,GAAG,KAAK,iBAAiB;AAEhD,IAAC,aAAyC,IAAI,IAAI;AAAA,MAChD;AAAA,MACA;AAAA,IACF;AACA,WAAO,IAAI;AAAA,MACT;AAAA,MACA,KAAK;AAAA,IACP;AAAA,EACF;AAAA,EAEA,aACE,MACA,SAC8D;AAE9D,UAAM,iBAAiB,OAAO,SAAmC;AAC/D,YAAM,SAAS,QAAQ,IAAI;AAC3B,aAAO,kBAAkB,UAAU,MAAM,SAAS;AAAA,IACpD;AAEA,UAAM,eAAe,EAAE,GAAG,KAAK,iBAAiB;AAEhD,IAAC,aAAyC,IAAI,IAAI;AAAA,MAChD;AAAA,MACA;AAAA,IACF;AACA,WAAO,IAAI;AAAA,MACT;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAAA,EAEA,IACE,OACuD;AAEvD,UAAM,eAAe;AAAA,MACnB,GAAG,KAAK;AAAA,MACR,GAAG,MAAM,kBAAkB;AAAA,IAC7B;AACA,WAAO,IAAI,GAAE,cAAc,KAAK,WAAW,MAAM,SAAS,CAAC;AAAA,EAC7D;AAAA,EAEA,QAA0C;AACxC,WAAO,KAAK,UACP,KAAK,WAAW,IAChB,KAAK,UAAU;AAAA,EACtB;AAAA,EAEQ,YAAsC;AAC5C,UAAM,SAAS;AAAA,MACb,GAAG,EAAE,UAAU,CAAC,EAAe;AAAA,IACjC;AAEA,eAAW,CAAC,KAAK,CAAC,SAAS,OAAO,CAAC,KAAK,OAAO;AAAA,MAC7C,KAAK;AAAA,IACP,GAAG;AACD,UAAI,SAAS;AACX,cAAM,IAAI;AAAA,UACR,6BAA6B,GAAG;AAAA,UAChC;AAAA,QACF;AAAA,MACF;AAEA,YAAM,UAAU,QAAQ,MAAM;AAE9B,UAAI,QAAQ,WAAW,QAAQ;AAC7B,cAAM,IAAI;AAAA,UACR,mCAAmC,GAAG;AAAA,UACtC;AAAA,QACF;AAAA,MACF;AAEA,MAAC,OAAO,EAAE,SAAsD,GAAG,IACjE;AACF,cAAQ,OAAO;AACf,MAAC,OAAmC,GAAG,IAAI,QAAQ,OAAO;AAAA,IAC5D;AAEA,WAAO;AAAA,EACT;AAAA,EAEA,MAAc,aAAgD;AAC5D,UAAM,SAAS;AAAA,MACb,GAAG,EAAE,UAAU,CAAC,EAAe;AAAA,IACjC;AAEA,eAAW,CAAC,KAAK,CAAC,SAAS,OAAO,CAAC,KAAK,OAAO;AAAA,MAC7C,KAAK;AAAA,IACP,GAAG;AACD,YAAM,gBAAgB,EAAE,GAAG,OAAO;AAClC,YAAM,UAAU,UACZ,MACE,QAGA,aAAa,IAEb,QAGA,aAAa;AAEnB,MACE,OAAO,EAAE,SAIT,GAAG,IAAI;AAET,UAAI,QAAQ,MAAM;AAChB,YAAI,QAAQ,WAAW,SAAS;AAC9B,gBAAM,QAAQ,KAAK;AAAA,QACrB,OAAO;AACL,kBAAQ,KAAK;AAAA,QACf;AAAA,MACF;AAEA,MAAC,OAAmC,GAAG,IACrC,QAAQ,WAAW,UAAU,MAAM,QAAQ,OAAO,IAAI,QAAQ,OAAO;AAAA,IACzE;AAEA,WAAO;AAAA,EACT;AACF;AAEO,SAAS,UAAU;AACxB,SAAO,IAAI,EAAE;AACf;","names":[]}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@xframework/x",
+  "version": "0.4.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
+    },
+    "./adapter": {
+      "types": "./dist/adapter.d.ts",
+      "require": "./dist/adapter.cjs",
+      "import": "./dist/adapter.js"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.24",
+    "tsd": "^0.31.2",
+    "tsup": "^8.2.4",
+    "typescript": "^5.5.4"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  }
+}

package/src/__tests__/async-adapter.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, it } from "vitest";
+import { createX } from "..";
+import { AsyncAdapter } from "../adapter";
+
+// async-adapter.test.ts
+describe("Async Adapter Tests", () => {
+  class TestAsyncAdapter extends AsyncAdapter<string> {
+    constructor(private value: string) {
+      super();
+    }
+    async export() {
+      return this.value;
+    }
+  }
+
+  class InitializableAsyncAdapter extends AsyncAdapter<string> {
+    private initialized = false;
+
+    async init() {
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      this.initialized = true;
+    }
+
+    async export() {
+      return this.initialized ? "initialized" : "not-initialized";
+    }
+  }
+
+  class ErrorAsyncAdapter extends AsyncAdapter<never> {
+    async init() {
+      throw new Error("Async init error");
+    }
+
+    async export(): Promise<never> {
+      throw new Error("Async export error");
+    }
+  }
+
+  it("should build async adapter chain", async () => {
+    const result = await createX()
+      .asyncAdapter("test1", () => new TestAsyncAdapter("hello"))
+      .asyncAdapter(
+        "test2",
+        async ({ test1 }) => new TestAsyncAdapter(test1 + " world"),
+      )
+      .build();
+
+    expect(result.test1).toBe("hello");
+    expect(result.test2).toBe("hello world");
+  });
+
+  it("should call init on async adapters", async () => {
+    const result = await createX()
+      .asyncAdapter("test", () => new InitializableAsyncAdapter())
+      .build();
+
+    expect(result.test).toBe("initialized");
+  });
+
+  it("should throw on init error in async adapter", async () => {
+    await expect(
+      createX()
+        .asyncAdapter("error", () => new ErrorAsyncAdapter())
+        .build(),
+    ).rejects.toThrow("Async init error");
+  });
+
+  it("should call init method on async adapter", async () => {
+    let initCalled = false;
+
+    class TestAsyncAdapter extends AsyncAdapter<string> {
+      async init() {
+        initCalled = true;
+      }
+
+      async export() {
+        return "test";
+      }
+    }
+
+    await createX()
+      .asyncAdapter("test", () => new TestAsyncAdapter())
+      .build();
+
+    expect(initCalled).toBe(true);
+  });
+});

package/src/__tests__/composition.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+import { createX } from "..";
+import { AsyncAdapter, SyncAdapter } from "../adapter";
+
+// composition.test.ts
+describe("Adapter Composition Tests", () => {
+  class NumberAdapter extends SyncAdapter<number> {
+    constructor(private value: number) {
+      super();
+    }
+    export() {
+      return this.value;
+    }
+  }
+
+  class StringAdapter extends AsyncAdapter<string> {
+    constructor(private deps: { number: number }) {
+      super();
+    }
+    async export() {
+      return `value: ${this.deps.number}`;
+    }
+  }
+
+  it("should compose sync adapters using use()", () => {
+    const first = createX().syncAdapter("num1", () => new NumberAdapter(1));
+    const second = createX().syncAdapter("num2", () => new NumberAdapter(2));
+
+    const result = createX().use(first).use(second).build();
+
+    expect(result.num1).toBe(1);
+    expect(result.num2).toBe(2);
+  });
+
+  it("should compose sync and async adapters", async () => {
+    const sync = createX().syncAdapter("number", () => new NumberAdapter(42));
+    const result = await createX()
+      .use(sync)
+      .asyncAdapter("string", ({ number }) => new StringAdapter({ number }))
+      .build();
+
+    expect(result.number).toBe(42);
+    expect(result.string).toBe("value: 42");
+  });
+});

package/src/__tests__/core.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+import { AdapterError } from "../core/adapters";
+import { createX } from "..";
+
+describe("Core Adapter Functionality", () => {
+  it("should create an empty X instance", () => {
+    const x = createX();
+    expect(x).toBeDefined();
+    expect(x.build()).toEqual({ _: { adapters: {} } });
+  });
+
+  it("should throw AdapterError with correct properties", () => {
+    const error = new AdapterError(
+      "test message",
+      "test-adapter",
+      new Error("cause"),
+    );
+    expect(error.message).toBe("test message");
+    expect(error.adapterName).toBe("test-adapter");
+    expect(error.cause).toBeInstanceOf(Error);
+    expect(error.name).toBe("AdapterError");
+  });
+});

package/src/__tests__/error-handling.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from "vitest";
+import { createX } from "..";
+import { AsyncAdapter, SyncAdapter } from "../adapter";
+
+// error-handling.test.ts
+describe("Error Handling Tests", () => {
+  it("should handle synchronous factory errors", () => {
+    expect(() =>
+      createX()
+        .syncAdapter("error", () => {
+          throw new Error("Factory error");
+        })
+        .build(),
+    ).toThrow("Factory error");
+  });
+
+  it("should handle asynchronous factory errors", async () => {
+    await expect(
+      createX()
+        .asyncAdapter("error", async () => {
+          throw new Error("Async factory error");
+        })
+        .build(),
+    ).rejects.toThrow("Async factory error");
+  });
+
+  it("should handle export errors in sync adapters", () => {
+    class ExportErrorAdapter extends SyncAdapter<never> {
+      // @ts-expect-error test
+      export() {
+        throw new Error("Export error");
+      }
+    }
+
+    expect(() =>
+      createX()
+        .syncAdapter("error", () => new ExportErrorAdapter())
+        .build(),
+    ).toThrow("Export error");
+  });
+
+  it("should handle export errors in async adapters", async () => {
+    class AsyncExportErrorAdapter extends AsyncAdapter<never> {
+      // @ts-expect-error test
+      export() {
+        throw new Error("Async export error");
+      }
+    }
+
+    await expect(
+      createX()
+        .asyncAdapter("error", () => new AsyncExportErrorAdapter())
+        .build(),
+    ).rejects.toThrow("Async export error");
+  });
+
+  it("should handle async adapter returned in sync context", () => {
+    class MismatchedAdapter extends AsyncAdapter<string> {
+      export() {
+        return "test";
+      }
+    }
+
+    expect(() =>
+      createX()
+        // @ts-expect-error test
+        .syncAdapter("error", () => new MismatchedAdapter())
+        .build(),
+    ).toThrow('Factory returned async adapter "error" in sync build');
+  });
+});

package/src/__tests__/sync-adapter.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it } from "vitest";
+import { createX } from "..";
+import { SyncAdapter } from "../adapter";
+// sync-adapter.test.ts
+describe("Sync Adapter Tests", () => {
+  class TestSyncAdapter extends SyncAdapter<number> {
+    constructor(private value: number) {
+      super();
+    }
+    export() {
+      return this.value;
+    }
+  }
+
+  class InitializableSyncAdapter extends SyncAdapter<number> {
+    private initialized = false;
+
+    init() {
+      this.initialized = true;
+    }
+
+    export() {
+      return this.initialized ? 1 : 0;
+    }
+  }
+
+  class ErrorSyncAdapter extends SyncAdapter<never> {
+    init() {
+      throw new Error("Init error");
+    }
+
+    // @ts-expect-error test
+    export() {
+      throw new Error("Export error");
+    }
+  }
+
+  it("should build sync adapter chain", () => {
+    const result = createX()
+      .syncAdapter("test1", () => new TestSyncAdapter(1))
+      .syncAdapter("test2", ({ test1 }) => new TestSyncAdapter(test1 + 1))
+      .build();
+
+    expect(result.test1).toBe(1);
+    expect(result.test2).toBe(2);
+  });
+
+  it("should call init on sync adapters", () => {
+    const result = createX()
+      .syncAdapter("test", () => new InitializableSyncAdapter())
+      .build();
+
+    expect(result.test).toBe(1);
+  });
+
+  it("should throw on init error in sync adapter", () => {
+    expect(() =>
+      createX()
+        .syncAdapter("error", () => new ErrorSyncAdapter())
+        .build(),
+    ).toThrow("Init error");
+  });
+
+  it("should call init method on sync adapter", () => {
+    let initCalled = false;
+
+    class TestSyncAdapter extends SyncAdapter<string> {
+      init() {
+        initCalled = true;
+      }
+
+      export() {
+        return "test";
+      }
+    }
+
+    createX()
+      .syncAdapter("test", () => new TestSyncAdapter())
+      .build();
+
+    expect(initCalled).toBe(true);
+  });
+});