@wssto2/vue-core 0.19.0 → 0.21.0

package/dist/collection/tree.d.ts

@@ -0,0 +1,64 @@
+import type { InjectionKey } from "vue";
+import type { RowAction } from "./columns";
+/** What a `CollectionTree` node is: its id, its name, its children, and whether it is switched on (`undefined`: it has no switch). */
+export interface TreeNode<Node> {
+    readonly id: string | number;
+    readonly label: string;
+    readonly active?: boolean;
+    readonly children?: readonly Node[];
+}
+/**
+ * A column besides the name. `visible` says where it applies: a column that belongs to one branch ("Kod marke" under Marke) is blank on
+ * every other row. The header always shows, so the columns do not jump when a branch opens.
+ */
+export interface TreeColumn<Node> {
+    readonly key: string;
+    readonly label: string;
+    /** Pixels. */
+    readonly width?: number;
+    readonly align?: "start" | "center" | "end";
+    /** `depth` is 0 for the roots. Default: every row. */
+    readonly visible?: (node: Node, depth: number) => boolean;
+}
+/** What `@reorder` says: the node, the parent it stays in (`null`: a root) and where it lands among that parent's children, counted from 0. */
+export interface TreeReorder {
+    readonly id: string | number;
+    readonly parentId: string | number | null;
+    readonly index: number;
+}
+/**
+ * The nodes a search or filter leaves on screen: those that match, and every ancestor of one (a match is never shown without its
+ * path). `forced` is the ancestors, which show open while the search lasts.
+ */
+export declare function visibleNodes<Node extends TreeNode<Node>>(nodes: readonly Node[], matches: (node: Node) => boolean): {
+    shown: Set<string | number>;
+    forced: Set<string | number>;
+};
+/** Whether a node's name contains the text, ignoring case and accents. */
+export declare const matchesText: (label: string, text: string) => boolean;
+/** A node as the branches see it: the typed node of the app, loosely (internal). */
+export interface LooseNode extends TreeNode<LooseNode> {
+    readonly [key: string]: unknown;
+}
+/** What `CollectionTree` hands its branches (internal): one object, so the recursion does not repeat a dozen props. */
+export interface TreeContext {
+    columns: readonly TreeColumn<LooseNode>[];
+    readonly: boolean;
+    reorderable: boolean;
+    search: string;
+    activeLabel: string | undefined;
+    isOpen(node: LooseNode): boolean;
+    isShown(node: LooseNode): boolean;
+    toggle(node: LooseNode): void;
+    addLabel(parent: LooseNode | null, level: number): string | null;
+    add(parent: LooseNode | null): void;
+    open(node: LooseNode): void;
+    setActive(node: LooseNode, active: boolean): void;
+    reorder(change: TreeReorder): void;
+    actions(node: LooseNode, depth: number): readonly RowAction[];
+    slot(name: string): ((scope: {
+        node: LooseNode;
+        depth: number;
+    }) => unknown) | undefined;
+}
+export declare const treeContextKey: InjectionKey<TreeContext>;

package/dist/content/DiffView.vue.d.ts

@@ -0,0 +1,22 @@
+import { type DiffLine } from "./diff";
+/**
+ * A diff of two texts, drawn from the lines the server computed (`{ op, text }`, op `" "` unchanged, `"-"` removed, `"+"` added):
+ * line numbers, the changes marked, and runs of unchanged lines folded to "12 unchanged lines" (a click opens them).
+ * `mode="unified"` is one column, `"split"` puts the old text left and the new right. A change is told by its sign and by
+ * screen-reader text ("added", "removed"), never by colour alone. Nothing changed shows a plain sentence.
+ *
+ *   <DiffView :lines="version.diff" mode="split" :context="3" />
+ *
+ * The text is not highlighted (that would load the code editor for a read-only view); it is shown as it is, in the mono font.
+ */
+type __VLS_Props = {
+    lines: readonly DiffLine[];
+    mode?: "unified" | "split";
+    /** Unchanged lines kept around each change; the rest fold. `null` folds nothing. Default 3. */
+    context?: number | null;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    mode: "unified" | "split";
+    context: number | null;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/content/PreviewFrame.vue.d.ts

@@ -0,0 +1,46 @@
+import { type PreviewAction, type PreviewCommand, type PreviewDevice } from "./previewFrame";
+declare const _default: <In extends {
+    type: string;
+} = PreviewAction, Out extends {
+    type: string;
+} = PreviewCommand>(__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 onMessage?: ((message: In) => any) | undefined;
+        readonly onError?: (() => any) | undefined;
+        readonly onLoad?: ((milliseconds: number) => any) | undefined;
+        readonly "onUpdate:device"?: ((device: "desktop" | "tablet" | "mobile") => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onError" | "onLoad" | "onMessage" | "onUpdate:device"> & {
+        src: string;
+        /** The iframe's accessible name. */
+        title: string;
+        device?: PreviewDevice;
+        sandbox?: string;
+        /** The origin messages are accepted from. Default: the origin of `src`. */
+        origin?: string;
+        /** Reads a message of the page; return null to ignore it. Default: `parsePreviewAction`. */
+        parse?: (data: unknown) => In | null;
+        /** Milliseconds before a page that has not loaded counts as failed. Default 15000. */
+        timeout?: number;
+    } & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{
+        reload: () => void;
+        post: (message: Out) => void;
+    }>): void;
+    attrs: any;
+    slots: {
+        toolbar?: () => unknown;
+        footer?: (scope: {
+            width: number;
+            scale: number;
+            device: PreviewDevice;
+            loadMs: number | null;
+        }) => unknown;
+    };
+    emit: ((evt: "message", message: In) => void) & ((evt: "error") => void) & ((evt: "load", milliseconds: number) => void) & ((evt: "update:device", device: "desktop" | "tablet" | "mobile") => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/content/diff.d.ts

@@ -0,0 +1,27 @@
+/** One line of a diff: unchanged (`" "`), removed (`"-"`) or added (`"+"`). */
+export interface DiffLine {
+    op: " " | "-" | "+";
+    text: string;
+}
+/** A line with its numbers in the old and in the new text (a removed line has no new number, an added line no old one). */
+export interface NumberedLine extends DiffLine {
+    oldNo: number | null;
+    newNo: number | null;
+}
+/** A run of unchanged lines folded away; `lines` are what a click shows. `key` is the index of its first line. */
+export interface DiffGap {
+    gap: true;
+    key: number;
+    lines: NumberedLine[];
+}
+export type DiffRow = NumberedLine | DiffGap;
+export declare const isGap: (row: object) => row is DiffGap;
+/** The unified rows: every line numbered, and each run of unchanged lines farther than `context` lines from a change folded into a gap (`context: null` folds nothing). A run of one line is not worth a gap. */
+export declare function diffRows(lines: readonly DiffLine[], context: number | null, expanded?: ReadonlySet<number>): DiffRow[];
+/** Two columns of the split view; a side without a line is null (the other side changed alone). */
+export type SplitRow = {
+    left: NumberedLine | null;
+    right: NumberedLine | null;
+} | DiffGap;
+/** The rows side by side: a run of removed lines meets the added lines that follow it, one for one. */
+export declare function splitRows(rows: readonly DiffRow[]): SplitRow[];

package/dist/content/index.d.ts

@@ -2,6 +2,8 @@ export { default as ActivityStream, type ActivityComment, type ActivityEvent, ty
 export { default as Avatar } from "./Avatar.vue";
 export { default as CommentThread, type CommentItem } from "./CommentThread.vue";
 export { default as Composer } from "./Composer.vue";
+export { default as DiffView } from "./DiffView.vue";
+export type { DiffLine } from "./diff";
 export { default as Divider } from "./Divider.vue";
 export { initialsFor } from "./initials";
 export { default as KeyValue } from "./KeyValue.vue";
@@ -9,5 +11,7 @@ export { default as KeyValueList, type KeyValueItem } from "./KeyValueList.vue";
 export { default as MicroLabel } from "./MicroLabel.vue";
 export { default as Money } from "./Money.vue";
 export { default as Panel } from "./Panel.vue";
+export { default as PreviewFrame } from "./PreviewFrame.vue";
+export { PREVIEW_WIDTHS, parsePreviewAction, previewScale, type PreviewAction, type PreviewCommand, type PreviewDevice } from "./previewFrame";
 export { default as StatSummary, type StatItem, type StatTone } from "./StatSummary.vue";
 export { default as Timestamp } from "./Timestamp.vue";