@naptics/vue-collection 0.0.1

package/lib/utils/breakpoints.js

@@ -0,0 +1,37 @@
+import { computed, ref } from 'vue';
+export const breakpoints = {
+    sm: 640,
+    md: 768,
+    lg: 1024,
+    xl: 1280,
+    '2xl': 1536,
+};
+export const bodyWidth = ref(document.body.clientWidth);
+/**
+ * This function has to be called once in the app two ensure that the breakpoint utilities actually update.
+ * It sets a `window.onresize` listener.
+ */
+export function addDocumentResizeEventListener() {
+    window.onresize = () => {
+        bodyWidth.value = document.body.clientWidth;
+    };
+}
+export function isWidthBreakpoint(breakpoint) {
+    switch (breakpoint) {
+        case 'sm':
+            return isWidthSm;
+        case 'md':
+            return isWidthMd;
+        case 'lg':
+            return isWidthLg;
+        case 'xl':
+            return isWidthXl;
+        case '2xl':
+            return isWidth2xl;
+    }
+}
+export const isWidth2xl = computed(() => bodyWidth.value > breakpoints['2xl']);
+export const isWidthXl = computed(() => bodyWidth.value > breakpoints.xl);
+export const isWidthLg = computed(() => bodyWidth.value > breakpoints.lg);
+export const isWidthMd = computed(() => bodyWidth.value > breakpoints.md);
+export const isWidthSm = computed(() => bodyWidth.value > breakpoints.sm);

package/lib/utils/component.d.ts

@@ -0,0 +1,50 @@
+import type { LooseRequired } from '@vue/shared';
+import { type ComponentObjectPropsOptions, type ExtractPropTypes, type RenderFunction, type SetupContext, type ToRefs, type UnwrapNestedRefs } from 'vue';
+type Data = Record<string, unknown>;
+export type Props<T = Data> = ComponentObjectPropsOptions<T>;
+/**
+ * `ExtractedProps` maps a prop object to the props, which are received in the `setup` function of a components.
+ */
+export type ExtractedProps<T extends Props> = Readonly<LooseRequired<Readonly<ExtractPropTypes<T>>>>;
+/**
+ * Components should be created using this helper function.
+ * It only takes three arguments, the name and the props of the component and the setup function.
+ * All other arguments which the {@link defineComponent} method of vue may provide,
+ * should not be used for a better consistency across all components.
+ * @param name the name of the component, should be more than one word.
+ * @param props the props of the component.
+ * @param setup the setup function, which will be called when the component is mounted.
+ * @returns the created vue-component.
+ */
+export declare function createComponent<T extends Props>(name: string, props: T, setup: (props: ExtractedProps<T>, context: SetupContext<never[]>) => RenderFunction | Promise<RenderFunction>): import("vue").DefineComponent<T, RenderFunction, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, never[], never, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<T extends import("vue").ComponentPropsOptions<{
+    [x: string]: unknown;
+}> ? ExtractPropTypes<T> : T> & {}, import("vue").ExtractDefaultPropTypes<T>>;
+/**
+ * Views should be created using this helper function. Views are special components, which don't have props.
+ * They are often the parent objects in a view hierarchy and contain many components.
+ * This function is syntactic sugar to create views and just calls {@link createComponent}.
+ * @param name the name of the component, should be more than one word.
+ * @param setup the setup function, which will be called when the component is mounted.
+ * @returns the created vue-component.
+ */
+export declare function createView(name: string, setup: (context: SetupContext<never[]>) => RenderFunction | Promise<RenderFunction>): import("vue").DefineComponent<{}, RenderFunction, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, never[], never, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<ExtractPropTypes<{}>> & {}, {}>;
+/**
+ * If props are specified outside of the {@link createComponent}
+ * function - e.g. to export them or for better code style -
+ * this helper function can be used to ensure strict typing.
+ * @param props the props which should be created.
+ * @returns the created props, with correct typing.
+ */
+export declare function createProps<T extends Props>(props: T): T;
+/**
+ * Extracts props from another prop object and returns a reactive object with the specified props.
+ * @param props the props to extract from
+ * @param keys the keys to extract from the props
+ * @returns the new object with the specified props
+ * @example
+ * const parentProps = { title: 'hi', text: 'ho' }
+ * const childProps = extractProps(parentProps, 'title')
+ * console.log(childProps) // { title: 'hi' }
+ */
+export declare function extractProps<T extends Record<string, unknown>>(props: T, ...keys: (keyof T)[]): UnwrapNestedRefs<Partial<ToRefs<T>>>;
+export {};

package/lib/utils/component.js

@@ -0,0 +1,51 @@
+import { defineComponent, reactive, toRef, } from 'vue';
+/**
+ * Components should be created using this helper function.
+ * It only takes three arguments, the name and the props of the component and the setup function.
+ * All other arguments which the {@link defineComponent} method of vue may provide,
+ * should not be used for a better consistency across all components.
+ * @param name the name of the component, should be more than one word.
+ * @param props the props of the component.
+ * @param setup the setup function, which will be called when the component is mounted.
+ * @returns the created vue-component.
+ */
+export function createComponent(name, props, setup) {
+    return defineComponent({ name, props, emits: [], setup });
+}
+/**
+ * Views should be created using this helper function. Views are special components, which don't have props.
+ * They are often the parent objects in a view hierarchy and contain many components.
+ * This function is syntactic sugar to create views and just calls {@link createComponent}.
+ * @param name the name of the component, should be more than one word.
+ * @param setup the setup function, which will be called when the component is mounted.
+ * @returns the created vue-component.
+ */
+export function createView(name, setup) {
+    return defineComponent({ name, emits: [], setup: (props, context) => setup(context) });
+}
+/**
+ * If props are specified outside of the {@link createComponent}
+ * function - e.g. to export them or for better code style -
+ * this helper function can be used to ensure strict typing.
+ * @param props the props which should be created.
+ * @returns the created props, with correct typing.
+ */
+export function createProps(props) {
+    return props;
+}
+/**
+ * Extracts props from another prop object and returns a reactive object with the specified props.
+ * @param props the props to extract from
+ * @param keys the keys to extract from the props
+ * @returns the new object with the specified props
+ * @example
+ * const parentProps = { title: 'hi', text: 'ho' }
+ * const childProps = extractProps(parentProps, 'title')
+ * console.log(childProps) // { title: 'hi' }
+ */
+export function extractProps(props, ...keys) {
+    const partial = {};
+    for (const key of keys)
+        partial[key] = toRef(props, key);
+    return reactive(partial);
+}

package/lib/utils/deferred.d.ts

@@ -0,0 +1,13 @@
+type PromiseResolve<T> = (value: T | PromiseLike<T>) => void;
+type PromiseReject = (reason?: unknown) => void;
+export type DeferredPromise<T> = {
+    promise: Promise<T>;
+    resolve: PromiseResolve<T>;
+    reject: PromiseReject;
+};
+/**
+ * Utlitity to return a deferred promise, which can be resolved from outside.
+ * @returns promise, resolve and reject
+ */
+export declare function deferred<T>(): DeferredPromise<T>;
+export {};

package/lib/utils/deferred.js

@@ -0,0 +1,17 @@
+/**
+ * Utlitity to return a deferred promise, which can be resolved from outside.
+ * @returns promise, resolve and reject
+ */
+export function deferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((_resolve, _reject) => {
+        resolve = _resolve;
+        reject = _reject;
+    });
+    return {
+        promise,
+        resolve,
+        reject,
+    };
+}

package/lib/utils/identifiable.d.ts

@@ -0,0 +1,57 @@
+import { type Nullish } from './utils';
+type IdType = string;
+export type Identifiable = Readonly<{
+    id: IdType;
+}>;
+export type MaybeIdentifiable = Readonly<{
+    id?: Nullish<IdType>;
+}>;
+/**
+ * Looks for the `id` in the given array of `Identifiables`.
+ * @param array The array to search the item in.
+ * @param id The `id` of the desired item.
+ * @returns The first item with the specified `id` or `undefined` if none exists.
+ */
+declare function find<T extends Identifiable>(array: T[], id: IdType): T | undefined;
+/**
+ * Checks if the given array contains an item with the `id`.
+ * @param array The array to search the item in.
+ * @param id The `id` to check the array for.
+ * @returns `true` if there is at least one item in the array with the given `id`.
+ */
+declare function contains<T extends Identifiable>(array: T[], id: IdType): boolean;
+/**
+ * Inserts the items into the given array, replacing items with the same `id`.
+ * If no item with the same `id` exists, the item is appended to the array.
+ * If multiple items with the same `id` exist, just the first item is replaced.
+ * @param array The array to insert the items into.
+ * @param insertItems The items to insert into the array.
+ * @returns The reference to the same array, which was passed.
+ */
+declare function insert<T extends Identifiable>(array: T[], ...insertItems: T[]): T[];
+/**
+ * Removes all items with the specified `ids` from the given array.
+ * @param array The array to remove the items from.
+ * @param ids The `ids` of the items which should be removed.
+ * @returns The reference to the same array, which was passed.
+ */
+declare function remove<T extends Identifiable>(array: T[], ...ids: IdType[]): T[];
+/**
+ * Compares the two arrays and checks if they both have
+ * items with the same `ids` in the same order.
+ * @param first The first array to compare.
+ * @param second The second array to compare.
+ * @returns `true` if the arrays contain item with the same `ids` in the same order.
+ */
+declare function areSameArrays(first: Identifiable[], second: Identifiable[]): boolean;
+/**
+ * This object contains utility functions to deal with {@link Identifiable} objects.
+ */
+export declare const Id: import("./utils").ReadonlyObject<{
+    find: typeof find;
+    contains: typeof contains;
+    insert: typeof insert;
+    remove: typeof remove;
+    areSameArrays: typeof areSameArrays;
+}>;
+export {};

package/lib/utils/identifiable.js

@@ -0,0 +1,78 @@
+import { markReadonly } from './utils';
+/**
+ * Looks for the `id` in the given array of `Identifiables`.
+ * @param array The array to search the item in.
+ * @param id The `id` of the desired item.
+ * @returns The first item with the specified `id` or `undefined` if none exists.
+ */
+function find(array, id) {
+    const filtered = array.filter(item => item.id === id);
+    if (filtered.length > 0)
+        return filtered[0];
+    else
+        return undefined;
+}
+/**
+ * Checks if the given array contains an item with the `id`.
+ * @param array The array to search the item in.
+ * @param id The `id` to check the array for.
+ * @returns `true` if there is at least one item in the array with the given `id`.
+ */
+function contains(array, id) {
+    return find(array, id) !== undefined;
+}
+function insertSingle(baseArray, insertItem) {
+    const index = baseArray.findIndex(item => item.id === insertItem.id);
+    index === -1 ? baseArray.push(insertItem) : baseArray.splice(index, 1, insertItem);
+}
+/**
+ * Inserts the items into the given array, replacing items with the same `id`.
+ * If no item with the same `id` exists, the item is appended to the array.
+ * If multiple items with the same `id` exist, just the first item is replaced.
+ * @param array The array to insert the items into.
+ * @param insertItems The items to insert into the array.
+ * @returns The reference to the same array, which was passed.
+ */
+function insert(array, ...insertItems) {
+    insertItems.forEach(item => insertSingle(array, item));
+    return array;
+}
+/**
+ * Removes all items with the specified `ids` from the given array.
+ * @param array The array to remove the items from.
+ * @param ids The `ids` of the items which should be removed.
+ * @returns The reference to the same array, which was passed.
+ */
+function remove(array, ...ids) {
+    ids.forEach(id => {
+        let noMatches = false;
+        while (!noMatches) {
+            const index = array.findIndex(item => item.id === id);
+            if (index != -1)
+                array.splice(index, 1);
+            else
+                noMatches = true;
+        }
+    });
+    return array;
+}
+/**
+ * Compares the two arrays and checks if they both have
+ * items with the same `ids` in the same order.
+ * @param first The first array to compare.
+ * @param second The second array to compare.
+ * @returns `true` if the arrays contain item with the same `ids` in the same order.
+ */
+function areSameArrays(first, second) {
+    if (first.length != second.length)
+        return false;
+    for (let i = 0; i < first.length; i++) {
+        if (first[i]?.id !== second[i]?.id)
+            return false;
+    }
+    return true;
+}
+/**
+ * This object contains utility functions to deal with {@link Identifiable} objects.
+ */
+export const Id = markReadonly({ find, contains, insert, remove, areSameArrays });

package/lib/utils/stringMaxLength.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns a shortened string with '...' at the end if it is longer than the given `maxLength`.
+ * @param input the string to shorten
+ * @param maxLength the max length
+ * @see maxLengthSplitCenter
+ */
+export declare function maxLength(input: string | null, maxLength: number): string;
+/**
+ * Returns a shortened string with '...' in the center of the string if it is longer than the given `maxLength`.
+ * @param input the string to shorten
+ * @param maxLength the max length
+ * @see maxLength
+ */
+export declare function maxLengthSplitCenter(input: string | null, maxLength: number): string;

package/lib/utils/stringMaxLength.js

@@ -0,0 +1,28 @@
+/**
+ * Returns a shortened string with '...' at the end if it is longer than the given `maxLength`.
+ * @param input the string to shorten
+ * @param maxLength the max length
+ * @see maxLengthSplitCenter
+ */
+export function maxLength(input, maxLength) {
+    if (input && input.length > maxLength)
+        return `${input.substring(0, maxLength - 3).trim()}...`;
+    else
+        return input || '';
+}
+/**
+ * Returns a shortened string with '...' in the center of the string if it is longer than the given `maxLength`.
+ * @param input the string to shorten
+ * @param maxLength the max length
+ * @see maxLength
+ */
+export function maxLengthSplitCenter(input, maxLength) {
+    if (input && input.length > maxLength) {
+        const chars = maxLength - 3;
+        const charsAtStart = Math.ceil(chars / 2);
+        const charsAtEnd = Math.floor(chars / 2);
+        return `${input.substring(0, charsAtStart).trim()}...${input.substring(input.length - charsAtEnd).trim()}`;
+    }
+    else
+        return input || '';
+}

package/lib/utils/tailwind.d.ts

@@ -0,0 +1,2 @@
+export type TWTextSize = 'text-xs' | 'text-sm' | 'text-base' | 'text-lg' | 'text-xl' | 'text-2xl' | 'text-3xl' | 'text-4xl' | 'text-5xl' | 'text-6xl' | 'text-7xl' | 'text-8xl' | 'text-9xl';
+export type TWMaxWidth = 'max-w-xs' | 'max-w-sm' | 'max-w-md' | 'max-w-lg' | 'max-w-xl' | 'max-w-2xl' | 'max-w-3xl' | 'max-w-4xl' | 'max-w-5xl' | 'max-w-6xl' | 'max-w-7xl' | 'max-w-full' | 'max-w-min' | 'max-w-max' | 'max-w-fit' | 'max-w-prose' | 'max-w-screen-sm' | 'max-w-screen-md' | 'max-w-screen-lg' | 'max-w-screen-xl' | 'max-w-screen-2xl';

package/lib/utils/tailwind.js

@@ -0,0 +1 @@
+export {};

package/lib/utils/utils.d.ts

@@ -0,0 +1,27 @@
+import type { FunctionalComponent, HTMLAttributes, VNodeProps } from 'vue';
+export type AnyObject = Record<string | number | symbol, unknown>;
+export type EmptyObject = Record<string, never>;
+export type Optional<T> = T | undefined;
+export type Nullable<T> = T | null;
+export type Nullish<T> = T | null | undefined;
+export type HeroIcon = FunctionalComponent<HTMLAttributes & VNodeProps>;
+export type ReadonlyObject<T extends AnyObject> = {
+    readonly [P in keyof T]: T[P] extends ReadonlyObject<infer _U> ? T[P] : T[P] extends AnyObject ? ReadonlyObject<T[P]> : T[P];
+};
+export declare function markReadonly<T extends AnyObject>(object: T): ReadonlyObject<T>;
+/**
+ * Generates and returns a non random but unique id.
+ */
+export declare function uniqueId(): number;
+/**
+ * Determines if a value is not null or undefined.
+ * @param value the value to check
+ * @returns `true` if the value is anything but `null` or `undefined`.
+ */
+export declare function notNullish<T>(value: Nullish<T>): value is T;
+/**
+ * Determines if a value is null or undefined.
+ * @param value the value to check
+ * @returns `true` if the value is `null` or `undefined`.
+ */
+export declare function isNullish(value: Nullish<unknown>): value is null | undefined;

package/lib/utils/utils.js

@@ -0,0 +1,26 @@
+export function markReadonly(object) {
+    return object;
+}
+let currentId = 1;
+/**
+ * Generates and returns a non random but unique id.
+ */
+export function uniqueId() {
+    return currentId++;
+}
+/**
+ * Determines if a value is not null or undefined.
+ * @param value the value to check
+ * @returns `true` if the value is anything but `null` or `undefined`.
+ */
+export function notNullish(value) {
+    return value !== null && value !== undefined;
+}
+/**
+ * Determines if a value is null or undefined.
+ * @param value the value to check
+ * @returns `true` if the value is `null` or `undefined`.
+ */
+export function isNullish(value) {
+    return value === null || value === undefined;
+}

package/lib/utils/vModel.d.ts

@@ -0,0 +1,182 @@
+import type { PropType, Ref } from 'vue';
+import type { AnyObject } from './utils';
+/**
+ * Creates props for a `v-model` of the given type.
+ * A `v-model` consits of a value-property and a update-function.
+ * @param propType The propType of the `v-model`.
+ * @returns An object containing the value-property and the update-function.
+ */
+export declare function vModelProps<T>(propType: PropType<T>): {
+    /**
+     * The value of the component.
+     */
+    readonly value: PropType<T>;
+    /**
+     * This will be called, when the value of the component has changed.
+     */
+    readonly onUpdateValue: PropType<(newValue: T) => void>;
+};
+/**
+ * Creates props for a required `v-model` of the given type.
+ * @see {@link vModelProps}
+ */
+export declare function vModelRequiredProps<T>(propType: PropType<T>): {
+    /**
+     * The value of the component.
+     */
+    readonly value: {
+        readonly type: PropType<T>;
+        readonly required: true;
+    };
+    /**
+     * This will be called, when the value of the component has changed.
+     */
+    readonly onUpdateValue: PropType<(newValue: T) => void>;
+};
+/**
+ * Creates props for a `v-model` of the given type with a default value.
+ * @see {@link vModelProps}
+ */
+export declare function vModelDefaultProps<T>(propType: PropType<T>, defaultValue: () => T): {
+    /**
+     * The value of the component.
+     */
+    readonly value: {
+        readonly type: PropType<T>;
+        readonly default: () => T;
+    };
+    /**
+     * This will be called, when the value of the component has changed.
+     */
+    readonly onUpdateValue: PropType<(newValue: T) => void>;
+};
+/**
+ * The `VModel` type contains a value and an optional update-function.
+ * This object is passed to a component to create a two-way binding.
+ */
+export type VModel<T, U = T> = {
+    value: T;
+    onUpdateValue?: (newValue: U) => void;
+};
+/**
+ * The `VModelForArray` contains the normal `VModel` properties,
+ * but aditionally a function, which removes the value from the array.
+ */
+export type VModelForArray<T, U = T> = VModel<T, U> & {
+    remove(): void;
+};
+/**
+ * Uses the given `ref` as a `v-model`, to create a two-way binding with the `ref`.
+ * @param ref The `ref` which should be used as the `v-model`.
+ * @returns An object of type {@link VModel}, which connects the `ref` to the `v-model`.
+ */
+export declare function vModelForRef<T>(ref: Ref<T>): VModel<T>;
+/**
+ * This creates a `v-model` for a property of an object. The property of the object is taken as the
+ * value of the `v-model`, the `onUpdate` function, is called every time when the property is updated
+ * with the whole object and its updated property.
+ * @param object The object which contains the relevant property.
+ * @param key The key of the property which should be used as the v-model.
+ * @param onUpdate The updater function which is called with the entire object when the property has changed.
+ * @returns An object containing of type {@link VModel}.
+ * @example
+ * ```tsx
+ * // inside setup function
+ * const customer = ref({ firstName: 'Hansi', lastName: 'Halunk' })
+ *
+ * // This input needs a v-model for the `firstName` property.
+ * return () => (
+ *     <NInput
+ *         name="First Name"
+ *         {...vModelForObjectProperty(customer.value, 'firstName', newVal => (customer.value = newValue))}
+ *     />
+ * )
+ * ```
+ */
+export declare function vModelForObjectProperty<T extends AnyObject, K extends keyof T>(object: T, key: K, onUpdate?: (newValue: T) => void): VModel<T[K]>;
+/**
+ * This creates a `v-model` which operates on one property of a parent `v-model`. It takes the value of
+ * the property as the value of the `v-model` and calls the function `onUpdateValue` of the parent `v-model`
+ * whenever the property changes. This function can be seen as a kind of mapper for a `v-model`.
+ * @param vModel The parent `v-model`, which this function extracts a single property from.
+ * @param key The key of the relevant property.
+ * @returns An object of type {@link VModel}.
+ * @example
+ * ```tsx
+ * type Customer = { firstName: string, lastName: String }
+ *
+ * // inside setup function,
+ * // This vModel would normally be inside the props of a component e.g., `CustomerEditor`.
+ * const parentVModel = {
+ *     value: { firstName: 'Hansi', lastName: 'Halunk' },
+ *     onUpdateValue: (newValue: Customer) => {
+ *         // update something
+ *     }
+ * }
+ *
+ * // This input needs a v-model for the `firstName` property.
+ * return () => (
+ *     <NInput
+ *         name="First Name"
+ *         {...vModelForVModelProperty(parentVModel, 'firstName'))}
+ *      />
+ * )
+ * ```
+ */
+export declare function vModelForVModelProperty<Model extends VModel<ModelValue>, Key extends keyof ModelValue, ModelValue extends AnyObject = Model['value']>(vModel: Model, key: Key): VModel<ModelValue[Key]>;
+/**
+ * This function does the same thing as {@link vModelForVModelProperty},
+ * but can be provided with a mapper function for the modified property.
+ * @see {@link vModelForVModelProperty}
+ * @example
+ * ```tsx
+ * type Customer = { firstName: string, lastName: String, type: 'admin' | 'user' }
+ *
+ * // inside setup function,
+ * // This vModel would normally be inside the props of a component e.g., `CustomerEditor`.
+ * const parentVModel = {
+ *     value: { firstName: 'Hansi', lastName: 'Halunk', type: 'user' },
+ *     onUpdateValue: (newValue: Customer) => {
+ *         // update something
+ *     }
+ * }
+ *
+ * // This input needs a v-model for the `type` property.
+ * // Unfortunately the NSelect input expects an `onUpdateValue` with a
+ * // parameter of type `string`, not type `admin | user`.
+ * // So we have to provide a mapper function from `string` to `admin | user`.
+ * // In this example, we just cast the value.
+ * return () => (
+ *     <NSelect
+ *         name="Type"
+ *         {...vModelForVModelPropertyMapType(parentVModel, 'type', newVal => newVal as 'admin' | 'user'))}
+ *      />
+ * )
+ * ```
+ */
+export declare function vModelForVModelPropertyMapType<Model extends VModel<ModelValue>, Key extends keyof ModelValue, UpdateValue, ModelValue extends AnyObject = Model['value']>(vModel: Model, key: Key, mapType: (value: UpdateValue) => ModelValue[Key]): VModel<ModelValue[Key], UpdateValue>;
+/**
+ * Creates an array of `v-models`, one for every element of an array. All changes in
+ * a `v-model` of any element, will call the `onUpdate` function, with the updated array.
+ * @param array The array to create `v-models` for.
+ * @param onUpdate The updater function, which is called whenever an element has changed.
+ * @returns An object of type {@link VModelForArray}.
+ * @example
+ * ```tsx
+ * // inside setup function
+ * const todos = ref([
+ *     'Create v-model helper functions.',
+ *     'Document them!'
+ * ])
+ *
+ * // For every todo, there should be an input to modifiy it.
+ * return () => (
+ *     <div>
+ *         {vModelsForArray(todos.value, newValue => (todos.value = newValue)).map(todoVModel => (
+ *            <NInput name="Todo" {...todoVModel} />
+ *         ))}
+ *     </div>
+ * )
+ * ```
+ */
+export declare function vModelsForArray<T>(array: T[], onUpdate?: (newValue: T[]) => void): VModelForArray<T>[];