quasar-ui-danx 0.4.27 → 0.4.29

package/src/types/actions.d.ts

@@ -1,24 +1,27 @@
+import { FilterGroup, ListController, ListControlsRoutes } from "src/types/controls";
+import { FormField } from "src/types/forms";
+import { TableColumn } from "src/types/tables";
 import { VNode } from "vue";
-import { TypedObject } from "./shared";
-
-export interface ActionPanel {
-	name: string | number;
-	label: string;
-	category?: string;
-	class?: string | object;
-	enabled?: boolean | ((activeItem: ActionTargetItem) => boolean);
-	tabVnode?: (activeItem: ActionTargetItem | null | undefined, activePanel: string | number) => VNode | any;
-	vnode: (activeItem: ActionTargetItem | null | undefined) => VNode | any;
-}
+import { AnyObject, ComputedRef, TypedObject } from "./shared";
 
 export interface ActionTargetItem extends TypedObject {
 	isSaving?: boolean;
 	updated_at?: string;
 }
 
-export type ActionTarget = ActionTargetItem[] | ActionTargetItem | null;
+export type ActionTarget<T = ActionTargetItem> = T[] | T | null;
+
+export interface ActionPanel<T = ActionTargetItem> {
+	name: string | number;
+	label: string;
+	category?: string;
+	class?: string | object;
+	enabled?: boolean | ((target: T) => boolean);
+	tabVnode?: (target: T | null | undefined, activePanel: string | number) => VNode | any;
+	vnode: (target: T | null | undefined) => VNode | any;
+}
 
-export interface ActionOptions {
+export interface ActionOptions<T = ActionTargetItem> {
 	name: string;
 	alias?: string;
 	label?: string;
@@ -29,21 +32,42 @@ export interface ActionOptions {
 	category?: string;
 	class?: string;
 	debounce?: number;
-	optimistic?: boolean | ((action: ActionOptions, target: ActionTargetItem | null, input: any) => void);
-	vnode?: ((target: ActionTarget) => VNode) | any;
-	enabled?: (target: object) => boolean;
-	batchEnabled?: (targets: object[]) => boolean;
-	onAction?: (action: string | null | undefined, target: ActionTargetItem | null, input: any) => Promise<any> | void;
-	onBatchAction?: (action: string | null | undefined, targets: ActionTargetItem[], input: any) => Promise<any>;
-	onStart?: (action: ActionOptions | null, targets: ActionTarget, input: any) => boolean;
-	onSuccess?: (result: any, targets: ActionTarget, input: any) => any;
-	onBatchSuccess?: (result: any, targets: ActionTargetItem[], input: any) => any;
-	onError?: (result: any, targets: ActionTarget, input: any) => any;
-	onFinish?: (result: any, targets: ActionTarget, input: any) => any;
+	optimistic?: boolean | ((action: ActionOptions<T>, target: T | null, input: any) => void);
+	vnode?: (target: ActionTarget<T>, data: any) => VNode | any;
+	enabled?: (target: ActionTarget<T>) => boolean;
+	batchEnabled?: (targets: T[]) => boolean;
+	onAction?: (action: string | ResourceAction<T> | ActionOptions<T>, target: T | null, input?: AnyObject | any) => Promise<AnyObject | any> | void;
+	onBatchAction?: (action: string | ResourceAction<T> | ActionOptions<T>, targets: T[], input: any) => Promise<AnyObject | any> | void;
+	onStart?: (action: ActionOptions<T> | null, targets: ActionTarget<T>, input: any) => boolean;
+	onSuccess?: (result: any, targets: ActionTarget<T>, input: any) => any;
+	onBatchSuccess?: (result: any, targets: T[], input: any) => any;
+	onError?: (result: any, targets: ActionTarget<T>, input: any) => any;
+	onFinish?: (result: any, targets: ActionTarget<T>, input: any) => any;
 }
 
-export interface ResourceAction extends ActionOptions {
+export interface ActionGlobalOptions extends Partial<ActionOptions> {
+	routes?: ListControlsRoutes;
+	controls?: ListController;
+}
+
+export interface ResourceAction<T = ActionTargetItem> extends ActionOptions<T> {
 	isApplying: boolean;
-	trigger: (target?: ActionTarget, input?: any) => Promise<any>;
+	trigger: (target?: ActionTarget<T>, input?: any) => Promise<any>;
 	__type: string;
 }
+
+export interface ActionController<T = ActionTargetItem> {
+	// Actions
+	action?: (actionName: string, target?: T | null, input?: any) => Promise<any | void>;
+	getAction?: (actionName: string, actionOptions?: Partial<ActionOptions>) => ResourceAction;
+	getActions?: (names?: string[]) => ResourceAction[];
+	extendAction?: (actionName: string, extendedId: string | number, actionOptions: Partial<ActionOptions>) => ResourceAction;
+	modifyAction?: (actionName: string, actionOptions: Partial<ActionOptions>) => ResourceAction;
+	batchActions?: ResourceAction[];
+	menuActions?: ResourceAction[];
+	columns?: TableColumn[];
+	filters?: ComputedRef<FilterGroup[]>;
+	fields?: FormField[];
+	panels?: ActionPanel[];
+	routes?: ListControlsRoutes;
+}

package/src/types/controls.d.ts

@@ -1,6 +1,5 @@
-import { ComputedRef, Ref, ShallowRef } from "vue";
-import { ActionTargetItem } from "./actions";
-import { AnyObject, LabelValueItem } from "./shared";
+import { ActionOptions, ActionTargetItem, ResourceAction } from "./actions";
+import { AnyObject, ComputedRef, LabelValueItem, Ref } from "./shared";
 
 export interface ListControlsFilter {
 	[key: string]: object | object[] | null | undefined | string | number | boolean;
@@ -20,25 +19,24 @@ export interface FilterGroup {
 	fields: FilterableField[];
 }
 
-
-export interface ListControlsRoutes {
-	list(pager?: ListControlsPagination): Promise<ActionTargetItem[]>;
+export interface ListControlsRoutes<T = ActionTargetItem> {
+	list(pager?: ListControlsPagination): Promise<T[]>;
 
 	summary?(filter?: ListControlsFilter): Promise<AnyObject>;
 
-	details?(target: ActionTargetItem): Promise<ActionTargetItem>;
+	details?(target: T): Promise<T>;
 
-	detailsAndStore?(target: ActionTargetItem): Promise<ActionTargetItem>;
+	detailsAndStore?(target: T): Promise<T>;
 
-	relation?(target: ActionTargetItem, relation: string): Promise<ActionTargetItem>;
+	relation?(target: T, relation: string): Promise<T>;
 
-	more?(pager: ListControlsPagination): Promise<ActionTargetItem[]>;
+	more?(pager: ListControlsPagination): Promise<T[]>;
 
 	fieldOptions?(filter?: AnyObject): Promise<AnyObject>;
 
-	applyAction?(action: string, target: ActionTargetItem | null, data?: object): Promise<AnyObject>;
+	applyAction?(action: string | ResourceAction | ActionOptions, target: T | null, data?: object): Promise<AnyObject>;
 
-	batchAction?(action: string, targets: ActionTargetItem[], data: object): Promise<AnyObject>;
+	batchAction?(action: string | ResourceAction | ActionOptions, targets: T[], data: object): Promise<AnyObject>;
 
 	export?(filter?: ListControlsFilter, name?: string): Promise<void>;
 }
@@ -62,24 +60,24 @@ export interface ListControlsPagination {
 	filter?: ListControlsFilter;
 }
 
-export interface PagedItems {
-	data: ActionTargetItem[] | undefined;
+export interface PagedItems<T = ActionTargetItem> {
+	data: T[] | undefined;
 	meta: {
 		total: number;
 		last_page?: number;
 	} | undefined;
 }
 
-export interface ActionController {
+export interface ListController<T = ActionTargetItem> {
 	name: string;
 	label: string;
-	pagedItems: Ref<PagedItems | null>;
+	pagedItems: Ref<PagedItems<T> | null>;
 	activeFilter: Ref<ListControlsFilter>;
 	globalFilter: Ref<ListControlsFilter>;
 	filterActiveCount: ComputedRef<number>;
 	showFilters: Ref<boolean>;
-	summary: ShallowRef<object | null>;
-	selectedRows: ShallowRef<ActionTargetItem[]>;
+	summary: Ref<object | null>;
+	selectedRows: Ref<T[]>;
 	isLoadingList: Ref<boolean>;
 	isLoadingFilters: Ref<boolean>;
 	isLoadingSummary: Ref<boolean>;
@@ -89,15 +87,15 @@ export interface ActionController {
 		filter: ListControlsFilter;
 		sort: object[] | undefined;
 	}>;
-	pagination: ShallowRef<ListControlsPagination>;
-	activeItem: ShallowRef<ActionTargetItem | null>;
-	activePanel: ShallowRef<string | null>;
+	pagination: Ref<ListControlsPagination>;
+	activeItem: Ref<T | null>;
+	activePanel: Ref<string | null>;
 
-	// Actions
+	// List Controls
 	initialize: () => void;
 	resetPaging: () => void;
 	setPagination: (updated: Partial<ListControlsPagination>) => void;
-	setSelectedRows: (selection: ActionTargetItem[]) => void;
+	setSelectedRows: (selection: T[]) => void;
 	clearSelectedRows: () => void;
 	loadList: (filter?: ListControlsFilter) => Promise<void>;
 	loadSummary: (filter?: ListControlsFilter) => Promise<void>;
@@ -107,9 +105,9 @@ export interface ActionController {
 	getActiveItemDetails: () => Promise<void>;
 	refreshAll: () => Promise<void[]>;
 	exportList: (filter?: ListControlsFilter) => Promise<void>;
-	setActiveItem: (item: ActionTargetItem | null) => void;
+	setActiveItem: (item: T | null) => void;
 	getNextItem: (offset: number) => Promise<void>;
-	activatePanel: (item: ActionTargetItem | null, panel: string) => void;
+	activatePanel: (item: T | null, panel: string) => void;
 	setActiveFilter: (filter?: ListControlsFilter) => void;
 	applyFilterFromUrl: (url: string, filters?: Ref<FilterGroup[]> | null) => void;
 	getFieldOptions: (field: string) => any[];

package/src/types/fields.d.ts

@@ -12,6 +12,7 @@ export interface TextFieldProps {
 	inputClass?: string | object;
 	allowOverMax?: boolean;
 	maxLength?: number;
+	rows?: number;
 	autogrow?: boolean;
 	noLabel?: boolean;
 	showName?: boolean;

package/src/types/files.d.ts

@@ -3,7 +3,7 @@ import { AnyObject, TypedObject } from "src/types/shared";
 export interface FileUploadOptions {
 	directory?: string,
 	createPresignedUpload?: ((path: string, name: string, mime?: string) => Promise<UploadedFile>) | null;
-	completePresignedUpload?: ((fileId: string) => Promise<UploadedFile>) | null;
+	completePresignedUpload?: ((fileId: string, file: XHRFileUpload) => Promise<UploadedFile>) | null;
 	refreshFile?: ((fileId: string) => Promise<UploadedFile>) | null;
 }
 
@@ -25,7 +25,7 @@ export interface UploadedFile extends TypedObject {
 	mimeType?: string;
 	mime?: string;
 	progress?: number;
-	location?: string;
+	location?: string | Partial<GeolocationCoordinates> | null;
 	blobUrl?: string;
 	url?: string;
 	thumb?: UploadedFile;

package/src/types/index.d.ts

@@ -1,3 +1,6 @@
+import { ActionController, ActionTargetItem } from "./actions";
+import { ListController } from "./controls";
+
 export * from "./actions";
 export * from "./config";
 export * from "./controls";
@@ -9,3 +12,5 @@ export * from "./forms";
 export * from "./requests";
 export * from "./shared";
 export * from "./tables";
+
+export type DanxController<T = ActionTargetItem> = ActionController<T> & ListController<T>;

package/src/types/shared.d.ts

@@ -14,3 +14,12 @@ export interface LabelValueItem {
 	label: string;
 	value: string | number | boolean;
 }
+
+/** Define Vue 3 Types here for better type checking in PHPStorm */
+export interface Ref<T = any> {
+	value: T;
+}
+
+export interface ComputedRef<T = any> {
+	readonly value: T;
+}

package/src/types/tables.d.ts

@@ -1,8 +1,8 @@
 import { VNode } from "vue";
-import { ActionOptions } from "./actions";
+import { ActionOptions, ActionTargetItem } from "./actions";
 
-export interface TableColumn {
-	actionMenu?: ActionOptions[];
+export interface TableColumn<T = ActionTargetItem> {
+	actionMenu?: ActionOptions<T>[];
 	align?: string;
 	category?: string;
 	class?: string | object;

package/types/vue-shims.d.ts

@@ -1,4 +1,5 @@
 declare module "*.vue" {
-    import Vue from 'vue';
-    export default Vue;
+    import type { DefineComponent } from "vue";
+    const component: DefineComponent<object, object, any>;
+	export default component;
 }