@speckle/ui-components 2.16.0 → 2.16.1-alpha10

package/dist/components/form/select/SourceApps.vue.d.ts

@@ -56,6 +56,12 @@ declare const _default: import("vue").DefineComponent<{
         type: PropType<Optional<SourceAppDefinition[]>>;
         default: undefined;
     };
+    clearable: {
+        type: BooleanConstructor;
+    };
+    help: {
+        type: StringConstructor;
+    };
 }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:modelValue": (v: ValueType) => void;
 }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
@@ -113,6 +119,12 @@ declare const _default: import("vue").DefineComponent<{
         type: PropType<Optional<SourceAppDefinition[]>>;
         default: undefined;
     };
+    clearable: {
+        type: BooleanConstructor;
+    };
+    help: {
+        type: StringConstructor;
+    };
 }>> & {
     "onUpdate:modelValue"?: ((v: ValueType) => any) | undefined;
 }, {
@@ -121,6 +133,7 @@ declare const _default: import("vue").DefineComponent<{
     modelValue: ValueType;
     multiple: boolean;
     showLabel: boolean;
+    clearable: boolean;
     items: Optional<SourceAppDefinition[]>;
     searchPlaceholder: string;
     selectorPlaceholder: Optional<string>;

package/dist/components/form/tags/ContextManager.vue.d.ts

@@ -0,0 +1,16 @@
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{}, {
+    goUp: () => void;
+    goDown: () => void;
+    open: () => void;
+    close: () => void;
+    selectActive: () => void;
+    isOpen: () => boolean;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/layout/Table.vue.d.ts

@@ -0,0 +1,68 @@
+import { ConcreteComponent } from 'vue';
+export type TableColumn<I> = {
+    id: I;
+    header: string;
+    classes: string;
+};
+export interface RowButton<T = unknown> {
+    icon: ConcreteComponent;
+    label: string;
+    action: (item: T) => void;
+    class: string;
+}
+declare const _default: <T extends {
+    id: string;
+}, C extends string>(__VLS_props: {
+    items: T[];
+    buttons?: RowButton<T>[] | undefined;
+    columns: TableColumn<C>[];
+    overflowCells?: boolean | undefined;
+    onRowClick?: ((item: T) => void) | undefined;
+} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, __VLS_ctx?: Pick<{
+    props: {
+        items: T[];
+        buttons?: RowButton<T>[] | undefined;
+        columns: TableColumn<C>[];
+        overflowCells?: boolean | undefined;
+        onRowClick?: ((item: T) => void) | undefined;
+    };
+    expose(exposed: {}): void;
+    attrs: any;
+    slots: Partial<Record<NonNullable<C>, (_: {
+        item: T;
+    }) => any>>;
+    emit: any;
+}, "attrs" | "slots" | "emit"> | undefined, __VLS_setup?: Promise<{
+    props: {
+        items: T[];
+        buttons?: RowButton<T>[] | undefined;
+        columns: TableColumn<C>[];
+        overflowCells?: boolean | undefined;
+        onRowClick?: ((item: T) => void) | undefined;
+    };
+    expose(exposed: {}): void;
+    attrs: any;
+    slots: Partial<Record<NonNullable<C>, (_: {
+        item: T;
+    }) => any>>;
+    emit: any;
+}>) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> & {
+    __ctx?: {
+        props: {
+            items: T[];
+            buttons?: RowButton<T>[] | undefined;
+            columns: TableColumn<C>[];
+            overflowCells?: boolean | undefined;
+            onRowClick?: ((item: T) => void) | undefined;
+        };
+        expose(exposed: {}): void;
+        attrs: any;
+        slots: Partial<Record<NonNullable<C>, (_: {
+            item: T;
+        }) => any>>;
+        emit: any;
+    } | undefined;
+};
+export default _default;

package/dist/components/user/Avatar.vue.d.ts

@@ -0,0 +1,59 @@
+import { AvatarUser, UserAvatarSize } from '../../composables/user/avatar';
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
+    size: {
+        type: import("vue").PropType<UserAvatarSize>;
+        default: string;
+    };
+    active: {
+        type: import("vue").PropType<boolean>;
+    };
+    user: {
+        type: import("vue").PropType<AvatarUser | null>;
+        default: null;
+    };
+    hoverEffect: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    noBorder: {
+        type: import("vue").PropType<boolean>;
+    };
+    noBg: {
+        type: import("vue").PropType<boolean>;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    size: {
+        type: import("vue").PropType<UserAvatarSize>;
+        default: string;
+    };
+    active: {
+        type: import("vue").PropType<boolean>;
+    };
+    user: {
+        type: import("vue").PropType<AvatarUser | null>;
+        default: null;
+    };
+    hoverEffect: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    noBorder: {
+        type: import("vue").PropType<boolean>;
+    };
+    noBg: {
+        type: import("vue").PropType<boolean>;
+    };
+}>>, {
+    size: UserAvatarSize;
+    user: AvatarUser | null;
+    hoverEffect: boolean;
+}, {}>, {
+    default?(_: {}): any;
+    "absolute-anchor"?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/user/AvatarEditable.vue.d.ts

@@ -0,0 +1,67 @@
+import { MaybeNullOrUndefined } from '@speckle/shared';
+type ModelType = MaybeNullOrUndefined<string>;
+declare const _default: import("vue").DefineComponent<{
+    editMode: import("vue").PropType<boolean>;
+    modelValue: {
+        type: import("vue").PropType<string | null>;
+    };
+    placeholder: {
+        type: import("vue").PropType<string>;
+        required: true;
+    };
+    name: {
+        type: import("vue").PropType<string>;
+        required: true;
+    };
+    rules: {
+        type: import("vue").PropType<string | Record<string, unknown> | import("vee-validate").GenericValidateFunction<ModelType> | import("vee-validate").GenericValidateFunction<ModelType>[] | {
+            validate(value: ModelType, options: Record<string, any>): Promise<ModelType>;
+        }>;
+    };
+    validateOnMount: {
+        type: import("vue").PropType<boolean>;
+    };
+    validateOnValueUpdate: {
+        type: import("vue").PropType<boolean>;
+    };
+    disabled: {
+        type: import("vue").PropType<boolean>;
+    };
+}, {
+    open: () => boolean;
+    close: () => boolean;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    save: (newUrl: ModelType) => void;
+    "update:modelValue": (value: ModelType) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    editMode: import("vue").PropType<boolean>;
+    modelValue: {
+        type: import("vue").PropType<string | null>;
+    };
+    placeholder: {
+        type: import("vue").PropType<string>;
+        required: true;
+    };
+    name: {
+        type: import("vue").PropType<string>;
+        required: true;
+    };
+    rules: {
+        type: import("vue").PropType<string | Record<string, unknown> | import("vee-validate").GenericValidateFunction<ModelType> | import("vee-validate").GenericValidateFunction<ModelType>[] | {
+            validate(value: ModelType, options: Record<string, any>): Promise<ModelType>;
+        }>;
+    };
+    validateOnMount: {
+        type: import("vue").PropType<boolean>;
+    };
+    validateOnValueUpdate: {
+        type: import("vue").PropType<boolean>;
+    };
+    disabled: {
+        type: import("vue").PropType<boolean>;
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((value: ModelType) => any) | undefined;
+    onSave?: ((newUrl: ModelType) => any) | undefined;
+}, {}, {}>;
+export default _default;

package/dist/components/user/AvatarEditor.vue.d.ts

@@ -0,0 +1,26 @@
+import { Nullable } from '@speckle/shared';
+import { AvatarUser } from '../../composables/user/avatar';
+declare const _default: import("vue").DefineComponent<{
+    user: {
+        type: import("vue").PropType<AvatarUser>;
+        required: true;
+    };
+    disabled: {
+        type: import("vue").PropType<boolean>;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    cancel: () => void;
+    save: (val: Nullable<string>) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    user: {
+        type: import("vue").PropType<AvatarUser>;
+        required: true;
+    };
+    disabled: {
+        type: import("vue").PropType<boolean>;
+    };
+}>> & {
+    onCancel?: (() => any) | undefined;
+    onSave?: ((val: Nullable<string>) => any) | undefined;
+}, {}, {}>;
+export default _default;

package/dist/components/user/AvatarGroup.vue.d.ts

@@ -0,0 +1,44 @@
+import { UserAvatarSize, AvatarUserWithId } from '../../composables/user/avatar';
+declare const _default: import("vue").DefineComponent<{
+    size: {
+        type: import("vue").PropType<UserAvatarSize>;
+        default: string;
+    };
+    users: {
+        type: import("vue").PropType<AvatarUserWithId[]>;
+        required: true;
+        default: () => never[];
+    };
+    overlap: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    maxCount: {
+        type: import("vue").PropType<number>;
+        default: undefined;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    size: {
+        type: import("vue").PropType<UserAvatarSize>;
+        default: string;
+    };
+    users: {
+        type: import("vue").PropType<AvatarUserWithId[]>;
+        required: true;
+        default: () => never[];
+    };
+    overlap: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    maxCount: {
+        type: import("vue").PropType<number>;
+        default: undefined;
+    };
+}>>, {
+    size: UserAvatarSize;
+    users: AvatarUserWithId[];
+    overlap: boolean;
+    maxCount: number;
+}, {}>;
+export default _default;

package/dist/composables/form/fileUpload.d.ts

@@ -0,0 +1,63 @@
+import { MaybeRef } from '@vueuse/core';
+import { MaybeNullOrUndefined, Nullable, Optional } from '@speckle/shared';
+import { CSSProperties } from 'vue';
+/**
+ * A file, as emitted out from FileUploadZone
+ */
+export interface UploadableFileItem {
+    file: File;
+    error: Nullable<Error>;
+    /**
+     * You can use this ID to check for File equality
+     */
+    id: string;
+}
+export declare enum BlobUploadStatus {
+    Success = 1,
+    Failure = 2
+}
+export type BlobPostResultItem = {
+    blobId?: string;
+    fileName?: string;
+    fileSize?: number;
+    formKey: string;
+    /**
+     * Success = 1, Failure = 2
+     */
+    uploadStatus: number;
+    uploadError: string;
+};
+export interface UploadFileItem extends UploadableFileItem {
+    /**
+     * Progress between 0 and 100
+     */
+    progress: number;
+    /**
+     * When upload has finished this contains a BlobPostResultItem
+     */
+    result: Optional<BlobPostResultItem>;
+    /**
+     * When a blob gets assigned to a resource, it should count as in use, and this will
+     * prevent it from being deleted as junk
+     */
+    inUse?: boolean;
+}
+export declare function usePrepareUploadableFiles(params: {
+    disabled?: MaybeRef<Optional<boolean>>;
+    accept?: MaybeRef<Optional<string>>;
+    multiple?: MaybeRef<Optional<boolean>>;
+    countLimit?: MaybeRef<Optional<number>>;
+    sizeLimit: MaybeRef<number>;
+}): {
+    /**
+     * Validate incoming files and build UploadableFileItem structs out of them
+     */
+    buildUploadableFiles: (files: File[]) => UploadableFileItem[] | undefined;
+};
+export declare function useFileUploadProgressCore(params: {
+    item: MaybeRef<MaybeNullOrUndefined<UploadFileItem>>;
+}): {
+    errorMessage: import("vue").ComputedRef<string | null>;
+    progressBarClasses: import("vue").ComputedRef<string>;
+    progressBarStyle: import("vue").ComputedRef<CSSProperties>;
+};

package/dist/composables/form/textInput.d.ts

@@ -5,16 +5,16 @@ export type InputColor = 'page' | 'foundation';
 /**
  * Common setup for text input & textarea fields
  */
-export declare function useTextInputCore(params: {
+export declare function useTextInputCore<V extends string | string[] = string>(params: {
     props: ToRefs<{
         name: string;
         help?: string;
         label?: string;
         showLabel?: boolean;
-        rules?: RuleExpression<string>;
+        rules?: RuleExpression<V>;
         validateOnMount?: boolean;
         validateOnValueUpdate?: boolean;
-        modelValue?: string;
+        modelValue?: V;
         autoFocus?: boolean;
         showClear?: boolean;
         useLabelInErrors?: boolean;
@@ -24,15 +24,19 @@ export declare function useTextInputCore(params: {
     emit: {
         (e: 'change', val: {
             event?: Event;
-            value: string;
+            value: V;
         }): void;
         (e: 'clear'): void;
     };
     inputEl: Ref<Nullable<HTMLInputElement | HTMLTextAreaElement>>;
+    options?: Partial<{
+        customClear: () => void;
+    }>;
 }): {
+    coreInputClasses: import("vue").ComputedRef<string>;
     coreClasses: import("vue").ComputedRef<string>;
     title: import("vue").ComputedRef<string>;
-    value: Ref<string>;
+    value: Ref<V>;
     helpTipId: import("vue").ComputedRef<string | undefined>;
     helpTipClasses: import("vue").ComputedRef<string>;
     helpTip: import("vue").ComputedRef<string | undefined>;

package/dist/composables/user/avatar.d.ts

@@ -0,0 +1,19 @@
+import { ToRefs } from 'vue';
+export type AvatarUser = {
+    name: string;
+    avatar?: string | null;
+};
+export type AvatarUserWithId = AvatarUser & {
+    id: string;
+};
+export type UserAvatarSize = 'xs' | 'sm' | 'base' | 'lg' | 'xl' | 'editable';
+export declare function useAvatarSizeClasses(params: {
+    props: ToRefs<{
+        size?: UserAvatarSize;
+    }>;
+}): {
+    heightClasses: import("vue").ComputedRef<"h-6" | "h-10" | "h-14" | "h-8" | "h-5" | "h-60">;
+    widthClasses: import("vue").ComputedRef<"w-5" | "w-6" | "w-10" | "w-14" | "w-60" | "w-8">;
+    sizeClasses: import("vue").ComputedRef<string>;
+    iconClasses: import("vue").ComputedRef<"w-5 h-5" | "w-3 h-3" | "w-8 h-8" | "w-20 h-20" | "w-4 h-4">;
+};

package/dist/helpers/common/error.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Base ObjectLoader error
+ */
+export declare abstract class BaseError extends Error {
+    /**
+     * Default message if none is passed
+     */
+    static defaultMessage: string;
+    constructor(message?: string, options?: ErrorOptions);
+}
+/**
+ * Throw these in execution branches that should never occur unless if there's a bug
+ */
+export declare class LogicError extends BaseError {
+    static defaultMessage: string;
+}
+export declare class UninitializedResourceAccessError extends BaseError {
+    static defaultMessage: string;
+}
+export declare class ComposableInvokedOutOfScopeError extends BaseError {
+    static defaultMessage: string;
+}
+/**
+ * Throw this when something that's only supported during CSR is invoked during SSR or vice versa
+ */
+export declare class UnsupportedEnvironmentError extends BaseError {
+    static defaultMessage: string;
+}

package/dist/helpers/common/validation.d.ts

@@ -21,3 +21,5 @@ export declare const stringContains: (params: {
     match: string | RegExp;
     message: string;
 }) => GenericValidateFunction<string>;
+export declare const isUrl: GenericValidateFunction<string>;
+export declare const isItemSelected: GenericValidateFunction<unknown[]>;

package/dist/helpers/form/file.d.ts

@@ -0,0 +1,41 @@
+import { Nullable } from '@speckle/shared';
+import { BaseError } from '../../helpers/common/error';
+export type FileTypeSpecifier = UniqueFileTypeSpecifier | `.${string}`;
+export declare enum UniqueFileTypeSpecifier {
+    AnyAudio = "audio/*",
+    AnyVideo = "video/*",
+    AnyImage = "image/*"
+}
+/**
+ * Validate if file has the allowed type. While we could also test for MIME types
+ * not in UniqueFileTypeSpecifier, this function is meant to be equivalent to the
+ * 'accept' attribute, which only allows for extensions or UniqueFileTypeSpecifier
+ * values.
+ * @param file
+ * @param allowedTypes The file must have one of these types
+ * @returns True if valid, Error object if not
+ */
+export declare function validateFileType(file: File, allowedTypes: FileTypeSpecifier[]): true | Error;
+/**
+ * Resolve file extension (with leading dot)
+ */
+export declare function resolveFileExtension(fileName: string): Nullable<FileTypeSpecifier>;
+/**
+ * Check if string is a FileTypeSpecifier
+ */
+export declare function isFileTypeSpecifier(type: string): type is FileTypeSpecifier;
+/**
+ * Create a human readable file size string from the numeric size in bytes
+ */
+export declare function prettyFileSize(sizeInBytes: number): string;
+/**
+ * Generate an ID that uniquely identifies a specific file. The same file
+ * will always have the same ID.
+ */
+export declare function generateFileId(file: File): string;
+export declare class MissingFileExtensionError extends BaseError {
+    static defaultMessage: string;
+}
+export declare class ForbiddenFileTypeError extends BaseError {
+    static defaultMessage: string;
+}