@xframework/config 0.4.0

package/.turbo/turbo-build.log

@@ -0,0 +1,22 @@
+
+> @xframework/config@0.4.0 build /home/runner/work/x/x/packages/@xframework/config
+> tsup
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.3.5
+CLI Using tsup config: /home/runner/work/x/x/packages/@xframework/config/tsup.config.ts
+CLI Target: esnext
+CLI Cleaning output folder
+CJS Build start
+ESM Build start
+CJS dist/index.cjs     1.31 KB
+CJS dist/index.cjs.map 770.00 B
+CJS ⚡️ Build success in 27ms
+ESM dist/index.js     303.00 B
+ESM dist/index.js.map 730.00 B
+ESM ⚡️ Build success in 27ms
+DTS Build start
+DTS ⚡️ Build success in 4195ms
+DTS dist/index.d.cts 345.00 B
+DTS dist/index.d.ts  345.00 B

package/CHANGELOG.md

@@ -0,0 +1,12 @@
+# @xframework/config
+
+## 0.4.0
+
+### Minor Changes
+
+- 98dd8e4: redesign
+
+### Patch Changes
+
+- Updated dependencies [98dd8e4]
+  - @xframework/x@0.4.0

package/dist/index.cjs

@@ -0,0 +1,41 @@
+"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, {
+  ConfigAdapter: () => ConfigAdapter
+});
+module.exports = __toCommonJS(index_exports);
+var import_adapter = require("@xframework/x/adapter");
+var ConfigAdapter = class extends import_adapter.SyncAdapter {
+  config;
+  constructor({ config }) {
+    super();
+    this.config = config;
+  }
+  export() {
+    return this.config;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigAdapter
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { SyncAdapter } from \"@xframework/x/adapter\";\n\nexport class ConfigAdapter<\n  UserConfigInstance extends Record<string, unknown>,\n> extends SyncAdapter<UserConfigInstance> {\n  public config: UserConfigInstance;\n  constructor({ config }: { config: UserConfigInstance }) {\n    super();\n    this.config = config;\n  }\n\n  export() {\n    return this.config;\n  }\n}\n\n// In the future create a more advanced config adapter with storage (sync, and async)\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAA4B;AAErB,IAAM,gBAAN,cAEG,2BAAgC;AAAA,EACjC;AAAA,EACP,YAAY,EAAE,OAAO,GAAmC;AACtD,UAAM;AACN,SAAK,SAAS;AAAA,EAChB;AAAA,EAEA,SAAS;AACP,WAAO,KAAK;AAAA,EACd;AACF;","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,11 @@
+import { SyncAdapter } from '@xframework/x/adapter';
+
+declare class ConfigAdapter<UserConfigInstance extends Record<string, unknown>> extends SyncAdapter<UserConfigInstance> {
+    config: UserConfigInstance;
+    constructor({ config }: {
+        config: UserConfigInstance;
+    });
+    export(): UserConfigInstance;
+}
+
+export { ConfigAdapter };

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { SyncAdapter } from '@xframework/x/adapter';
+
+declare class ConfigAdapter<UserConfigInstance extends Record<string, unknown>> extends SyncAdapter<UserConfigInstance> {
+    config: UserConfigInstance;
+    constructor({ config }: {
+        config: UserConfigInstance;
+    });
+    export(): UserConfigInstance;
+}
+
+export { ConfigAdapter };

package/dist/index.js

@@ -0,0 +1,16 @@
+// src/index.ts
+import { SyncAdapter } from "@xframework/x/adapter";
+var ConfigAdapter = class extends SyncAdapter {
+  config;
+  constructor({ config }) {
+    super();
+    this.config = config;
+  }
+  export() {
+    return this.config;
+  }
+};
+export {
+  ConfigAdapter
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { SyncAdapter } from \"@xframework/x/adapter\";\n\nexport class ConfigAdapter<\n  UserConfigInstance extends Record<string, unknown>,\n> extends SyncAdapter<UserConfigInstance> {\n  public config: UserConfigInstance;\n  constructor({ config }: { config: UserConfigInstance }) {\n    super();\n    this.config = config;\n  }\n\n  export() {\n    return this.config;\n  }\n}\n\n// In the future create a more advanced config adapter with storage (sync, and async)\n"],"mappings":";AAAA,SAAS,mBAAmB;AAErB,IAAM,gBAAN,cAEG,YAAgC;AAAA,EACjC;AAAA,EACP,YAAY,EAAE,OAAO,GAAmC;AACtD,UAAM;AACN,SAAK,SAAS;AAAA,EAChB;AAAA,EAEA,SAAS;AACP,WAAO,KAAK;AAAA,EACd;AACF;","names":[]}

package/package.json

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

package/src/__tests__/index.test.ts

@@ -0,0 +1,147 @@
+import { expect, it, describe } from "vitest";
+import { createX } from "@xframework/x";
+import { ConfigAdapter } from "../index";
+
+describe("ConfigAdapter", () => {
+  // Test with a simple config object
+  const simpleConfig = {
+    apiKey: "test-api-key",
+    url: "https://api.example.com",
+    version: 1,
+  } as const;
+
+  it("should properly initialize and export config instance", () => {
+    const adapter = new ConfigAdapter({
+      config: simpleConfig,
+    });
+
+    expect(adapter.config).toBe(simpleConfig);
+    expect(adapter.export()).toBe(simpleConfig);
+  });
+
+  it("should integrate with X framework", () => {
+    const x = createX()
+      .syncAdapter(
+        "config",
+        () =>
+          new ConfigAdapter({
+            config: simpleConfig,
+          }),
+      )
+      .build();
+
+    expect(x._.adapters.config).toBeInstanceOf(ConfigAdapter);
+    expect(x.config).toBe(simpleConfig);
+    expect(x.config.apiKey).toBe("test-api-key");
+    expect(x.config.url).toBe("https://api.example.com");
+    expect(x.config.version).toBe(1);
+  });
+
+  // Test with a nested config object
+  const nestedConfig = {
+    api: {
+      key: "test-api-key",
+      endpoints: {
+        users: "/api/users",
+        posts: "/api/posts",
+      },
+      version: 2,
+    },
+    database: {
+      host: "localhost",
+      port: 5432,
+      credentials: {
+        username: "admin",
+        password: "secret",
+      },
+    },
+    features: {
+      darkMode: true,
+      beta: {
+        enabled: false,
+        whitelist: ["user1", "user2"],
+      },
+    },
+  } as const;
+
+  it("should handle nested config objects", () => {
+    const adapter = new ConfigAdapter({
+      config: nestedConfig,
+    });
+
+    expect(adapter.config).toBe(nestedConfig);
+    expect(adapter.export()).toBe(nestedConfig);
+  });
+
+  it("should provide type-safe access to nested config through X framework", () => {
+    const x = createX()
+      .syncAdapter(
+        "config",
+        () =>
+          new ConfigAdapter({
+            config: nestedConfig,
+          }),
+      )
+      .build();
+
+    expect(x.config.api.key).toBe("test-api-key");
+    expect(x.config.api.endpoints.users).toBe("/api/users");
+    expect(x.config.database.credentials.username).toBe("admin");
+    expect(x.config.features.beta.whitelist).toEqual(["user1", "user2"]);
+  });
+
+  // Test with different config types
+  it("should handle configs with various types", () => {
+    const mixedConfig = {
+      string: "test",
+      number: 42,
+      boolean: true,
+      array: [1, 2, 3],
+      date: new Date("2024-01-01"),
+      nullable: null as null | string,
+      optional: undefined as undefined | number,
+      tuple: ["id", 123] as const,
+      union: "value" as "value" | "other",
+    };
+
+    const x = createX()
+      .syncAdapter(
+        "config",
+        () =>
+          new ConfigAdapter({
+            config: mixedConfig,
+          }),
+      )
+      .build();
+
+    expect(x.config.string).toBe("test");
+    expect(x.config.number).toBe(42);
+    expect(x.config.boolean).toBe(true);
+    expect(x.config.array).toEqual([1, 2, 3]);
+    expect(x.config.date).toBeInstanceOf(Date);
+    expect(x.config.nullable).toBeNull();
+    expect(x.config.optional).toBeUndefined();
+    expect(x.config.tuple).toEqual(["id", 123]);
+    expect(x.config.union).toBe("value");
+  });
+
+  // Test compile-time type constraints
+  it("should have proper TypeScript type constraints", () => {
+    // These would fail at compile time, but work at runtime
+    // @ts-expect-error Config must be a record of string keys
+    const nullConfig = new ConfigAdapter({ config: null });
+    expect(nullConfig.config).toBe(null);
+
+    // @ts-expect-error Config must be a record of string keys
+    const undefinedConfig = new ConfigAdapter({ config: undefined });
+    expect(undefinedConfig.config).toBe(undefined);
+
+    // @ts-expect-error Config must be a record of string keys
+    const numberConfig = new ConfigAdapter({ config: 42 });
+    expect(numberConfig.config).toBe(42);
+
+    // @ts-expect-error Config must be a record of string keys
+    const stringConfig = new ConfigAdapter({ config: "not an object" });
+    expect(stringConfig.config).toBe("not an object");
+  });
+});

package/src/index.ts

@@ -0,0 +1,17 @@
+import { SyncAdapter } from "@xframework/x/adapter";
+
+export class ConfigAdapter<
+  UserConfigInstance extends Record<string, unknown>,
+> extends SyncAdapter<UserConfigInstance> {
+  public config: UserConfigInstance;
+  constructor({ config }: { config: UserConfigInstance }) {
+    super();
+    this.config = config;
+  }
+
+  export() {
+    return this.config;
+  }
+}
+
+// In the future create a more advanced config adapter with storage (sync, and async)

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;