@odx/angular 12.26.1 → 13.0.1

package/utils/lib/helpers/get-language-code.d.ts

@@ -1,18 +0,0 @@
-/**
- * Extracts the language code from a language string that may include both a language and a region code.
- * The function supports language strings formatted with either a hyphen (`-`) or an underscore (`_`) as the separator.
- *
- * @param {string} language - The complete language string, potentially including both language and region codes.
- * @returns {string} The extracted language code, converted to lower case.
- *
- * @example
- * ```ts
- * // Extracting language code from a language-region string
- * console.log(getLanguageCode('en-US')); // Outputs: 'en'
- * console.log(getLanguageCode('zh_CN')); // Outputs: 'zh'
- *
- * // Handling language codes without region codes
- * console.log(getLanguageCode('fr'));    // Outputs: 'fr'
- * ```
- */
-export declare function getLanguageCode(language: string): string;

package/utils/lib/helpers/get-opposite-side.d.ts

@@ -1,23 +0,0 @@
-import { Position, Side } from '../types';
-/**
- * Determines the opposite side for a given position. This function is useful for scenarios
- * where you need to dynamically calculate the positioning or alignment opposite to the current one,
- * such as inverting tooltips, popovers, or any UI elements that adjust based on available viewport space.
- *
- * @param {Position} position - The position string, which includes a side and possibly an alignment.
- * @returns {Side} The opposite side relative to the provided position's side.
- *
- * @example
- * ```ts
- * // Getting the opposite side of a given position
- * console.log(getOppositeSide('top-left')); // Outputs: 'bottom'
- * console.log(getOppositeSide('right'));    // Outputs: 'left'
- *
- * // Using getOppositeSide to adjust UI elements
- * const currentSide = 'left';
- * const newPosition = getOppositeSide(currentSide);
- * // Assuming an element's position or orientation needs to be dynamically updated
- * updateElementPosition(newPosition);
- * ```
- */
-export declare function getOppositeSide(position: Position): Side;

package/utils/lib/helpers/get-side.d.ts

@@ -1,19 +0,0 @@
-import { Position, Side } from '../types';
-/**
- * Extracts the side part from a position string. The position format generally combines
- * a side (e.g., "top", "bottom", "left", "right") with an optional alignment
- * (e.g., "left", "center", "right" for vertical positions or "top", "middle", "bottom" for horizontal positions).
- *
- * @param {Position} position - The position string from which to extract the side.
- * @returns {Side} The side part of the position, indicating the general placement direction.
- *
- * @example
- * ```ts
- * // Extracting the side from a position with alignment
- * console.log(getSide('top-left')); // Outputs: 'top'
- *
- * // Extracting the side from a simple position
- * console.log(getSide('bottom')); // Outputs: 'bottom'
- * ```
- */
-export declare function getSide(position: Position): Side;

package/utils/lib/helpers/get-unique-id.d.ts

@@ -1,35 +0,0 @@
-/**
- * Generates a unique identifier for a given key. If the key has previously been used,
- * the function increments a counter associated with that key to ensure uniqueness.
- * The generated ID is in the format of `${key}-${counter}`.
- *
- * @param {string} key - The key for which to generate a unique identifier.
- * @returns {string} A unique identifier string based on the provided key.
- *
- * @example
- * ```ts
- * const id1 = getUniqueId('component');
- * console.log(id1); // Outputs: "component-1"
- *
- * const id2 = getUniqueId('component');
- * console.log(id2); // Outputs: "component-2"
- * ```
- */
-export declare function getUniqueId(key: string): string;
-/**
- * Clears the cache used by `getUniqueId` to generate unique identifiers. This function
- * resets all counters associated with each key, effectively restarting the generation
- * of unique IDs from their initial state.
- *
- * This can be useful in scenarios such as testing or when starting a new session that
- * requires resetting the state of unique ID generation.
- *
- * @example
- * ```ts
- * getUniqueId('component'); // Returns "component-1"
- * getUniqueId('component'); // Returns "component-2"
- * clearUniqueIdCache();
- * getUniqueId('component'); // Returns "component-1" after cache reset
- * ```
- */
-export declare function clearUniqueIdCache(): void;

package/utils/lib/helpers/index.d.ts

@@ -1,23 +0,0 @@
-export * from './angular';
-export * from './animations-handler';
-export * from './array';
-export * from './build-url';
-export * from './build-website-url';
-export * from './cache-storage-client';
-export * from './coercion';
-export * from './debounce';
-export * from './defer-fn';
-export * from './dom';
-export * from './event-manager';
-export * from './get-axis';
-export * from './get-language-code';
-export * from './get-opposite-side';
-export * from './get-side';
-export * from './get-unique-id';
-export * from './match-url';
-export * from './ng-changes';
-export * from './provide-config';
-export * from './queue';
-export * from './sorter';
-export * from './type-guards';
-export * from './until-destroyed';

package/utils/lib/helpers/match-url.d.ts

@@ -1,42 +0,0 @@
-/**
- * Checks if a given value is a valid URL matcher, which can be either a string or a regular expression.
- * This function serves as a type guard to facilitate URL matching operations by verifying the type of the filter.
- *
- * @param {unknown} value - The value to check for being a valid URL matcher.
- * @returns {value is string | RegExp} `true` if the value is a string or RegExp, indicating it can be used for URL matching; otherwise, `false`.
- *
- * @example
- * ```ts
- * // Checking a string URL matcher
- * console.log(isUrlMatcher('https://example.com')); // true
- *
- * // Checking a RegExp URL matcher
- * console.log(isUrlMatcher(/https:\/\/example\.com/)); // true
- *
- * // Checking a non-matcher value
- * console.log(isUrlMatcher(123)); // false
- * ```
- */
-export declare function isUrlMatcher(value: unknown): value is string | RegExp;
-/**
- * Determines if a given URL matches a specified filter, which can be either a string or a regular expression.
- * For string filters, the function checks if the URL starts with the filter value. For RegExp filters,
- * it checks if the URL matches the regular expression pattern.
- *
- * @param {string} url - The URL to be checked against the filter.
- * @param {string | RegExp} filter - The filter used to match the URL, which can be a prefix string or a RegExp pattern.
- * @returns {boolean} `true` if the URL matches the filter; otherwise, `false`.
- *
- * @example
- * ```ts
- * // Matching a URL with a string filter
- * console.log(matchUrl('https://example.com/page', 'https://example.com')); // true
- *
- * // Matching a URL with a RegExp filter
- * console.log(matchUrl('https://example.com/page', /example\.com\/page/)); // true
- *
- * // A non-matching example
- * console.log(matchUrl('https://example.com/page', 'https://another.com')); // false
- * ```
- */
-export declare function matchUrl(url: string, filter: string | RegExp): boolean;

package/utils/lib/helpers/ng-changes.d.ts

@@ -1,62 +0,0 @@
-import { GetProperties } from '../types';
-/**
- * Represents a typed version of Angular's `SimpleChanges` object, describing the changes to each
- * property of a component or directive. This utility enhances type safety when working with Angular's
- * change detection mechanism by providing specific property types.
- *
- * @template C - The component or directive class.
- * @template Properties - The properties of the component or directive, inferred from `C` by default.
- * @type {Object} - A mapping from property names to change information for each property.
- *
- * @example
- * ```ts
- * interface MyComponent {
- *   name: string;
- *   age: number;
- * }
- *
- * function ngOnChanges(changes: NgChanges<MyComponent>) {
- *   if (changes.name) {
- *     console.log('Name changed from', changes.name.previousValue, 'to', changes.name.currentValue);
- *   }
- * }
- * ```
- */
-export type NgChanges<C, Properties = GetProperties<C>> = {
-    [Key in keyof Properties]: {
-        previousValue: Properties[Key];
-        currentValue: Properties[Key];
-        firstChange: boolean;
-        isFirstChange(): boolean;
-    };
-};
-/**
- * Checks if the specified property or properties have changed in the current change detection cycle.
- * Optionally ignores changes that occur during the first change detection cycle (e.g., initialization).
- *
- * @template U - The component or directive class.
- * @template T - The type representing the changes, typically `NgChanges<U>`.
- * @template K - The key or keys representing the properties to check for changes.
- * @param {T} changes - The `NgChanges` object containing information about all changes.
- * @param {K | K[]} keyOrKeys - The property name(s) to check for changes.
- * @param {boolean} [ignoreFirstChange=true] - Whether to ignore changes that occur during the first change detection cycle.
- * @returns {boolean} `true` if the specified property or properties have changed, otherwise `false`.
- *
- * @example
- * ```ts
- * // Example usage within an Angular component's `ngOnChanges` method
- * ngOnChanges(changes: NgChanges<MyComponent>): void {
- *   if (hasChanged(changes, 'name')) {
- *     console.log('Name has changed');
- *   }
- * }
- *
- * // Checking multiple properties for changes
- * ngOnChanges(changes: NgChanges<MyComponent>): void {
- *   if (hasChanged(changes, ['name', 'age'], false)) {
- *     console.log('Name or age has changed (including first change)');
- *   }
- * }
- * ```
- */
-export declare function hasChanged<U extends Record<string, unknown>, T extends NgChanges<U>, K extends keyof T>(changes: T, keyOrKeys: K | K[], ignoreFirstChange?: boolean): boolean;

package/utils/lib/helpers/provide-config.d.ts

@@ -1,69 +0,0 @@
-import { FactoryProvider, InjectionToken, Type, ValueProvider } from '@angular/core';
-interface ConfigFactoryProvider<T, D extends ConfigDependencies> {
-    useFactory: (...args: {
-        [I in keyof D]: D[I] extends Type<unknown> ? InstanceType<D[I]> : D[I] extends InjectionToken<unknown> ? any : never;
-    }) => T;
-    deps?: [...D];
-}
-export type ConfigDependencies<T = unknown> = ReadonlyArray<Type<T> | InjectionToken<T>>;
-export type ConfigProvider<T = unknown, D extends ConfigDependencies = []> = ConfigFactoryProvider<T, D> | T;
-export type ConfigTransformFn<T = unknown> = (config: Partial<T>) => Partial<T>;
-/**
- * Provides a configuration object or a factory for creating the configuration object, optionally applying a transformation function.
- * This utility simplifies the process of defining and injecting configuration objects throughout an Angular application.
- *
- * @template T - The type of the configuration object.
- * @template D - The dependencies required by the configuration factory, if any.
- * @param {InjectionToken<T> | string} token - The injection token or string token associated with the configuration.
- * @param {ConfigProvider<T, D>} config - The configuration object or a factory provider that produces the configuration.
- * @param {ConfigTransformFn<T>} [transform=() => ({}))] - An optional transformation function to apply to the configuration object.
- * @returns {FactoryProvider | ValueProvider} - An Angular provider object for the given configuration.
- *
- * @example
- * ```ts
- * // Define a simple configuration object
- * const appConfig = { apiEndpoint: 'https://api.example.com' };
- *
- * // Provide the configuration with an optional transformation function
- * provideConfig(appConfigToken, appConfig, (config) => ({
- *   ...config,
- *   apiEndpoint: `${config.apiEndpoint}/v2`,
- * }));
- *
- * // Using a factory provider for dynamic configuration
- * provideConfig(appConfigToken, {
- *   useFactory: (envService) => ({ apiEndpoint: envService.getApiEndpoint() }),
- *   deps: [EnvironmentService],
- * });
- * ```
- */
-export declare function provideConfig<T extends object, D extends ConfigDependencies = ConfigDependencies>(token: InjectionToken<T> | string, config: ConfigProvider<T, D>, transform?: ConfigTransformFn<T>): FactoryProvider | ValueProvider;
-/**
- * Generates a set of configuration-related tokens and utility functions for managing configuration in an Angular application.
- * This function creates a standardized way to define, provide, and inject configurations, including defaults and transformations.
- *
- * @template T - The type of the configuration object.
- * @template N - The name of the configuration, used to generate token names and utility functions.
- * @param {N} name - The name of the configuration.
- * @param {string} prefix - A prefix for the injection token to ensure uniqueness across the application.
- * @param {T} defaultValue - The default value for the configuration.
- * @param {ConfigTransformFn<T>} [transform] - An optional transformation function to be applied to the configuration.
- * @returns An object containing the generated injection token, default configuration, and utility functions for the configuration.
- *
- * @example
- * ```ts
- * // Create configuration tokens and utilities for "appConfig" with a default value and optional transform function
- * const { appConfigConfig, provideAppConfigConfig } = createConfigTokens('appConfig', 'myPrefix', { debug: false }, (config) => ({
- *   ...config,
- *   debug: true, // Enable debug mode by default
- * }));
- *
- * // Later, in a module or component, provide the customized configuration
- * @NgModule({
- *   providers: [provideAppConfigConfig({ apiEndpoint: 'https://api.example.com' })]
- * })
- * class AppModule {}
- * ```
- */
-export declare function createConfigTokens<T, N extends string>(name: N, prefix: string, defaultValue: T, transform?: ConfigTransformFn<T>): Record<`${N}Config`, InjectionToken<Partial<T>>> & Record<`${N}DefaultConfig`, T> & Record<`inject${N}Config`, () => T> & Record<`provide${N}Config`, <D extends ConfigDependencies = ConfigDependencies<Partial<T>>>(config: ConfigProvider<Partial<T>, D>) => FactoryProvider | ValueProvider>;
-export {};

package/utils/lib/helpers/queue.d.ts

@@ -1,123 +0,0 @@
-import { Observable } from 'rxjs';
-type QueueItemId = string | number;
-type QueueItem<T> = T & {
-    id: QueueItemId;
-};
-/**
- * A class representing a queue structure with advanced functionalities including adding, removing,
- * updating items, and observing changes through RxJS observables. It supports generic queue item types,
- * allowing for flexible usage across different contexts.
- *
- * @template T - The type of items stored in the queue. Each item must extend an object containing a unique `id`.
- */
-export declare class Queue<T> {
-    private readonly queue;
-    private readonly events$$;
-    private values;
-    private firstItem;
-    private lastItem;
-    /**
-     * An observable that emits when an item is added to the queue.
-     *
-     * @type {Observable<T>}
-     */
-    readonly onAdd$: Observable<T>;
-    /**
-     * An observable that emits when an item in the queue is updated.
-     *
-     * @type {Observable<T>}
-     */
-    readonly onUpdate$: Observable<T>;
-    /**
-     * An observable that emits when an item is removed from the queue.
-     *
-     * @type {Observable<T>}
-     */
-    readonly onRemove$: Observable<T>;
-    /**
-     * An observable representing the current state of the queue as an array of items.
-     *
-     * @type {Observable<QueueItem<T>[]>}
-     */
-    readonly value$: Observable<QueueItem<T>[]>;
-    /**
-     * An observable that emits the current size of the queue.
-     *
-     * @type {Observable<number>}
-     */
-    readonly size$: Observable<number>;
-    /**
-     * Gets the size of the queue.
-     *
-     * @returns {number} - The number of elements in the queue.
-     */
-    get size(): number;
-    /**
-     * Checks if the specified item is the first item in the queue.
-     *
-     * @param {QueueItem<T>} item - The item to check.
-     * @returns {boolean} - Returns `true` if the item is the first item in the queue, `false` otherwise.
-     */
-    isFirst({ id }: QueueItem<T>): boolean;
-    /**
-     * Checks if the specified item is the last item in the queue.
-     *
-     * @param {QueueItem<T>} item - The item to check.
-     * @returns {boolean} - Returns true if the item is the last item, otherwise returns false.
-     */
-    isLast({ id }: QueueItem<T>): boolean;
-    /**
-     * Retrieves a queue item from the queue based on the provided item or item ID.
-     *
-     * @param {QueueItem<T> | QueueItemId} itemOrId - The queue item or item ID to retrieve.
-     * @returns {QueueItem<T> | null} - The queue item if found, or `null` if not found.
-     */
-    get(itemOrId: QueueItem<T> | QueueItemId): QueueItem<T> | null;
-    /**
-     * Adds an item to the queue, optionally emitting an event.
-     *
-     * @param {QueueItem<T>} item - The item to add.
-     * @param {boolean} [emitEvent=true] - Whether to emit an event for this action.
-     * @returns {QueueItem<T>} The item added to the queue.
-     */
-    add(item: QueueItem<T>, emitEvent?: boolean): QueueItem<T>;
-    /**
-     * Adds multiple items to the queue.
-     *
-     * @param {Array<QueueItem<T>>} items - An array of items to be added to the queue.
-     * @param {boolean} emitEvent - (Optional) A boolean indicating whether to emit an event after adding the items. Default is true.
-     * @returns {Array<QueueItem<T>>} An array of added items.
-     */
-    addMany(items: Array<QueueItem<T>>, emitEvent?: boolean): Array<QueueItem<T>>;
-    /**
-     * Removes an item from the queue.
-     *
-     * @param {Array<QueueItem<T> | QueueItemId>} itemOrId - The item or ID of the item to be removed.
-     * @param {boolean} emitEvent - Whether to emit an event after removing the item. Default is `true`.
-     * @returns The removed item, or `null` if the item was not found.
-     */
-    remove(itemOrId: QueueItem<T> | QueueItemId, emitEvent?: boolean): QueueItem<T> | null;
-    /**
-     * Removes multiple items from the queue based on the provided item or item IDs.
-     *
-     * @param {Array<QueueItem<T> | QueueItemId>} itemOrIds - An array of QueueItem or QueueItemId objects representing the items to be removed.
-     * @param {boolean} emitEvent - A boolean indicating whether to emit an event after removing the items. Default is true.
-     * @returns {Array<QueueItem<T> | null>} An array of removed QueueItem objects or null values.
-     */
-    removeMany(itemOrIds: Array<QueueItem<T> | QueueItemId>, emitEvent?: boolean): Array<QueueItem<T> | null>;
-    /**
-     * Clears the queue by removing all items.
-     *
-     * @param {boolean} emitEvent - Whether to emit an event after clearing the queue. Default is true.
-     */
-    clear(emitEvent?: boolean): void;
-    /**
-     * Returns an array representation of the queue.
-     *
-     * @returns {QueueItem<T>[]} An array containing all the items in the queue.
-     */
-    toArray(): QueueItem<T>[];
-    private notify;
-    private createEventObserver;
-}
-export {};

package/utils/lib/helpers/sorter.d.ts

@@ -1,51 +0,0 @@
-/**
- * Options for creating a sorter function. Can be used for arrays of objects (with `keyFn`)
- * or arrays of primitives (if `keyFn` is omitted).
- * @template T The type of items to be sorted.
- */
-export interface SorterOptions<T> {
-    sortDirection?: SortDirection;
-    locale?: string;
-    collatorOptions?: Intl.CollatorOptions;
-    /**
-     * Optional function to extract the sortable value from an item.
-     * If not provided, the item itself is used for comparison (suitable for arrays of primitives).
-     * The extracted value should be a string, number, boolean, null, or undefined.
-     * @default (item: T) => item
-     */
-    keyFn?: (item: T) => string | number | boolean | null | undefined;
-}
-/**
- * Defines the possible directions for sorting.
- * It is used to specify how elements should be ordered.
- *
- * - `ASC`: Represents "ascending" order (e.g., A to Z, 1 to 10).
- * - `DESC`: Represents "descending" order (e.g., Z to A, 10 to 1).
- */
-export type SortDirection = (typeof SortDirection)[keyof typeof SortDirection];
-/**
- * Constant object representing the available sort directions.
- * @property {string} ASC - Sort in ascending order.
- * @property {string} DESC - Sort in descending order.
- * @readonly
- */
-export declare const SortDirection: {
-    readonly ASC: "asc";
-    readonly DESC: "desc";
-};
-/**
- * Creates a comparison function suitable for Array.prototype.sort(),
- * based on the provided sort parameters.
- * Uses Intl.Collator for string comparison.
- * Can sort arrays of objects by an extracted value (via `keyFn`) or arrays of primitives directly.
- *
- * Behavior for `null` and `undefined` values (either direct or returned by `keyFn`):
- * - `undefined` values are **always** sorted to the end of the array, regardless of the sort direction.
- * - `null` values are sorted to the beginning of the array for ASC sort.
- * - For DESC sort, `null` values are sorted to the end of the array, but before any `undefined` values.
- *
- * @template T The type of items in the array.
- * @param options Optional sorting options. If `keyFn` is not provided, items are compared directly.
- * @returns A comparison function `(a: T, b: T) => number`.
- */
-export declare function createSorter<T>(options?: SorterOptions<T>): (a: T, b: T) => number;

package/utils/lib/helpers/type-guards.d.ts

@@ -1,67 +0,0 @@
-import { TemplateRef, Type, ViewContainerRef } from '@angular/core';
-/**
- * Checks if the given value is a `ViewContainerRef`.
- *
- * @param {unknown} value - The value to check.
- * @returns {value is ViewContainerRef} `true` if the value is a `ViewContainerRef`, otherwise `false`.
- */
-export declare function isViewContainer(value: unknown): value is ViewContainerRef;
-/**
- * Checks if the given value is a `TemplateRef`.
- *
- * @template T - The embedded view type.
- * @param {unknown} value - The value to check.
- * @returns {value is TemplateRef<T>} `true` if the value is a `TemplateRef`, otherwise `false`.
- */
-export declare function isTemplateRef<T = unknown>(value: unknown): value is TemplateRef<T>;
-/**
- * Checks if the given value is an Angular component class.
- *
- * @template T - The component class type.
- * @param {unknown} value - The value to check.
- * @returns {value is Type<T>} `true` if the value is a component class, otherwise `false`.
- */
-export declare function isComponent<T = unknown>(value: unknown): value is Type<T>;
-/**
- * Checks if the given value is a string.
- *
- * @param {unknown} value - The value to check.
- * @returns {value is string} `true` if the value is a string, otherwise `false`.
- */
-export declare function isString(value: unknown): value is string;
-/**
- * Checks if the given value is a non-empty string.
- *
- * @param {unknown} value - The value to check.
- * @returns {value is string} `true` if the value is a non-empty string, otherwise `false`.
- */
-export declare function isNonEmptyString(value: unknown): value is string;
-/**
- * Checks if the given value is a boolean.
- *
- * @param {unknown} value - The value to check.
- * @returns {value is boolean} `true` if the value is a boolean, otherwise `false`.
- */
-export declare function isBoolean(value: unknown): value is boolean;
-/**
- * Checks if the given value is a function.
- *
- * @param {unknown} value - The value to check.
- * @returns {value is CallableFunction} `true` if the value is a function, otherwise `false`.
- */
-export declare function isFunction(value: unknown): value is CallableFunction;
-/**
- * Checks if the given value is present (not null or undefined).
- *
- * @template T - The value type.
- * @param {T | null | undefined} value - The value to check.
- * @returns {value is NonNullable<T>} `true` if the value is present, otherwise `false`.
- */
-export declare function isPresent<T>(value: T | null | undefined): value is NonNullable<T>;
-/**
- * Checks if the given value is a number.
- *
- * @param {unknown} value - The value to check.
- * @returns {value is number} `true` if the value is a number, otherwise `false`.
- */
-export declare function isNumber(value: unknown): value is number;

package/utils/lib/helpers/until-destroyed.d.ts

@@ -1,40 +0,0 @@
-import { MonoTypeOperatorFunction } from 'rxjs';
-/**
- * Creates a MonoTypeOperatorFunction that automatically unsubscribes from observables when the host component or service is destroyed.
- * It uses Angular's `DestroyRef` to detect when the component or service is destroyed and triggers the unsubscription at that point.
- * This utility function helps in managing subscriptions and prevents memory leaks by ensuring observables are unsubscribed when no longer needed.
- *
- * @returns A function that returns a `MonoTypeOperatorFunction<T>`, which can be used in an RxJS pipe to automatically unsubscribe
- * based on the component's or service's lifecycle.
- *
- * @example
- * ```ts
- * // In an Angular component or service
- * import { Component } from '@angular/core';
- * import { Observable } from 'rxjs';
- * import { untilDestroyed } from './path/to/untilDestroyed';
- *
- * @Component({
- *   selector: 'app-example',
- *   template: `<div>Example Component</div>`,
- * })
- * export class ExampleComponent {
- *   private readonly takeUntilDestroyed = untilDestroyed();
- *
- *   constructor() {
- *     const exampleObservable$ = new Observable(observer => {
- *       // Observable logic here
- *     });
- *
- *     exampleObservable$.pipe(
- *       this.takeUntilDestroyed(),
- *     ).subscribe(data => {
- *       // Subscription logic here
- *     });
- *   }
- *
- *   // No need to manually implement ngOnDestroy to unsubscribe
- * }
- * ```
- */
-export declare function untilDestroyed(): <T>() => MonoTypeOperatorFunction<T>;

package/utils/lib/types/axis.d.ts

@@ -1,5 +0,0 @@
-export type Axis = (typeof Axis)[keyof typeof Axis];
-export declare const Axis: {
-    readonly X: "x";
-    readonly Y: "y";
-};

package/utils/lib/types/get-properties.d.ts

@@ -1,5 +0,0 @@
-type MarkFunctionPropertyNames<T> = {
-    [Key in keyof T]: T[Key] extends CallableFunction ? never : Key;
-}[keyof T];
-export type GetProperties<T> = Pick<T, MarkFunctionPropertyNames<T>>;
-export {};

package/utils/lib/types/index.d.ts

@@ -1,4 +0,0 @@
-export * from './axis';
-export * from './get-properties';
-export * from './position';
-export * from './side';

package/utils/lib/types/position.d.ts

@@ -1,15 +0,0 @@
-export type Position = (typeof Position)[keyof typeof Position];
-export declare const Position: {
-    readonly TOP: "top";
-    readonly TOP_START: "top-start";
-    readonly TOP_END: "top-end";
-    readonly RIGHT: "right";
-    readonly RIGHT_START: "right-start";
-    readonly RIGHT_END: "right-end";
-    readonly BOTTOM: "bottom";
-    readonly BOTTOM_START: "bottom-start";
-    readonly BOTTOM_END: "bottom-end";
-    readonly LEFT: "left";
-    readonly LEFT_START: "left-start";
-    readonly LEFT_END: "left-end";
-};

package/utils/lib/types/side.d.ts

@@ -1,7 +0,0 @@
-export type Side = (typeof Side)[keyof typeof Side];
-export declare const Side: {
-    readonly TOP: "top";
-    readonly RIGHT: "right";
-    readonly BOTTOM: "bottom";
-    readonly LEFT: "left";
-};