@xframework/x 0.4.0

package/src/__tests__/type-system.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it } from "vitest";
+import { createX } from "..";
+import { SyncAdapter } from "../adapter";
+
+interface Config {
+  key: string;
+  value: number;
+}
+
+class ConfigAdapter extends SyncAdapter<Config> {
+  export(): Config {
+    return { key: "test", value: 42 };
+  }
+}
+
+class NumberAdapter extends SyncAdapter<number> {
+  constructor(private value: number) {
+    super();
+  }
+  export() {
+    return this.value;
+  }
+}
+
+class StringAdapter extends SyncAdapter<string> {
+  constructor(private deps: { number: number }) {
+    super();
+  }
+  export() {
+    return `value: ${this.deps.number}`;
+  }
+}
+
+// type-system.test.ts
+describe("Type System Tests", () => {
+  it("should properly type exports", () => {
+    const result = createX()
+      .syncAdapter("config", () => new ConfigAdapter())
+      .build();
+
+    // TypeScript should recognize these properties
+    expect(result.config.key).toBe("test");
+    expect(result.config.value).toBe(42);
+  });
+
+  it("should properly type dependencies", () => {
+    class DependentAdapter extends SyncAdapter<string> {
+      constructor(private deps: { config: { value: number } }) {
+        super();
+      }
+      export() {
+        return `value: ${this.deps.config.value}`;
+      }
+    }
+
+    const result = createX()
+      .syncAdapter("config", () => new ConfigAdapter())
+      .syncAdapter("dependent", (deps) => new DependentAdapter(deps))
+      .build();
+
+    expect(result.dependent).toBe("value: 42");
+  });
+
+  it("should maintain type safety with use()", () => {
+    const first = createX().syncAdapter("num", () => new NumberAdapter(1));
+    const second = createX()
+      .use(first)
+      .syncAdapter("str", ({ num }) => new StringAdapter({ number: num }));
+
+    // TypeScript should recognize these types
+    type SecondType = typeof second;
+    type BuildType = Awaited<ReturnType<SecondType["build"]>>;
+
+    const result = second.build() as BuildType;
+    expect(result.num).toBeDefined();
+    expect(result.str).toBeDefined();
+  });
+});

package/src/adapter.ts

@@ -0,0 +1 @@
+export { AsyncAdapter, SyncAdapter, AdapterError } from "./core/adapters";

package/src/core/adapters.ts

@@ -0,0 +1,26 @@
+import type { SyncAdapterType, AsyncAdapterType } from "./types";
+
+export abstract class SyncAdapter<TExport> implements SyncAdapterType<TExport> {
+  readonly __type = "sync" as const;
+  init?(): void;
+  abstract export(): TExport;
+}
+
+export abstract class AsyncAdapter<TExport>
+  implements AsyncAdapterType<TExport>
+{
+  readonly __type = "async" as const;
+  init?(): Promise<void>;
+  abstract export(): Promise<TExport>;
+}
+
+export class AdapterError extends Error {
+  constructor(
+    message: string,
+    public readonly adapterName: string,
+    public readonly cause?: unknown,
+  ) {
+    super(message);
+    this.name = "AdapterError";
+  }
+}

package/src/core/types.ts

@@ -0,0 +1,47 @@
+// Core adapter type definitions
+export type SyncAdapterType<TExport = unknown> = {
+  __type: "sync";
+  init?(): void;
+  export(): TExport;
+};
+
+export type AsyncAdapterType<TExport = unknown> = {
+  __type: "async";
+  init?(): Promise<void>;
+  export(): Promise<TExport>;
+};
+
+export type AnyAdapter = SyncAdapterType | AsyncAdapterType;
+export type AdapterRegistry = Record<string, AnyAdapter>;
+
+// Helper type to extract the exported type from an adapter
+export type ExportType<TAdapter> = TAdapter extends
+  | SyncAdapterType<infer TExport>
+  | AsyncAdapterType<infer TExport>
+  ? TExport
+  : never;
+
+// Result type with metadata container
+export type AdapterResult<TAdapters extends AdapterRegistry> = {
+  [Key in keyof TAdapters]: ExportType<TAdapters[Key]>;
+} & {
+  _: {
+    adapters: TAdapters;
+  };
+};
+
+export type BuildOutput<
+  TAdapters extends AdapterRegistry,
+  TIsAsync extends boolean,
+> = TIsAsync extends true
+  ? Promise<AdapterResult<TAdapters>>
+  : AdapterResult<TAdapters>;
+
+// Factory types
+export type SyncAdapterCreator<TExport, TDeps extends AdapterRegistry> = (
+  dependencies: AdapterResult<TDeps>,
+) => SyncAdapterType<TExport>;
+
+export type AsyncAdapterCreator<TExport, TDeps extends AdapterRegistry> = (
+  dependencies: AdapterResult<TDeps>,
+) => Promise<AsyncAdapterType<TExport>> | AsyncAdapterType<TExport>;

package/src/core/x.ts

@@ -0,0 +1,163 @@
+import { AdapterError } from "./adapters";
+import type {
+  SyncAdapterCreator,
+  SyncAdapterType,
+  AsyncAdapterCreator,
+  AsyncAdapterType,
+  AdapterRegistry,
+  AdapterResult,
+  BuildOutput,
+} from "./types";
+
+type AdapterFactory<T extends AdapterRegistry> =
+  | [(deps: AdapterResult<T>) => SyncAdapterType<unknown>, false]
+  | [(deps: AdapterResult<T>) => Promise<AsyncAdapterType<unknown>>, true];
+
+class X<
+  TAdapters extends AdapterRegistry = Record<string, never>,
+  TIsAsync extends boolean = false,
+> {
+  constructor(
+    private readonly adapterFactories: Record<
+      string,
+      AdapterFactory<TAdapters>
+    > = {} as Record<string, AdapterFactory<TAdapters>>,
+    private readonly isAsync: TIsAsync = false as TIsAsync,
+  ) {}
+
+  syncAdapter<TKey extends string, TExport>(
+    name: TKey,
+    factory: SyncAdapterCreator<TExport, TAdapters>,
+  ): X<TAdapters & Record<TKey, SyncAdapterType<TExport>>, TIsAsync> {
+    type NewAdapters = TAdapters & Record<TKey, SyncAdapterType<TExport>>;
+    const newFactories = { ...this.adapterFactories };
+    // We know this is safe because factory is a SyncAdapterCreator
+    (newFactories as Record<string, unknown>)[name] = [
+      factory,
+      false,
+    ] as AdapterFactory<NewAdapters>;
+    return new X(
+      newFactories as Record<string, AdapterFactory<NewAdapters>>,
+      this.isAsync,
+    );
+  }
+
+  asyncAdapter<TKey extends string, TExport>(
+    name: TKey,
+    factory: AsyncAdapterCreator<TExport, TAdapters>,
+  ): X<TAdapters & Record<TKey, AsyncAdapterType<TExport>>, true> {
+    type NewAdapters = TAdapters & Record<TKey, AsyncAdapterType<TExport>>;
+    const wrappedFactory = async (deps: AdapterResult<TAdapters>) => {
+      const result = factory(deps);
+      return result instanceof Promise ? await result : result;
+    };
+
+    const newFactories = { ...this.adapterFactories };
+    // We know this is safe because wrappedFactory returns a Promise<AsyncAdapterType>
+    (newFactories as Record<string, unknown>)[name] = [
+      wrappedFactory,
+      true,
+    ] as AdapterFactory<NewAdapters>;
+    return new X(
+      newFactories as Record<string, AdapterFactory<NewAdapters>>,
+      true,
+    );
+  }
+
+  use<TOtherAdapters extends AdapterRegistry, TOtherAsync extends boolean>(
+    other: X<TOtherAdapters, TOtherAsync>,
+  ): X<TAdapters & TOtherAdapters, TIsAsync | TOtherAsync> {
+    type CombinedAdapters = TAdapters & TOtherAdapters;
+    const newFactories = {
+      ...this.adapterFactories,
+      ...other["adapterFactories"],
+    } as Record<string, AdapterFactory<CombinedAdapters>>;
+    return new X(newFactories, this.isAsync || other["isAsync"]);
+  }
+
+  build(): BuildOutput<TAdapters, TIsAsync> {
+    return this.isAsync
+      ? (this.buildAsync() as BuildOutput<TAdapters, TIsAsync>)
+      : (this.buildSync() as BuildOutput<TAdapters, TIsAsync>);
+  }
+
+  private buildSync(): AdapterResult<TAdapters> {
+    const result = {
+      _: { adapters: {} as TAdapters },
+    } as AdapterResult<TAdapters>;
+
+    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) as SyncAdapterType<unknown>;
+
+      if (adapter.__type !== "sync") {
+        throw new AdapterError(
+          `Factory returned async adapter "${key}" in sync build`,
+          key,
+        );
+      }
+
+      (result._.adapters as Record<string, SyncAdapterType<unknown>>)[key] =
+        adapter;
+      adapter.init?.();
+      (result as Record<string, unknown>)[key] = adapter.export();
+    }
+
+    return result;
+  }
+
+  private async buildAsync(): Promise<AdapterResult<TAdapters>> {
+    const result = {
+      _: { adapters: {} as TAdapters },
+    } as AdapterResult<TAdapters>;
+
+    for (const [key, [factory, isAsync]] of Object.entries(
+      this.adapterFactories,
+    )) {
+      const currentResult = { ...result };
+      const adapter = isAsync
+        ? await (
+            factory as (
+              deps: AdapterResult<TAdapters>,
+            ) => Promise<AsyncAdapterType<unknown>>
+          )(currentResult)
+        : (
+            factory as (
+              deps: AdapterResult<TAdapters>,
+            ) => SyncAdapterType<unknown>
+          )(currentResult);
+
+      (
+        result._.adapters as Record<
+          string,
+          SyncAdapterType<unknown> | AsyncAdapterType<unknown>
+        >
+      )[key] = adapter;
+
+      if (adapter.init) {
+        if (adapter.__type === "async") {
+          await adapter.init();
+        } else {
+          adapter.init();
+        }
+      }
+
+      (result as Record<string, unknown>)[key] =
+        adapter.__type === "async" ? await adapter.export() : adapter.export();
+    }
+
+    return result;
+  }
+}
+
+export function createX() {
+  return new X();
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { createX } from "./core/x";

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "lib": ["ESNext", "DOM"]
+  },
+  "include": ["src", "tsup.config.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsup.config.ts

@@ -0,0 +1,3 @@
+import { tsupConfig } from "../../../utils/tsup.config";
+
+export default tsupConfig;