@ethlete/query 5.15.1 → 5.16.0

package/src/lib/stories/client-page.mdx

@@ -0,0 +1,100 @@
+import { Meta } from '@storybook/blocks';
+
+<Meta title="HttpClient/Client" />
+
+# HttpClient
+
+For API requests, the Eth SDK offers you the option of using a powerful query client. The client includes standard authentication, e.g. with Bearer Token.
+
+## Clients
+
+```ts
+import { QueryClient } from '@ethlete/query';
+
+export const client = new QueryClient({
+  baseRoute: 'https://api.test.com',
+});
+```
+
+### Options
+
+##### Logging
+
+```ts
+export const client = new QueryClient({
+  baseRoute: 'https://api.test.com',
+  logging: {
+    /**
+     * Log all query state changes.
+     */
+    queryStateChanges?: boolean;
+    /**
+     * Log query state garbage collector runs.
+     */
+    queryStateGarbageCollector?: boolean;
+    /**
+     * Log if subscriptions are made to queries that are in the `prepared` state.
+     * This usually indicates that the `.execute()` method was forgotten.
+     */
+    preparedQuerySubscriptions?: boolean;
+  },
+});
+```
+
+---
+
+##### Request
+
+```ts
+import { QueryClient } from '@ethlete/query';
+
+export const client = new QueryClient({
+  baseRoute: 'https://api.test.com',
+  request?: {
+      /**
+       * Adapter function used for extracting the time until the response is invalid.
+       * The default uses the `cache-control` (`max-age` & `s-maxage`), `age` and `expires` headers.
+       * Should return a number in seconds.
+       */
+      cacheAdapter?: CacheAdapterFn;
+      /**
+       * Default headers to be sent with every request.
+       * Will be overridden by headers passed to the query.
+       * Do not include the `Authorization` header here. Use an `AuthProvider` instead.
+       */
+      headers?: RequestHeaders | RequestHeadersMethodMap;
+      /**
+       * Whether to automatically refresh expired queries when the window regains focus.
+       * @default true
+       */
+      autoRefreshQueriesOnWindowFocus?: boolean;
+      /**
+       * Whether to automatically stop polling queries when the window loses focus.
+       * Polling will resume when the window regains focus.
+       * @default true
+       */
+      enableSmartPolling?: boolean;
+      /**
+       * A retry function to be used for all queries.
+       * @default shouldRetryRequest()
+       */
+      retryFn?: RequestRetryFn;
+      /**
+       * Configuration options for all graphql queries.
+       */
+      gql?: {
+          /**
+           * Determines if the query should be sent via GET or POST.
+           * - `GET`: The query will be sent via query parameters.
+           * - `POST`: The query will be sent via the body.
+           * @default 'POST'
+           */
+          transferVia?: GqlTransferOption;
+      };
+      /**
+       * Configuration options for all query strings.
+       */
+      queryParams?: BuildQueryStringConfig;
+  }
+});
+```

package/src/lib/stories/queries-page.mdx

@@ -0,0 +1,117 @@
+import { Meta } from '@storybook/blocks';
+
+<Meta title="HttpClient/Queries" />
+
+# Queries
+
+We use the client to create so-called queries, which we can then use in our components. The client executes the request and offers many convenient features, e.g. to intercept loading or error states or to activate polling on the request.
+
+## Example
+
+```ts
+import { def } from '@ethlete/query';
+import { client } from '../fut-api.client';
+
+// Interfaces
+interface PostLoginArgs {
+  email: string;
+  password: string;
+}
+
+interface PostRefreshTokenArgs {
+  refreshToken: string;
+}
+
+interface AuthorizationTokenView {
+  token: string;
+  refreshToken: string;
+}
+
+// Queries
+export const postLogin = client.post({
+  route: '/auth/login',
+  secure: false,
+  types: {
+    args: def<PostLoginArgs>(),
+    response: def<AuthorizationTokenView>(),
+  },
+});
+
+export const postRefreshToken = client.post({
+  route: '/auth/refresh-token',
+  secure: false,
+  types: {
+    args: def<PostRefreshTokenArgs>(),
+    response: def<AuthorizationTokenView>(),
+  },
+});
+```
+
+## Options
+
+```ts
+
+{
+    /**
+     * The http method to use for the query.
+     */
+    method: Method;
+    /**
+     * Determines if the auth provider should be used for this query.
+     * The query **will throw** if the query client's auth provider is unset.
+     */
+    secure?: boolean;
+    /**
+     * Determines if the query should emit progress events.
+     */
+    reportProgress?: boolean;
+    /**
+     * Determines the query's response type.
+     * @default 'json'
+     */
+    responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
+    /**
+     * Whether this request should be sent with outgoing credentials (cookies).
+     * @default false
+     */
+    withCredentials?: boolean;
+    /**
+     * Configuration for handling auto refresh triggers.
+     *
+     * **Note:** This is only available for queries that can be refreshed. (`GET`, `HEAD`, `OPTIONS`, `GQL_QUERY`)
+     */
+    autoRefreshOn?: QueryAutoRefreshConfig;
+    /**
+     * Whether to automatically stop polling for this query when the window loses focus.
+     * Polling will resume when the window regains focus.
+     *
+     * This can only be disabled if `enableSmartPolling` is enabled on the query client.
+     * @default true
+     */
+    enableSmartPolling?: boolean;
+    /**
+     * Object containing the query's type information.
+     */
+    types?: {
+        /**
+         * The type of the successful response.
+         */
+        response?: Response;
+        /**
+         * Arguments for executing the query.
+         *
+         * - `pathParams`: The path parameters for the query. (in front of the ? in the url)
+         * - `queryParams`: The query parameters for the query. (after the ? in the url)
+         * - `body`: The body for the query. Unavailable for GET, HEAD and OPTIONS requests.
+         * - `headers`: The headers for the query.
+         * - `variables`: The variables for the query. (graphql only)
+         */
+        args?: Arguments;
+    };
+    /**
+     * Object containing the query's entity store information.
+     */
+    entity?: QueryEntityConfig<Store, Data, Response, Arguments, Id>;
+};
+
+```

package/src/lib/symfony/symfony.types.ts

@@ -0,0 +1,21 @@
+import { HttpStatusCode } from '../request';
+
+export interface SymfonyErrorTrace {
+  args: string[];
+  class: string;
+  file: string;
+  function: string;
+  line: number;
+  namespace: string;
+  short_class: string;
+  type: string;
+}
+
+export interface SymfonyError {
+  class: string;
+  detail: string;
+  status: HttpStatusCode;
+  title: string;
+  trace: SymfonyErrorTrace[];
+  type: string;
+}

package/src/lib/symfony/symfony.utils.ts

@@ -0,0 +1,43 @@
+import { FormViolationListView, FormViolationView } from '@ethlete/types';
+import { SymfonyError } from './symfony.types';
+
+export const isSymfonyError = (error: unknown): error is SymfonyError => {
+  if (!error || typeof error !== 'object') {
+    return false;
+  }
+
+  const symfonyError = error as SymfonyError;
+
+  return (
+    symfonyError.class !== undefined &&
+    symfonyError.detail !== undefined &&
+    symfonyError.status !== undefined &&
+    symfonyError.title !== undefined &&
+    symfonyError.trace !== undefined &&
+    symfonyError.type !== undefined
+  );
+};
+
+export const isSymfonyPagerfantaOutOfRangeError = (error: unknown): error is SymfonyError => {
+  if (!isSymfonyError(error)) {
+    return false;
+  }
+
+  return error.class.startsWith('Pagerfanta') && error.class.endsWith('OutOfRangeCurrentPageException');
+};
+
+export const isSymfonyFormViolationListError = (error: unknown): error is FormViolationListView => {
+  return typeof error === 'object' && error !== null && 'violations' in error;
+};
+
+export const isSymfonyListError = (error: unknown): error is FormViolationView[] => {
+  return (
+    !!error &&
+    typeof error === 'object' &&
+    Array.isArray(error) &&
+    !!error.length &&
+    'message' in error[0] &&
+    'propertyPath' in error[0] &&
+    'invalidValue' in error[0]
+  );
+};

package/src/lib/utils/data.utils.ts

@@ -0,0 +1,280 @@
+import { CreateComputedOptions, Injector, Signal, assertInInjectionContext, computed, inject } from '@angular/core';
+import { ToObservableOptions, ToSignalOptions, toObservable, toSignal } from '@angular/core/rxjs-interop';
+import { computedTillTruthy, createDestroy } from '@ethlete/core';
+import { Observable, Subscribable, of, pairwise, startWith, switchMap, takeUntil, tap } from 'rxjs';
+import {
+  AnyQuery,
+  AnyQueryCollection,
+  QueryOf,
+  QueryState,
+  QueryStateType,
+  extractQuery,
+  filterQueryStates,
+  isQuery,
+  isQueryStateFailure,
+  isQueryStateLoading,
+  isQueryStateSuccess,
+} from '../query';
+import { QueryDataOf } from '../query-creator';
+
+export interface QueryContainerConfig {
+  /**
+   * If `true`, the previous query will be aborted when a new query is pushed into the container.
+   * @default true // Only if the request can be cached (GET, OPTIONS, HEAD and GQL_QUERY). Otherwise false.
+   */
+  abortPrevious?: boolean;
+
+  /**
+   * If `true`, the query will be aborted when the container is destroyed.
+   * @default true // Only if the request can be cached (GET, OPTIONS, HEAD and GQL_QUERY). Otherwise false.
+   */
+  abortOnDestroy?: boolean;
+
+  /**
+   * If `true`, the previous polling will be stopped when a new query is pushed into the container.
+   * @default true // Only if the query has no other dependents and the request can be cached (GET, OPTIONS, HEAD and GQL_QUERY). Otherwise false.
+   */
+  stopPreviousPolling?: boolean;
+}
+
+export interface QueryFilterConfig {
+  /**
+   * If `true`, the response will be cached until the next response is received or the query fails.
+   * @default false
+   */
+  cacheResponse?: boolean;
+}
+
+export const addQueryContainerHandling = (
+  obs: Observable<AnyQuery | AnyQuery[] | null>,
+  valueFn: () => AnyQuery | AnyQuery[] | null | undefined,
+  config?: QueryContainerConfig,
+) => {
+  assertInInjectionContext(addQueryContainerHandling);
+
+  const { abortPrevious, abortOnDestroy, stopPreviousPolling } = config ?? {};
+
+  const injector = inject(Injector);
+  const destroy$ = createDestroy();
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const tNode = (injector as any)._tNode;
+  const componentId = tNode?.index ?? -1;
+
+  obs
+    .pipe(
+      takeUntil(destroy$),
+      startWith(null),
+      pairwise(),
+      tap(([prevQuery, currQuery]) => {
+        const cleanQuery = (q: AnyQuery | null | undefined) => {
+          if (!q?._hasDependents() && ((abortPrevious === undefined && q?.canBeCached) || abortPrevious)) {
+            q?.abort();
+          }
+
+          if (
+            !q?._hasDependents() &&
+            ((stopPreviousPolling === undefined && q?.canBeCached) || stopPreviousPolling) &&
+            q?.isPolling
+          ) {
+            q?.stopPolling();
+          }
+        };
+
+        if ((isQuery(prevQuery) || prevQuery === null) && (isQuery(currQuery) || currQuery === null)) {
+          prevQuery?._removeDependent(componentId);
+          currQuery?._addDependent(componentId);
+
+          cleanQuery(prevQuery);
+        } else if (
+          (Array.isArray(prevQuery) || prevQuery === null) &&
+          (Array.isArray(currQuery) || currQuery === null)
+        ) {
+          if (prevQuery) {
+            for (let i = 0; i < prevQuery.length; i++) {
+              prevQuery[i]?._removeDependent(componentId);
+            }
+          }
+
+          if (currQuery) {
+            for (let i = 0; i < currQuery.length; i++) {
+              currQuery[i]?._addDependent(componentId);
+            }
+          }
+
+          if (prevQuery) {
+            for (let i = 0; i < prevQuery.length; i++) {
+              cleanQuery(prevQuery[i]);
+            }
+          }
+        } else if (
+          (isQuery(prevQuery) && Array.isArray(currQuery)) ||
+          (Array.isArray(prevQuery) && isQuery(currQuery))
+        ) {
+          throw new Error('Cannot mix queries and arrays of queries in the same query container.');
+        }
+      }),
+    )
+    .subscribe();
+
+  destroy$.subscribe(() => {
+    const query = valueFn();
+
+    const handleQuery = (q: AnyQuery | null | undefined) => {
+      q?._removeDependent(componentId);
+
+      if (!q?._hasDependents() && ((q?.canBeCached && abortOnDestroy === undefined) || abortOnDestroy)) {
+        q?.abort();
+      }
+    };
+
+    if (isQuery(query)) {
+      handleQuery(query);
+    } else if (Array.isArray(query)) {
+      for (const q of query) {
+        handleQuery(q);
+      }
+    }
+  });
+};
+
+export function toQuerySignal<T extends AnyQuery | null>(
+  source: Observable<T> | Subscribable<T>,
+): Signal<T | undefined>;
+export function toQuerySignal<T extends AnyQuery | null>(
+  source: Observable<T> | Subscribable<T>,
+  options: ToSignalOptions & { initialValue?: undefined; requireSync?: false } & QueryContainerConfig,
+): Signal<T | undefined>;
+export function toQuerySignal<T extends AnyQuery | null>(
+  source: Observable<T> | Subscribable<T>,
+  options: ToSignalOptions & { initialValue?: null; requireSync?: false } & QueryContainerConfig,
+): Signal<T | null>;
+export function toQuerySignal<T extends AnyQuery | null>(
+  source: Observable<T> | Subscribable<T>,
+  options: ToSignalOptions & { initialValue?: undefined; requireSync: true } & QueryContainerConfig,
+): Signal<T>;
+export function toQuerySignal<T extends AnyQuery | null, const U extends T>(
+  source: Observable<T> | Subscribable<T>,
+  options: ToSignalOptions & { initialValue: U; requireSync?: false } & QueryContainerConfig,
+): Signal<T | U>;
+
+export function toQuerySignal<T extends AnyQuery | null, U = undefined>(
+  source: Observable<T> | Subscribable<T>,
+  options?: ToSignalOptions & { initialValue?: U } & QueryContainerConfig,
+): Signal<T | U> {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const s = toSignal(source, options as any);
+
+  addQueryContainerHandling(source as Observable<T>, () => s() as T, options);
+
+  return s as Signal<T | U>;
+}
+
+export function queryComputed<T extends AnyQuery | null>(
+  computation: () => T,
+  options?: CreateComputedOptions<T> & QueryContainerConfig & ToObservableOptions,
+): Signal<T> {
+  const c = computed(computation, options);
+  const obs = toObservable(c, options);
+
+  addQueryContainerHandling(obs, () => c(), options);
+
+  return c;
+}
+
+/**
+ * Creates a signal that will only be reactive until the first query is created.
+ * All subsequent changes inside the computation will be ignored.
+ */
+export function queryComputedTillTruthy<T extends AnyQuery | null>(
+  computation: () => T,
+  options?: CreateComputedOptions<T> & QueryContainerConfig & ToObservableOptions,
+): Signal<T | null> {
+  const c = computedTillTruthy(computed(computation, options));
+  const obs = toObservable(c, options);
+
+  addQueryContainerHandling(obs, () => c(), options);
+
+  return c;
+}
+
+export function queryArrayComputed<T extends AnyQuery[] | null>(
+  computation: () => T,
+  options?: CreateComputedOptions<T> & QueryContainerConfig & ToObservableOptions,
+): Signal<T> {
+  const c = computed(computation, options);
+  const obs = toObservable(c, options);
+
+  addQueryContainerHandling(obs, () => c(), options);
+
+  return c;
+}
+
+export function toQuerySubject<T extends AnyQuery | null>(
+  source: Signal<T>,
+  options?: ToObservableOptions & QueryContainerConfig,
+): Observable<T> {
+  const obs = toObservable(source, options);
+
+  addQueryContainerHandling(obs, () => source(), options);
+
+  return obs;
+}
+
+export function queryStateSignal<T extends Signal<AnyQuery | AnyQueryCollection | null>>(
+  source: T,
+  options?: QueryFilterConfig,
+) {
+  const { cacheResponse } = options ?? {};
+
+  return toSignal(
+    toObservable(source).pipe(
+      switchMap((q) => extractQuery(q)?.state$ ?? of(null)),
+      switchMap((state) => {
+        if (cacheResponse) {
+          return of(state).pipe(
+            filterQueryStates([QueryStateType.Success, QueryStateType.Failure, QueryStateType.Cancelled]),
+          );
+        }
+
+        return of(state);
+      }),
+    ),
+    {
+      initialValue: null,
+    },
+  ) as Signal<QueryState<QueryDataOf<QueryOf<ReturnType<T>>>> | null>;
+}
+
+export function queryStateResponseSignal<T extends Signal<AnyQuery | AnyQueryCollection | null>>(
+  source: T,
+  options?: QueryFilterConfig,
+) {
+  const s = queryStateSignal(source, options);
+
+  return computed(() => {
+    const state = s();
+
+    return isQueryStateSuccess(state) ? state.response : null;
+  });
+}
+
+export function queryStateErrorSignal<T extends Signal<AnyQuery | AnyQueryCollection | null>>(source: T) {
+  const s = queryStateSignal(source);
+
+  return computed(() => {
+    const state = s();
+
+    return isQueryStateFailure(state) ? state.error : null;
+  });
+}
+
+export function queryStateLoadingSignal<T extends Signal<AnyQuery | AnyQueryCollection | null>>(source: T) {
+  const s = queryStateSignal(source);
+
+  return computed(() => {
+    const state = s();
+
+    return isQueryStateLoading(state) ? state : null;
+  });
+}

package/src/lib/utils/deep-freeze.util.ts

@@ -0,0 +1,21 @@
+export const deepFreeze = <T extends Record<string, unknown>>(object: T) => {
+  // check if object is actually an object or frozen
+  if (!object || typeof object !== 'object' || Object.isFrozen(object)) {
+    return object;
+  }
+
+  // Retrieve the property names defined on object
+  const propNames = Object.getOwnPropertyNames(object);
+
+  // Freeze properties before freezing self
+
+  for (const name of propNames) {
+    const value = object[name];
+
+    if (value && typeof value === 'object') {
+      deepFreeze(value as T);
+    }
+  }
+
+  return Object.freeze(object);
+};

package/{lib/utils/def.util.d.ts → src/lib/utils/def.util.ts}

@@ -4,4 +4,4 @@
  * @see https://github.com/microsoft/TypeScript/issues/26242
  * @returns null
  */
-export declare const def: <Data>() => Data;
+export const def = <Data>() => null as unknown as Data;

package/src/test-setup.ts

@@ -0,0 +1 @@
+import 'jest-preset-angular/setup-jest';

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "useDefineForClassFields": false,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ],
+  "extends": "../../tsconfig.base.json",
+  "angularCompilerOptions": {
+    "enableI18nLegacyMessageIdFormat": false,
+    "strictInjectionParameters": true,
+    "strictInputAccessModifiers": true,
+    "strictTemplates": true
+  }
+}

package/tsconfig.lib.json

@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "declaration": true,
+    "declarationMap": true,
+    "inlineSources": true,
+    "types": ["mdx"]
+  },
+  "exclude": ["src/test-setup.ts", "src/**/*.spec.ts", "jest.config.ts", "src/**/*.test.ts"],
+  "include": ["src/**/*.ts"]
+}

package/tsconfig.lib.prod.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "declarationMap": false,
+    "stripInternal": true
+  },
+  "angularCompilerOptions": {
+    "compilationMode": "partial"
+  }
+}

package/tsconfig.spec.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "module": "commonjs",
+    "types": ["jest", "node"],
+    "target": "es2016"
+  },
+  "files": ["src/test-setup.ts"],
+  "include": ["jest.config.ts", "src/**/*.test.ts", "src/**/*.spec.ts", "src/**/*.d.ts"]
+}

package/esm2022/ethlete-query.mjs

@@ -1,5 +0,0 @@
-/**
- * Generated bundle index. Do not edit.
- */
-export * from './index';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXRobGV0ZS1xdWVyeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYnMvcXVlcnkvc3JjL2V0aGxldGUtcXVlcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2022/index.mjs

@@ -1,20 +0,0 @@
-export * from './lib/auth';
-export * from './lib/class-validator';
-export * from './lib/devtools/components/query-devtools';
-export * from './lib/devtools/pipes';
-export * from './lib/devtools/utils';
-export * from './lib/directives';
-export * from './lib/entity';
-export * from './lib/gql';
-export * from './lib/infinite-query';
-export * from './lib/logger';
-export * from './lib/query';
-export * from './lib/query-client';
-export * from './lib/query-creator';
-export * from './lib/query-form';
-export * from './lib/query-store';
-export * from './lib/request';
-export * from './lib/symfony';
-export * from './lib/utils';
-// Burst cache
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWJzL3F1ZXJ5L3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsMENBQTBDLENBQUM7QUFDekQsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsYUFBYSxDQUFDO0FBRTVCLGNBQWMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9hdXRoJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NsYXNzLXZhbGlkYXRvcic7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9kZXZ0b29scy9jb21wb25lbnRzL3F1ZXJ5LWRldnRvb2xzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2RldnRvb2xzL3BpcGVzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2RldnRvb2xzL3V0aWxzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2RpcmVjdGl2ZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZW50aXR5JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2dxbCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9pbmZpbml0ZS1xdWVyeSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9sb2dnZXInO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvcXVlcnknO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvcXVlcnktY2xpZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3F1ZXJ5LWNyZWF0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvcXVlcnktZm9ybSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9xdWVyeS1zdG9yZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9yZXF1ZXN0JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3N5bWZvbnknO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdXRpbHMnO1xuXG4vLyBCdXJzdCBjYWNoZVxuIl19