@celldl/editor 0.20260212.0 → 0.20260217.0

package/dist/src/CellDL/utils.d.ts

@@ -0,0 +1,6 @@
+import { Pair } from '../common/types';
+export declare function sleep(ms: number): Promise<unknown>;
+export declare function round(length: number, decimalPlaces?: number): number;
+export declare function roundEqual(l1: number, l2: number, decimalPlaces?: number): boolean;
+export declare function range(startOrStop: number, stop?: number | null, step?: number | null): Generator<number, void, unknown>;
+export declare function pairwise<T>(a: T[]): Pair<T>[];

package/dist/src/assets/oxigraph/web.d.ts

@@ -0,0 +1,279 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * RDF/JS DataFactory-compatible methods
+ */ 
+export function literal(value: string | undefined, languageOrDataType?: string | NamedNode | {language: string, direction?: "ltr" | "rtl"}): Literal;
+export function quad(subject: Quad_Subject, predicate: Quad_Predicate, object: Quad_Object, graph?: Quad_Graph): Quad;
+
+/**
+ * RDF/JS-compatible BlankNode term
+ */
+export class BlankNode {
+    readonly termType: "BlankNode";
+    readonly value: string;
+
+    equals(other: Term | null | undefined): boolean;
+    toString(): string;
+}
+
+/**
+ * RDF/JS-compatible DefaultGraph term
+ */
+export class DefaultGraph {
+    readonly termType: "DefaultGraph";
+    readonly value: "";
+
+    equals(other: Term | null | undefined): boolean;
+    toString(): string;
+}
+
+/**
+ * RDF/JS-compatible Literal term
+ */
+export class Literal {
+    readonly datatype: NamedNode;
+    readonly language: string;
+    readonly direction: "ltr" | "rtl" | "";
+    readonly termType: "Literal";
+    readonly value: string;
+
+    equals(other: Term | null | undefined): boolean;
+    toString(): string;
+}
+
+/**
+ * RDF/JS-compatible BlankNode term
+ */
+export class NamedNode {
+    readonly termType: "NamedNode";
+    readonly value: string;
+
+    equals(other: Term | null | undefined): boolean;
+    toString(): string;
+}
+
+/**
+ * BaseQuad is part of the RDF/JS spec and has no direct equivalent in Oxigraph.
+ * 
+ * It's copied here from the RDF/JS reference types (https://github.com/rdfjs/types , MIT license) because:
+ *  - RDF/JS DatasetCore's match method takes Term parameters.
+ *  - RDF/JS's Term is defined in terms of BaseQuad and not Quad.
+ */ 
+export interface BaseQuad {
+    readonly graph: Term;
+    readonly object: Term;
+    readonly predicate: Term;
+    readonly subject: Term;
+    readonly termType: "Quad";
+    readonly value: "";
+
+    equals(other: Term | null | undefined): boolean;
+    toString(): string;
+}
+
+/**
+ * RDF/JS-compatible Quad term
+ */
+export class Quad implements BaseQuad {
+    readonly graph: Quad_Graph;
+    readonly object: Quad_Object;
+    readonly predicate: Quad_Predicate;
+    readonly subject: Quad_Subject;
+    readonly termType: "Quad";
+    readonly value: "";
+
+    equals(other: Term | null | undefined): boolean;
+    toString(): string;
+}
+
+/**
+ * Typedefs copied from the RDF/JS reference types (https://github.com/rdfjs/types)
+ */
+export type Quad_Graph = DefaultGraph | NamedNode | BlankNode | Variable;
+export type Quad_Object = NamedNode | Literal | BlankNode | Quad | Variable;
+export type Quad_Predicate = NamedNode | Variable;
+export type Quad_Subject = NamedNode | BlankNode | Quad | Variable;
+
+/**
+ * RDF/JS-compatible Term typedef. See note above re: BaseQuad.
+ */
+export type Term = NamedNode | BlankNode | Literal | Variable | DefaultGraph | BaseQuad;
+
+/**
+ * RDF/JS-compatible Variable term
+ */
+export class Variable {
+    readonly termType: "Variable";
+    readonly value: string;
+
+    equals(other: Term | null | undefined): boolean;
+    toString(): string;
+}
+
+
+
+export class Store {
+    readonly size: number;
+
+    constructor(quads?: Iterable<Quad>);
+
+    add(quad: Quad): void;
+
+    delete(quad: Quad): void;
+
+    dump(
+        options: {
+            format: string;
+            from_graph_name?: BlankNode | DefaultGraph | NamedNode;
+        }
+    ): string;
+
+    has(quad: Quad): boolean;
+
+    load(
+        data: string,
+        options: {
+            base_iri?: NamedNode | string;
+            format: string;
+            no_transaction?: boolean;
+            to_graph_name?: BlankNode | DefaultGraph | NamedNode;
+            unchecked?: boolean;
+            lenient?: boolean;
+        }
+    ): void;
+
+    match(subject?: Term | null, predicate?: Term | null, object?: Term | null, graph?: Term | null): Quad[];
+
+    query(
+        query: string,
+        options?: {
+            base_iri?: NamedNode | string;
+            results_format?: string;
+            default_graph?: BlankNode | DefaultGraph | NamedNode | Iterable<BlankNode | DefaultGraph | NamedNode>;
+            named_graphs?: Iterable<BlankNode | NamedNode>;
+            use_default_graph_as_union?: boolean;
+        }
+    ): boolean | Map<string, Term>[] | Quad[] | string;
+
+    update(
+        update: string,
+        options?: {
+            base_iri?: NamedNode | string;
+        }
+    ): void;
+}
+
+
+
+export function blankNode(value?: string | null): BlankNode;
+
+export function defaultGraph(): DefaultGraph;
+
+export function fromQuad(original: any): any;
+
+export function fromTerm(original: any): any;
+
+export function main(): void;
+
+export function namedNode(value: string): NamedNode;
+
+export function triple(subject: any, predicate: any, object: any): Quad;
+
+export function variable(value: string): Variable;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+  readonly memory: WebAssembly.Memory;
+  readonly __wbg_blanknode_free: (a: number, b: number) => void;
+  readonly __wbg_defaultgraph_free: (a: number, b: number) => void;
+  readonly __wbg_literal_free: (a: number, b: number) => void;
+  readonly __wbg_namednode_free: (a: number, b: number) => void;
+  readonly __wbg_quad_free: (a: number, b: number) => void;
+  readonly __wbg_store_free: (a: number, b: number) => void;
+  readonly blankNode: (a: number, b: number) => [number, number, number];
+  readonly blanknode_equals: (a: number, b: any) => number;
+  readonly blanknode_term_type: (a: number) => [number, number];
+  readonly blanknode_toString: (a: number) => [number, number];
+  readonly blanknode_value: (a: number) => [number, number];
+  readonly defaultGraph: () => number;
+  readonly defaultgraph_equals: (a: number, b: any) => number;
+  readonly defaultgraph_term_type: (a: number) => [number, number];
+  readonly defaultgraph_toString: (a: number) => [number, number];
+  readonly defaultgraph_value: (a: number) => [number, number];
+  readonly fromQuad: (a: any) => [number, number, number];
+  readonly fromTerm: (a: any) => [number, number, number];
+  readonly literal: (a: number, b: number, c: any) => [number, number, number];
+  readonly literal_datatype: (a: number) => number;
+  readonly literal_direction: (a: number) => [number, number];
+  readonly literal_equals: (a: number, b: any) => number;
+  readonly literal_language: (a: number) => [number, number];
+  readonly literal_term_type: (a: number) => [number, number];
+  readonly literal_toString: (a: number) => [number, number];
+  readonly literal_value: (a: number) => [number, number];
+  readonly main: () => void;
+  readonly namedNode: (a: number, b: number) => [number, number, number];
+  readonly namednode_equals: (a: number, b: any) => number;
+  readonly namednode_term_type: (a: number) => [number, number];
+  readonly namednode_toString: (a: number) => [number, number];
+  readonly namednode_value: (a: number) => [number, number];
+  readonly quad: (a: any, b: any, c: any, d: any) => [number, number, number];
+  readonly quad_equals: (a: number, b: any) => number;
+  readonly quad_graph: (a: number) => any;
+  readonly quad_object: (a: number) => any;
+  readonly quad_predicate: (a: number) => any;
+  readonly quad_subject: (a: number) => any;
+  readonly quad_term_type: (a: number) => [number, number];
+  readonly quad_toString: (a: number) => [number, number];
+  readonly quad_value: (a: number) => [number, number];
+  readonly store_add: (a: number, b: any) => [number, number];
+  readonly store_delete: (a: number, b: any) => [number, number];
+  readonly store_dump: (a: number, b: any, c: any) => [number, number, number, number];
+  readonly store_has: (a: number, b: any) => [number, number, number];
+  readonly store_load: (a: number, b: number, c: number, d: any, e: any, f: any) => [number, number];
+  readonly store_match: (a: number, b: any, c: any, d: any, e: any) => [number, number, number, number];
+  readonly store_new: (a: any) => [number, number, number];
+  readonly store_query: (a: number, b: number, c: number, d: any) => [number, number, number];
+  readonly store_size: (a: number) => [number, number, number];
+  readonly store_update: (a: number, b: number, c: number, d: any) => [number, number];
+  readonly triple: (a: any, b: any, c: any) => [number, number, number];
+  readonly variable: (a: number, b: number) => [number, number, number];
+  readonly variable_equals: (a: number, b: any) => number;
+  readonly variable_term_type: (a: number) => [number, number];
+  readonly variable_toString: (a: number) => [number, number];
+  readonly variable_value: (a: number) => [number, number];
+  readonly __wbg_variable_free: (a: number, b: number) => void;
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+  readonly __wbindgen_exn_store: (a: number) => void;
+  readonly __externref_table_alloc: () => number;
+  readonly __wbindgen_externrefs: WebAssembly.Table;
+  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+  readonly __externref_table_dealloc: (a: number) => void;
+  readonly __externref_drop_slice: (a: number, b: number) => void;
+  readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+*
+* @returns {InitOutput}
+*/
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+*
+* @returns {Promise<InitOutput>}
+*/
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/dist/src/common/EditorTypes.d.ts

@@ -0,0 +1,39 @@
+/******************************************************************************
+
+CellDL Editor
+
+Copyright (c) 2022 - 2025 David Brooks
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+******************************************************************************/
+import type * as vue from 'vue';
+export interface EditorToolButton {
+    toolId: string;
+    active?: boolean;
+    prompt: string;
+    icon?: string;
+    image?: string;
+    panel?: vue.Raw<vue.Component>;
+}
+export interface EditorState {
+    fileModified?: boolean;
+    itemSelected?: boolean;
+    pasteContents?: boolean;
+    redoContents?: boolean;
+}
+export interface ViewState {
+    showGrid?: boolean;
+    gridSpacing?: number;
+    snapToGrid?: number;
+}

package/dist/src/common/common.d.ts

@@ -0,0 +1,7 @@
+export declare function isWindows(): boolean;
+export declare function isLinux(): boolean;
+export declare function isMacOs(): boolean;
+export declare function isDesktop(): boolean;
+export declare function isCtrlOrCmd(event: KeyboardEvent): boolean;
+export declare function formatTime(time: number): string;
+export declare function formatIssue(issue: string): string;

package/dist/src/common/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const SHORT_DELAY: number;
+export declare const MEDIUM_DELAY: number;
+export declare const LONG_DELAY: number;
+export declare const TOAST_LIFE: number;
+export declare const COPYRIGHT: string;

package/dist/src/common/points.d.ts

@@ -0,0 +1,57 @@
+/******************************************************************************
+
+CellDL Editor
+
+Copyright (c) 2022 - 2025 David Brooks
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+******************************************************************************/
+export interface PointLike {
+    x: number;
+    y: number;
+}
+export type PointArray = [number, number];
+export declare const POINT_EPSILON = 0.0001;
+export declare const POINT_EPSILON_SQUARED: number;
+export declare class Point implements PointLike {
+    readonly x: number;
+    readonly y: number;
+    constructor(x?: number, y?: number);
+    static fromPoint(point: PointLike): Point;
+    static fromArray(coords: PointArray): Point;
+    asArray(): PointArray;
+    add(point: PointLike): Point;
+    colinear(p1: PointLike, p2: PointLike, between?: boolean): boolean;
+    copy(): Point;
+    distance(point: PointLike): number;
+    equals(point: PointLike): boolean;
+    isZero(): boolean;
+    apply(fn: (n: number) => number): Point;
+    scalarScale(scale: number): Point;
+    scale(scale: PointLike): Point;
+    snapTo(point: PointLike, snapDistance?: number): Point;
+    subtract(point: PointLike): Point;
+    toString(): string;
+}
+export declare class PointMath {
+    static add(p1: PointLike, p2: PointLike): Point;
+    static apply(p1: PointLike, fn: (number: number) => number): Point;
+    static colinear(p0: PointLike, p1: PointLike, p2: PointLike, between?: boolean): boolean;
+    static distance(p1: PointLike, p2: PointLike): number;
+    static equals(p1: PointLike, p2: PointLike): boolean;
+    static isZero(pt: PointLike): boolean;
+    static scalarScale(p1: PointLike, scale: number): Point;
+    static scale(p1: PointLike, scale: PointLike): Point;
+    static subtract(p1: PointLike, p2: PointLike): Point;
+}

package/dist/src/common/styling.d.ts

@@ -0,0 +1,36 @@
+/******************************************************************************
+
+CellDL Editor
+
+Copyright (c) 2022 - 2025 David Brooks
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+******************************************************************************/
+export declare const CONNECTION_ARROW_SIZE: number[];
+export declare const CONNECTION_SPLAY_PADDING = 16;
+export declare const MAX_CONNECTION_SPLAY_PADDING = 20;
+export declare const CONNECTION_COLOUR = "#567";
+export declare const OLD_CONNECTION_COLOUR = "#334155";
+export declare const CONNECTION_WIDTH = 2;
+export declare const CONNECTION_DASH = 2;
+export declare const INTERFACE_PORT_RADIUS = 4;
+export declare const SELECTION_STROKE_WIDTH = 3;
+export declare const CELLDL_BACKGROUND_CLASS = "celldl-background";
+export declare function arrowMarkerDefinition(markerId: string, markerType: string): string;
+export type GradientStop = {
+    offset: string;
+    colour: string;
+};
+export declare function gradientDefinition(type: string, gradientId: string, stops: GradientStop[]): string;
+export declare const CellDLStylesheet: string;

package/dist/src/common/svgUtils.d.ts

@@ -0,0 +1,48 @@
+import { PointLike } from './points';
+import { StringProperties } from './types';
+import { Extent } from '../CellDL/geometry/index';
+export declare const SVG_URI = "http://www.w3.org/2000/svg";
+export interface INodeStyle {
+    gradientFill: boolean;
+    colours: string[];
+    direction?: string;
+}
+export interface IPathStyle {
+    colour: string;
+    width: number;
+    dashed: boolean;
+}
+export interface LatexMathSvgOptions {
+    background?: string | string[];
+    border?: string;
+    'border-width'?: string;
+    class?: string;
+    'corner-radius'?: string;
+    'middle-colour'?: string;
+    'min-height'?: string;
+    'min-width'?: string;
+    padding?: string;
+    'vertical-align'?: string;
+}
+export declare function svgSize(svgDocument: Document): PointLike | null;
+export declare function getViewbox(svgElement: SVGGraphicsElement): Extent;
+type Attributes = StringProperties;
+export declare function createSVGElement(tagName: string, attributes: Attributes): SVGElement;
+export declare function svgCircle(centre: PointLike, radius: number, attributes?: Attributes): string;
+export declare function svgCircleElement(centre: PointLike, radius: number, attributes?: Attributes): SVGCircleElement;
+export declare function svgPath(points: PointLike[], attributes?: Attributes): string;
+export declare function svgPathDescription(points: PointLike[]): string;
+export declare function svgPathElement(points: PointLike[], attributes?: Attributes): SVGPathElement;
+export declare function svgRect(topLeft: PointLike, bottomRight: PointLike, attributes?: Attributes): string;
+export declare function svgRectElement(topLeft: PointLike, bottomRight: PointLike, attributes?: StringProperties): SVGRectElement;
+export declare const LatexStyleRules: string;
+export declare class LatexMathSvg {
+    #private;
+    static svgRect(latex: string, suffix?: string, options?: LatexMathSvgOptions): string;
+}
+export declare function base64Svg(svg: string): string;
+export declare function getSvgImageFromBase64(svgText: string): string | undefined;
+export declare function getSvgFillStyle(svgText: string): string[];
+export declare function getSvgPathStyle(svgElement: SVGGraphicsElement): IPathStyle;
+export declare function setSvgPathStyle(svgElement: SVGGraphicsElement, pathStyle: IPathStyle): void;
+export {};

package/dist/src/common/themeCssVariables.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Composable utility for injecting PrimeVue theme CSS variables into the DOM.
+ *
+ * Ex https://github.com/CellDL/CellDLEditor/pull/4/changes from https://github.com/akhuoa
+ */
+/**
+ * @param componentName The key name in the preset (e.g., 'card', 'button', 'select')
+ */
+export declare function useThemeCssVariables(componentName: string): void;

package/dist/src/common/types.d.ts

@@ -0,0 +1,23 @@
+/******************************************************************************
+
+CellDL Editor
+
+Copyright (c) 2022 - 2025 David Brooks
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+******************************************************************************/
+export type Constructor<T> = new (...args: any[]) => T;
+export type Pair<T> = [T, T];
+export type PropertiesType = Record<string, string | number | boolean>;
+export type StringProperties = Record<string, string>;

package/dist/src/common/vueCommon.d.ts

@@ -0,0 +1,9 @@
+import { Theme } from '../../index.ts';
+import * as vue from 'vue';
+export declare const activeInstanceUid: () => vue.Ref<string | null>;
+export declare const useTheme: () => {
+    theme: () => Theme;
+    setTheme: (newTheme: Theme | undefined) => void;
+    useLightMode: () => boolean;
+    useDarkMode: () => boolean;
+};

package/dist/src/components/CellDLEditor.vue.d.ts

@@ -0,0 +1,19 @@
+import { CellDLEditorProps, EditorData } from '../../index';
+import * as vue from 'vue';
+declare const _default: vue.DefineComponent<__VLS_TypePropsToOption<CellDLEditorProps>, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    error: (msg: string) => void;
+    "editor-data": (data: EditorData) => void;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption<CellDLEditorProps>>> & {
+    onError?: ((msg: string) => any) | undefined;
+    "onEditor-data"?: ((data: EditorData) => any) | undefined;
+}, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/src/components/WrappedEditor.vue.d.ts

@@ -0,0 +1,19 @@
+import { CellDLEditorProps, EditorData } from '../../index';
+import * as vue from 'vue';
+declare const _default: vue.DefineComponent<__VLS_TypePropsToOption<CellDLEditorProps>, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    error: (msg: string) => void;
+    "editor-data": (data: EditorData) => void;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption<CellDLEditorProps>>> & {
+    onError?: ((msg: string) => any) | undefined;
+    "onEditor-data"?: ((data: EditorData) => any) | undefined;
+}, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/src/components/panels/FillStyle.vue.d.ts

@@ -0,0 +1,20 @@
+import { INodeStyle } from '../../common/svgUtils';
+import * as vue from 'vue';
+type __VLS_Props = {
+    fillStyle: INodeStyle;
+};
+declare const _default: vue.DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    change: (...args: any[]) => void;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>> & {
+    onChange?: ((...args: any[]) => any) | undefined;
+}, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/src/components/panels/PathStyle.vue.d.ts

@@ -0,0 +1,20 @@
+import { IPathStyle } from '../../common/svgUtils';
+import * as vue from 'vue';
+type __VLS_Props = {
+    pathStyle: IPathStyle;
+};
+declare const _default: vue.DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    change: (...args: any[]) => void;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>> & {
+    onChange?: ((...args: any[]) => any) | undefined;
+}, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/src/components/panels/PropertiesPanel.vue.d.ts

@@ -0,0 +1,21 @@
+import * as vue from 'vue';
+type __VLS_Props = {
+    toolId: string;
+};
+declare const _default: vue.DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    "panel-event": (...args: any[]) => void;
+    "style-event": (...args: any[]) => void;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>> & {
+    "onPanel-event"?: ((...args: any[]) => any) | undefined;
+    "onStyle-event"?: ((...args: any[]) => any) | undefined;
+}, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/src/components/popovers/ComponentPopover.vue.d.ts

@@ -0,0 +1,19 @@
+import * as vue from 'vue';
+type __VLS_Props = {
+    toolId: string;
+};
+declare const _default: vue.DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    "popover-event": (...args: any[]) => void;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>> & {
+    "onPopover-event"?: ((...args: any[]) => any) | undefined;
+}, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};