@wssto2/vue-core 0.19.0 → 0.21.0

package/dist/characteristics/model.d.ts

@@ -0,0 +1,34 @@
+import type { TreeColumn, TreeNode } from "../collection";
+import type { DescriptionResponse, FieldResponse, ItemResponse, LabelResponse, LevelResponse } from "../modules/characteristics/entities";
+/** One item of the tree as the screen draws it. `id` is `"<level>:<id>"`: ids repeat from one level's table to the next. */
+export interface CharacteristicNode extends TreeNode<CharacteristicNode> {
+    readonly item: ItemResponse;
+    readonly level: number;
+    /** The items from the root down to this one's parent. */
+    readonly ancestors: readonly ItemResponse[];
+    readonly children?: readonly CharacteristicNode[];
+}
+export declare const keyOf: (level: number, id: number) => string;
+export declare const parseKey: (key: string | number) => {
+    level: number;
+    id: number;
+};
+/** A label in the administration's language: Croatian for the Croatian-family locales, English otherwise. */
+export declare const labelIn: (label: LabelResponse, locale: string) => string;
+/** The fields of `level` that apply to an item below `path` (the item's ancestors, and the item itself once it exists): a field with `under` is for one branch only. */
+export declare function fieldsFor(level: LevelResponse, path: readonly {
+    level: number;
+    id: number;
+}[]): readonly FieldResponse[];
+/** The tree of the flat, depth-first list the server sends: siblings by `order`, the described levels' extras on `item`. */
+export declare function buildTree(items: readonly ItemResponse[], description: DescriptionResponse): CharacteristicNode[];
+/** The columns of the list: every `in_list` field of every level, a column once however many branches describe it. */
+export declare function listColumns(description: DescriptionResponse, locale: string): {
+    column: TreeColumn<CharacteristicNode>;
+    fields: readonly {
+        level: LevelResponse;
+        field: FieldResponse;
+    }[];
+}[];
+/** A value as the list shows it: a choice by its label, a yes/no as words. */
+export declare function displayValue(field: FieldResponse, value: unknown, locale: string, yes: string, no: string): string;

package/dist/characteristics/routes.d.ts

@@ -0,0 +1,13 @@
+import type { RouteRecordRaw } from "vue-router";
+/**
+ * The route of `characteristicsFeature`: a typed target for links (`characteristicsPages.index`) and the record the feature installs.
+ * The name and path are fixed, so a link or a menu binding of the application can name them.
+ */
+export interface CharacteristicsPages {
+    /** The records `characteristicsFeature` installs. */
+    readonly records: readonly RouteRecordRaw[];
+    readonly index: {
+        readonly name: "characteristics.index";
+    };
+}
+export declare const characteristicsPages: CharacteristicsPages;

package/dist/collection/CollectionTree.vue.d.ts

@@ -0,0 +1,51 @@
+import type { RowAction } from "./columns";
+import { type TreeColumn, type TreeNode, type TreeReorder } from "./tree";
+declare const _default: <Node extends TreeNode<Node>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onToggle?: ((node: Node, active: boolean) => any) | undefined;
+        readonly onAdd?: ((parent: Node | null) => any) | undefined;
+        readonly onOpen?: ((node: Node) => any) | undefined;
+        readonly onReorder?: ((change: TreeReorder) => any) | undefined;
+        readonly "onUpdate:expanded"?: ((value: readonly (string | number)[]) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onToggle" | "onAdd" | "onOpen" | "onReorder" | "onUpdate:expanded"> & ({
+        nodes: readonly Node[];
+        columns?: readonly TreeColumn<Node>[];
+        /** The accessible name of the tree. */
+        label: string;
+        reorderable?: boolean;
+        readonly?: boolean;
+        search?: string;
+        /** Rows to leave out, besides the search's. */
+        filter?: (node: Node) => boolean;
+        activeLabel?: string;
+        addLabel?: (parent: Node | null, level: number) => string | null;
+        rowActions?: (node: Node, depth: number) => RowAction[];
+        /** The header of the name column. */
+        nameLabel?: string;
+    } & {
+        /** The ids of the open groups. */
+        expanded?: readonly (string | number)[];
+    }) & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        [name: `cell-${string}`]: (scope: {
+            node: Node;
+            depth: number;
+        }) => unknown;
+        /** A row's icon; by default a folder for a group and a tag for an item. */
+        icon?: (scope: {
+            node: Node;
+            depth: number;
+        }) => unknown;
+        /** What shows when there are no rows. */
+        empty?: () => unknown;
+    };
+    emit: (((evt: "toggle", node: Node, active: boolean) => void) & ((evt: "add", parent: Node | null) => void) & ((evt: "open", node: Node) => void) & ((evt: "reorder", change: TreeReorder) => void)) & ((evt: "update:expanded", value: readonly (string | number)[]) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/collection/CollectionTreeBranch.vue.d.ts

@@ -0,0 +1,12 @@
+import { type LooseNode } from "./tree";
+/**
+ * The children of one parent (internal to `CollectionTree`): a sortable list of rows, each with its own branch below it while it is open,
+ * and the "add" row at the end of an open branch. Rows can only be reordered among their siblings because each branch is its own list.
+ */
+type __VLS_Props = {
+    nodes: readonly LooseNode[];
+    parent: LooseNode | null;
+    depth: number;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/collection/FileExplorer.vue.d.ts

@@ -0,0 +1,53 @@
+import type { PageAction } from "../page/types";
+import { type Column, type RowAction } from "./columns";
+import type { ExplorerCrumb, ExplorerRow } from "./explorer";
+import type { CellSlots } from "./slots";
+declare const _default: <Row extends ExplorerRow, const Col extends Column<Row, never>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onOpen?: ((row: Row) => any) | undefined;
+        readonly "onUpdate:selected"?: ((value: readonly (string | number)[]) => any) | undefined;
+        readonly "onUpdate:folder"?: ((value: string | null) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onOpen" | "onUpdate:selected" | "onUpdate:folder"> & ({
+        rows: readonly Row[];
+        columns: readonly Col[];
+        /** The accessible name of the table ("Pages and directories"). */
+        label: string;
+        /** Root first, the open folder last. Without it no breadcrumb shows. */
+        breadcrumb?: readonly ExplorerCrumb[];
+        loading?: boolean;
+        /** The row's menu: More at its end. */
+        rowActions?: (row: Row) => RowAction[];
+        /** The bar of buttons over the ticked rows. */
+        selectionActions?: (rows: readonly Row[]) => readonly PageAction[];
+        /** The query parameter that holds the open folder; `null` keeps the folder out of the URL. */
+        param?: string | null;
+        /** The header of the name column. */
+        nameLabel?: string;
+    } & {
+        /** The ids of the ticked rows. */
+        selected?: readonly (string | number)[];
+        /** The id of the open folder, `null` at the root. */
+        folder?: string | null;
+    }) & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: CellSlots<Row, Col> & {
+        /** Before the breadcrumb: the host picker. */
+        switch?: () => unknown;
+        /** The page's own buttons at the end of the header (upload, new folder, New). */
+        toolbar?: () => unknown;
+        /** A row's icon; by default the kind's. */
+        icon?: (scope: {
+            item: Row;
+        }) => unknown;
+        /** What an empty folder shows. */
+        empty?: () => unknown;
+    };
+    emit: ((evt: "open", row: Row) => void) & (((evt: "update:selected", value: readonly (string | number)[]) => void) & ((evt: "update:folder", value: string | null) => void));
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/collection/RowMore.vue.d.ts

@@ -0,0 +1,11 @@
+import type { RowAction } from "./columns";
+/**
+ * The More button of a row and the menu of its actions, for the explorer and the tree (internal). A row without actions shows nothing.
+ * `label` names the row ("More actions: Kontakt"), so the buttons of a list are told apart.
+ */
+type __VLS_Props = {
+    actions: readonly RowAction[];
+    label: string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/collection/explorer.d.ts

@@ -0,0 +1,11 @@
+/** What a `FileExplorer` row is: a folder, a page, a link or a file; the app's rows carry whatever else the columns show. */
+export interface ExplorerRow {
+    readonly id: string | number;
+    readonly kind: "folder" | "page" | "link" | "file";
+    readonly name: string;
+}
+/** One step of a `FileExplorer` breadcrumb: the folder's id (`null`: the root) and its name. */
+export interface ExplorerCrumb {
+    readonly id: string | null;
+    readonly label: string;
+}

package/dist/collection/index.d.ts

@@ -29,3 +29,8 @@ export { createPicker } from "./picker";
 export type { Picker, PickerOptions } from "./picker";
 export { default as PickerModal } from "./PickerModal.vue";
 export { default as DynamicCollection } from "./DynamicCollection.vue";
+export { default as FileExplorer } from "./FileExplorer.vue";
+export type { ExplorerCrumb, ExplorerRow } from "./explorer";
+export { default as CollectionTree } from "./CollectionTree.vue";
+export { matchesText, visibleNodes } from "./tree";
+export type { TreeColumn, TreeNode, TreeReorder } from "./tree";