@obsidiane/auth-client-js 1.0.1

package/src/lib/interceptors/bridge-debug.interceptor.ts

@@ -0,0 +1,32 @@
+import {HttpInterceptorFn, HttpResponse} from '@angular/common/http';
+import {inject} from '@angular/core';
+import {BRIDGE_LOGGER} from '../tokens';
+import {catchError, finalize, tap, throwError} from 'rxjs';
+
+/**
+ * Lightweight request/response logging controlled by `provideBridge({debug: true})`.
+ * Logs are delegated to the injected `BRIDGE_LOGGER`.
+ */
+export const bridgeDebugInterceptor: HttpInterceptorFn = (req, next) => {
+  const logger = inject(BRIDGE_LOGGER, {optional: true});
+  if (!logger) return next(req);
+
+  const startedAt = Date.now();
+  logger.debug('[Bridge] request', {method: req.method, url: req.urlWithParams});
+
+  return next(req).pipe(
+    tap((evt) => {
+      if (evt instanceof HttpResponse) {
+        logger.debug('[Bridge] response', {method: req.method, url: req.urlWithParams, status: evt.status});
+      }
+    }),
+    catchError((err) => {
+      logger.error('[Bridge] error', {method: req.method, url: req.urlWithParams, err});
+      return throwError(() => err);
+    }),
+    finalize(() => {
+      const durationMs = Date.now() - startedAt;
+      logger.debug('[Bridge] done', {method: req.method, url: req.urlWithParams, durationMs});
+    })
+  );
+};

package/src/lib/interceptors/bridge-defaults.interceptor.ts

@@ -0,0 +1,53 @@
+import {HttpInterceptorFn} from '@angular/common/http';
+import {inject} from '@angular/core';
+import {BRIDGE_DEFAULTS, BRIDGE_LOGGER} from '../tokens';
+import {retry, timeout, timer} from 'rxjs';
+
+const DEFAULT_RETRY_METHODS = ['GET', 'HEAD', 'OPTIONS'];
+
+/**
+ * Applies default headers, timeout and retry policy configured via `provideBridge({defaults: ...})`.
+ */
+export const bridgeDefaultsInterceptor: HttpInterceptorFn = (req, next) => {
+  const defaults = inject(BRIDGE_DEFAULTS, {optional: true}) ?? {};
+  const logger = inject(BRIDGE_LOGGER, {optional: true});
+
+  let nextReq = req;
+
+  if (defaults.headers) {
+    for (const [k, v] of Object.entries(defaults.headers)) {
+      if (!nextReq.headers.has(k)) {
+        nextReq = nextReq.clone({headers: nextReq.headers.set(k, v)});
+      }
+    }
+  }
+
+  let out$ = next(nextReq);
+
+  const timeoutMs = typeof defaults.timeoutMs === 'number' ? defaults.timeoutMs : undefined;
+  if (timeoutMs && timeoutMs > 0) {
+    out$ = out$.pipe(timeout({first: timeoutMs}));
+  }
+
+  const retryCfg = defaults.retries;
+  const retryCount = typeof retryCfg === 'number' ? retryCfg : retryCfg?.count;
+  if (retryCount && retryCount > 0) {
+    const methods = (typeof retryCfg === 'object' && retryCfg.methods) ? retryCfg.methods : DEFAULT_RETRY_METHODS;
+    const normalizedMethod = req.method.toUpperCase();
+    const methodAllowList = new Set(methods.map((m) => m.toUpperCase()));
+    if (methodAllowList.has(normalizedMethod)) {
+      const delayMs = typeof retryCfg === 'object' ? (retryCfg.delayMs ?? 250) : 250;
+      out$ = out$.pipe(
+        retry({
+          count: retryCount,
+          delay: (_err, retryIndex) => {
+            logger?.debug?.('[Bridge] retry', {url: req.urlWithParams, method: req.method, retryIndex});
+            return timer(delayMs);
+          },
+        })
+      );
+    }
+  }
+
+  return out$;
+};

package/src/lib/interceptors/content-type.interceptor.ts

@@ -0,0 +1,49 @@
+import {HttpInterceptorFn} from '@angular/common/http';
+
+export interface ApiMediaTypes {
+  accept: string;
+  post: string;
+  put: string;
+  patch: string;
+}
+
+export const DEFAULT_MEDIA_TYPES: ApiMediaTypes = {
+  accept: 'application/ld+json',
+  post: 'application/ld+json',
+  put: 'application/ld+json',
+  patch: 'application/merge-patch+json',
+};
+
+export const contentTypeInterceptor: HttpInterceptorFn = (req, next) => {
+  const mediaTypes = DEFAULT_MEDIA_TYPES;
+  let headers = req.headers;
+
+  // Set Accept if missing.
+  if (!headers.has('Accept')) {
+    headers = headers.set('Accept', mediaTypes.accept);
+  }
+
+  // Only methods with a body.
+  const isBodyMethod = ['POST', 'PUT', 'PATCH'].includes(req.method);
+  // Ignore FormData (browser sets multipart boundary).
+  const isFormData = typeof FormData !== 'undefined' && req.body instanceof FormData;
+
+  if (isBodyMethod && !isFormData && !headers.has('Content-Type')) {
+    let contentType: string;
+
+    switch (req.method) {
+      case 'PATCH':
+        contentType = mediaTypes.patch;
+        break;
+      case 'PUT':
+        contentType = mediaTypes.put;
+        break;
+      default:
+        contentType = mediaTypes.post;
+    }
+
+    headers = headers.set('Content-Type', contentType);
+  }
+
+  return next(req.clone({headers}));
+};

package/src/lib/interceptors/singleflight.interceptor.ts

@@ -0,0 +1,55 @@
+import {HttpEvent, HttpInterceptorFn, HttpRequest} from '@angular/common/http';
+import {finalize, Observable, shareReplay} from 'rxjs';
+
+export type SingleFlightMode = 'off' | 'safe';
+
+const DEFAULT_MODE: SingleFlightMode = 'safe';
+const SAFE_METHODS = new Set(['GET', 'HEAD', 'OPTIONS']);
+
+export function createSingleFlightInterceptor(mode: SingleFlightMode = DEFAULT_MODE): HttpInterceptorFn {
+  const inflight = new Map<string, Observable<HttpEvent<unknown>>>();
+
+  return (req, next) => {
+    if (mode === 'off') {
+      return next(req);
+    }
+
+    const method = req.method.toUpperCase();
+    if (!SAFE_METHODS.has(method)) {
+      return next(req);
+    }
+    if (req.reportProgress === true) {
+      return next(req);
+    }
+
+    const key = computeKey(req);
+    const existing = inflight.get(key);
+    if (existing) {
+      return existing;
+    }
+
+    const shared$ = next(req).pipe(
+      finalize(() => inflight.delete(key)),
+      shareReplay({bufferSize: 1, refCount: true})
+    );
+
+    inflight.set(key, shared$);
+    return shared$;
+  };
+}
+
+function computeKey(req: HttpRequest<unknown>): string {
+  const auth = req.headers.get('Authorization') ?? '';
+  const accept = req.headers.get('Accept') ?? '';
+  const contentType = req.headers.get('Content-Type') ?? '';
+  const creds = req.withCredentials ? '1' : '0';
+  return [
+    req.method.toUpperCase(),
+    req.urlWithParams,
+    `rt=${req.responseType}`,
+    `wc=${creds}`,
+    `a=${auth}`,
+    `acc=${accept}`,
+    `ct=${contentType}`,
+  ].join('::');
+}

package/src/lib/ports/realtime.port.ts

@@ -0,0 +1,36 @@
+import {Observable} from 'rxjs';
+import {Iri} from './resource-repository.port';
+
+export type RealtimeStatus = 'connecting' | 'connected' | 'closed';
+
+export interface SseEvent {
+  type: string;
+  data: string;
+  lastEventId?: string;
+}
+
+export interface SseOptions {
+  withCredentials?: boolean;
+}
+
+export interface RealtimeEvent<T> {
+  iri: string;
+  data?: T;
+}
+
+export type SubscribeFilter = {
+  field: string;
+};
+
+export interface RealtimePort {
+  /**
+   * Subscribes to Mercure events for the given topics.
+   *
+   * Note: topics must be stable strings. Undefined values are ignored by the adapter.
+   */
+  subscribe$<T>(iris: Iri[], filter?: SubscribeFilter): Observable<RealtimeEvent<T>>;
+
+  unsubscribe(iris: Iri[]): void;
+
+  status$(): Observable<RealtimeStatus>;
+}

package/src/lib/ports/resource-repository.port.ts

@@ -0,0 +1,78 @@
+import {HttpHeaders, HttpParams} from '@angular/common/http';
+import {Observable} from 'rxjs';
+
+export type Iri = string | undefined;
+export type IriRequired = string;
+
+type BaseHttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD';
+export type HttpMethod = BaseHttpMethod | Lowercase<BaseHttpMethod>;
+
+export type QueryParamValue = string | number | boolean | Array<string | number | boolean>;
+export type AnyQuery = Query | Record<string, QueryParamValue> | HttpParams;
+
+export interface Item {
+  '@id'?: Iri;
+  '@context'?: string;
+  '@type'?: string;
+}
+
+export interface View extends Item {
+  first?: Iri;
+  last?: Iri;
+  next?: Iri;
+  previous?: Iri;
+}
+export interface IriTemplateMapping extends Item {
+  variable: string;
+  property?: string;
+  required?: boolean;
+}
+export interface IriTemplate extends Item {
+  template: string;
+  variableRepresentation?: string;
+  mapping: IriTemplateMapping[];
+}
+export interface Collection<T> extends Item {
+  member: T[];
+  totalItems?: number;
+  search?: IriTemplate;
+  view?: View;
+}
+
+export interface Query {
+  itemsPerPage?: number;
+  page?: number;
+  filters?: Record<string, QueryParamValue>;
+}
+
+export interface HttpCallOptions {
+  headers?: HttpHeaders | Record<string, string>;
+  withCredentials?: boolean;
+}
+
+export interface ResourceRepository<T> {
+  getCollection$(query?: AnyQuery, opts?: HttpCallOptions): Observable<Collection<T>>;
+
+  get$(iri: IriRequired, opts?: HttpCallOptions): Observable<T>;
+
+  post$(payload: Partial<T>, opts?: HttpCallOptions): Observable<T>;
+
+  patch$(iri: IriRequired, changes: Partial<T>, opts?: HttpCallOptions): Observable<T>;
+
+  put$(iri: IriRequired, payload: Partial<T>, opts?: HttpCallOptions): Observable<T>;
+
+  delete$(iri: IriRequired, opts?: HttpCallOptions): Observable<void>;
+
+  request$<R = unknown, B = unknown>(req: HttpRequestConfig<B>): Observable<R>;
+}
+
+export interface HttpRequestConfig<TBody = unknown> {
+  method: HttpMethod;
+  url?: Iri;
+  query?: AnyQuery;
+  body?: TBody;
+  headers?: HttpHeaders | Record<string, string>;
+  responseType?: 'json' | 'text' | 'blob';
+  withCredentials?: boolean;
+  options?: Record<string, unknown>;
+}

package/src/lib/provide-bridge.ts

@@ -0,0 +1,148 @@
+import {EnvironmentProviders, makeEnvironmentProviders} from '@angular/core';
+import {HttpInterceptorFn, provideHttpClient, withFetch, withInterceptors} from '@angular/common/http';
+import {
+  API_BASE_URL,
+  BRIDGE_DEFAULTS,
+  BRIDGE_LOGGER,
+  BRIDGE_WITH_CREDENTIALS,
+  MERCURE_HUB_URL,
+  MERCURE_TOPIC_MODE,
+} from './tokens';
+import {BridgeDefaults, BridgeLogger, MercureTopicMode} from './bridge.types';
+import {contentTypeInterceptor} from './interceptors/content-type.interceptor';
+import {bridgeDefaultsInterceptor} from './interceptors/bridge-defaults.interceptor';
+import {bridgeDebugInterceptor} from './interceptors/bridge-debug.interceptor';
+import {from, switchMap} from 'rxjs';
+import {createSingleFlightInterceptor} from './interceptors/singleflight.interceptor';
+
+export type BridgeAuth =
+  | string
+  | {type: 'bearer'; token: string}
+  | {type: 'bearer'; getToken: () => string | undefined | Promise<string | undefined>}
+  | HttpInterceptorFn;
+
+export interface BridgeMercureOptions {
+  hubUrl?: string;
+  init?: RequestInit;
+  topicMode?: MercureTopicMode;
+}
+
+export interface BridgeOptions {
+  /** Base URL of the API (e.g. `http://localhost:8000`). */
+  baseUrl: string;
+  /** Auth strategy used to attach an Authorization header. */
+  auth?: BridgeAuth;
+  /**
+   * Use `topicMode` to control the `topic=` values sent to the hub.
+   */
+  mercure?: BridgeMercureOptions;
+  /** Default HTTP behaviour (headers, timeout, retries). */
+  defaults?: BridgeDefaults;
+  /**
+   * De-duplicates in-flight HTTP requests.
+   *
+   * - `true` (default): single-flight for safe methods (`GET/HEAD/OPTIONS`)
+   * - `false`: disabled (each call triggers a new request)
+   */
+  singleFlight?: boolean;
+  /** Enables debug logging via the debug interceptor and console logger. */
+  debug?: boolean;
+  /** Extra `HttpInterceptorFn` applied after bridge interceptors. */
+  extraInterceptors?: HttpInterceptorFn[];
+}
+
+/** Registers the bridge HTTP client, interceptors, Mercure realtime adapter and configuration tokens. */
+export function provideBridge(opts: BridgeOptions): EnvironmentProviders {
+  const {
+    baseUrl,
+    auth,
+    mercure,
+    defaults,
+    singleFlight = true,
+    debug = false,
+    extraInterceptors = [],
+  } = opts;
+
+  if (!baseUrl) {
+    throw new Error("provideBridge(): missing 'baseUrl'");
+  }
+
+  const resolvedMercureInit: RequestInit = mercure?.init ?? {credentials: 'include' as RequestCredentials};
+  const resolvedMercureHubUrl = mercure?.hubUrl;
+  const resolvedMercureTopicMode: MercureTopicMode = mercure?.topicMode ?? 'url';
+  const withCredentials = resolveWithCredentials(resolvedMercureInit);
+
+  const loggerProvider: BridgeLogger = createBridgeLogger(debug);
+
+  const interceptors: HttpInterceptorFn[] = [
+    contentTypeInterceptor,
+    bridgeDefaultsInterceptor,
+    ...createAuthInterceptors(auth),
+    ...(singleFlight ? [createSingleFlightInterceptor('safe')] : [createSingleFlightInterceptor('off')]),
+    ...(debug ? [bridgeDebugInterceptor] : []),
+    ...extraInterceptors,
+  ];
+
+  return makeEnvironmentProviders([
+    provideHttpClient(
+      withFetch(),
+      withInterceptors(interceptors)
+    ),
+    {provide: API_BASE_URL, useValue: baseUrl},
+    {provide: BRIDGE_WITH_CREDENTIALS, useValue: withCredentials},
+    ...(resolvedMercureHubUrl ? [{provide: MERCURE_HUB_URL, useValue: resolvedMercureHubUrl}] : []),
+    {provide: MERCURE_TOPIC_MODE, useValue: resolvedMercureTopicMode},
+    {provide: BRIDGE_DEFAULTS, useValue: defaults ?? {}},
+    {provide: BRIDGE_LOGGER, useValue: loggerProvider},
+  ]);
+}
+
+function createBridgeLogger(debug: boolean): BridgeLogger {
+  const noop = () => undefined;
+  return {
+    debug: debug ? console.debug.bind(console) : noop,
+    info: debug ? console.info.bind(console) : noop,
+    warn: debug ? console.warn.bind(console) : noop,
+    error: console.error.bind(console),
+  };
+}
+
+function resolveWithCredentials(init: RequestInit | undefined): boolean {
+  if (!init) return false;
+  const anyInit = init as RequestInit & {withCredentials?: boolean};
+  return anyInit.withCredentials === true || init.credentials === 'include';
+}
+
+function createAuthInterceptors(auth?: BridgeAuth): HttpInterceptorFn[] {
+  if (!auth) return [];
+
+  if (typeof auth === 'function') {
+    return [auth as HttpInterceptorFn];
+  }
+
+  const bearer =
+    typeof auth === 'string'
+      ? {type: 'bearer' as const, token: auth}
+      : (auth as Exclude<BridgeAuth, string | HttpInterceptorFn>);
+
+  if (bearer.type !== 'bearer') return [];
+
+  if ('token' in bearer) {
+    const token = bearer.token;
+    return [createBearerAuthInterceptor(() => token)];
+  }
+
+  return [createBearerAuthInterceptor(bearer.getToken)];
+}
+
+function createBearerAuthInterceptor(getToken: () => string | undefined | Promise<string | undefined>): HttpInterceptorFn {
+  return (req, next) => {
+    if (req.headers.has('Authorization')) return next(req);
+    return from(Promise.resolve(getToken())).pipe(
+      switchMap((token) => {
+        if (!token) return next(req);
+        return next(req.clone({headers: req.headers.set('Authorization', `Bearer ${token}`)}));
+      })
+    );
+  };
+}

package/src/lib/tokens.ts

@@ -0,0 +1,20 @@
+import {InjectionToken} from '@angular/core';
+import {BridgeDefaults, BridgeLogger, MercureTopicMode} from './bridge.types';
+
+/** Base URL of the API (e.g. `http://localhost:8000`). */
+export const API_BASE_URL = new InjectionToken<string>('API_BASE_URL');
+
+/** Mercure hub URL (e.g. `http://localhost:8000/.well-known/mercure`). */
+export const MERCURE_HUB_URL = new InjectionToken<string>('MERCURE_HUB_URL');
+
+/**
+ * Default credential policy for HTTP requests and Mercure EventSource.
+ * When `true`, the bridge sets `withCredentials: true` on HTTP calls and uses cookies for SSE.
+ */
+export const BRIDGE_WITH_CREDENTIALS = new InjectionToken<boolean>('BRIDGE_WITH_CREDENTIALS');
+
+export const MERCURE_TOPIC_MODE = new InjectionToken<MercureTopicMode>('MERCURE_TOPIC_MODE');
+
+export const BRIDGE_LOGGER = new InjectionToken<BridgeLogger>('BRIDGE_LOGGER');
+
+export const BRIDGE_DEFAULTS = new InjectionToken<BridgeDefaults>('BRIDGE_DEFAULTS');

package/src/lib/utils/url.ts

@@ -0,0 +1,15 @@
+export function joinUrl(base: string, path: string): string {
+  const normalizedBase = base.endsWith('/') ? base.slice(0, -1) : base;
+  const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+  return `${normalizedBase}${normalizedPath}`;
+}
+
+/**
+ * Resolves an API IRI (e.g. `/api/books/1`) to a full URL using the API base.
+ * If `path` is already absolute (http/https), it is returned as-is.
+ */
+export function resolveUrl(base: string, path: string): string {
+  if (/^https?:\/\//i.test(path)) return path;
+  if (path.startsWith('//')) return path;
+  return joinUrl(base, path);
+}

package/src/models/Auth.ts

@@ -0,0 +1,5 @@
+import type { Item } from '../lib/ports/resource-repository.port';
+
+export interface Auth extends Item {
+  tokenId?: string | null;
+}

package/src/models/AuthInviteCompleteInputInviteComplete.ts

@@ -0,0 +1,7 @@
+import type { Item } from '../lib/ports/resource-repository.port';
+
+export interface AuthInviteCompleteInputInviteComplete extends Item {
+  token: string;
+  password: string;
+  confirmPassword: string;
+}

package/src/models/AuthInviteUserInputInviteSend.ts

@@ -0,0 +1,5 @@
+import type { Item } from '../lib/ports/resource-repository.port';
+
+export interface AuthInviteUserInputInviteSend extends Item {
+  email: string | null;
+}

package/src/models/AuthLdJson.ts

@@ -0,0 +1,5 @@
+import type { Item } from '../lib/ports/resource-repository.port';
+
+export interface AuthLdJson extends Item {
+  tokenId?: string | null;
+}

package/src/models/AuthPasswordForgotInputPasswordForgot.ts

@@ -0,0 +1,5 @@
+import type { Item } from '../lib/ports/resource-repository.port';
+
+export interface AuthPasswordForgotInputPasswordForgot extends Item {
+  email: string | null;
+}

package/src/models/AuthPasswordResetInputPasswordReset.ts

@@ -0,0 +1,6 @@
+import type { Item } from '../lib/ports/resource-repository.port';
+
+export interface AuthPasswordResetInputPasswordReset extends Item {
+  token: string;
+  password: string;
+}

package/src/models/AuthRegisterUserInputUserRegister.ts

@@ -0,0 +1,6 @@
+import type { Item } from '../lib/ports/resource-repository.port';
+
+export interface AuthRegisterUserInputUserRegister extends Item {
+  email: string | null;
+  password: string | null;
+}

package/src/models/FrontendConfig.ts

@@ -0,0 +1,12 @@
+import type { Item } from '../lib/ports/resource-repository.port';
+
+export interface FrontendConfig extends Item {
+  id?: string | null;
+  registrationEnabled?: boolean;
+  passwordStrengthLevel?: number;
+  brandingName?: string;
+  frontendRedirectUrl?: string;
+  environment?: string;
+  themeMode?: string;
+  themeColor?: string;
+}

package/src/models/InvitePreview.ts

@@ -0,0 +1,8 @@
+import type { Item } from '../lib/ports/resource-repository.port';
+
+export interface InvitePreview extends Item {
+  token?: string | null;
+  email?: string | null;
+  accepted?: boolean;
+  expired?: boolean;
+}

package/src/models/InviteUserInviteRead.ts

@@ -0,0 +1,9 @@
+import type { Item } from '../lib/ports/resource-repository.port';
+
+export interface InviteUserInviteRead extends Item {
+  id?: number;
+  email?: string;
+  createdAt?: string;
+  expiresAt?: string;
+  acceptedAt?: string | null;
+}

package/src/models/Setup.ts

@@ -0,0 +1,5 @@
+import type { Item } from '../lib/ports/resource-repository.port';
+
+export interface Setup extends Item {
+  tokenId?: string | null;
+}

package/src/models/SetupRegisterUserInputUserRegister.ts

@@ -0,0 +1,6 @@
+import type { Item } from '../lib/ports/resource-repository.port';
+
+export interface SetupRegisterUserInputUserRegister extends Item {
+  email: string | null;
+  password: string | null;
+}

package/src/models/UserUpdateUserRolesInputUserRoles.ts

@@ -0,0 +1,5 @@
+import type { Item } from '../lib/ports/resource-repository.port';
+
+export interface UserUpdateUserRolesInputUserRoles extends Item {
+  roles: string[] | null;
+}

package/src/models/UserUserRead.ts

@@ -0,0 +1,9 @@
+import type { Item } from '../lib/ports/resource-repository.port';
+
+export interface UserUserRead extends Item {
+  id?: number;
+  email: string;
+  roles?: string[];
+  emailVerified?: boolean;
+  lastLoginAt?: string | null;
+}

package/src/models/index.ts

@@ -0,0 +1,14 @@
+export type { Auth } from './Auth';
+export type { AuthInviteCompleteInputInviteComplete } from './AuthInviteCompleteInputInviteComplete';
+export type { AuthInviteUserInputInviteSend } from './AuthInviteUserInputInviteSend';
+export type { AuthLdJson } from './AuthLdJson';
+export type { AuthPasswordForgotInputPasswordForgot } from './AuthPasswordForgotInputPasswordForgot';
+export type { AuthPasswordResetInputPasswordReset } from './AuthPasswordResetInputPasswordReset';
+export type { AuthRegisterUserInputUserRegister } from './AuthRegisterUserInputUserRegister';
+export type { FrontendConfig } from './FrontendConfig';
+export type { InvitePreview } from './InvitePreview';
+export type { InviteUserInviteRead } from './InviteUserInviteRead';
+export type { Setup } from './Setup';
+export type { SetupRegisterUserInputUserRegister } from './SetupRegisterUserInputUserRegister';
+export type { UserUserRead } from './UserUserRead';
+export type { UserUpdateUserRolesInputUserRoles } from './UserUpdateUserRolesInputUserRoles';

package/src/public-api.ts

@@ -0,0 +1,9 @@
+export * from './lib/provide-bridge';
+export * from './lib/bridge.types';
+export * from './lib/facades/facade.factory';
+export * from './lib/facades/bridge.facade';
+export * from './lib/facades/resource.facade';
+export * from './lib/ports/resource-repository.port';
+export * from './lib/utils/url';
+
+export * from './models';

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "lib": ["ES2022", "dom"],
+    "declaration": true,
+    "declarationMap": false,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./",
+    "strict": true,
+    "noImplicitAny": false,
+    "experimentalDecorators": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "baseUrl": "./"
+  },
+  "include": ["index.ts", "src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}