sard 1.0.0 → 1.0.1

package/components/rotate-verify/rotate-verify.js

@@ -0,0 +1,107 @@
+import { createBem } from "../../utils/bem.js";
+import "../../utils/index.js";
+import slide_verify_default from "../slide-verify/slide-verify.js";
+import { defaultRotateVerifyProps } from "./common.js";
+import { computed, createElementBlock, createElementVNode, createVNode, defineComponent, mergeDefaults, normalizeClass, normalizeStyle, openBlock, ref, unref } from "vue";
+//#region packages/sard/components/rotate-verify/rotate-verify.vue
+const _hoisted_1 = ["src"];
+var rotate_verify_default = /*@__PURE__*/ defineComponent({
+	__name: "rotate-verify",
+	props: /*@__PURE__*/ mergeDefaults({
+		src: {
+			type: String,
+			required: false
+		},
+		targetPos: {
+			type: Number,
+			required: false
+		},
+		text: {
+			type: String,
+			required: false
+		},
+		successText: {
+			type: String,
+			required: false
+		},
+		errorText: {
+			type: String,
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		resetWhenError: {
+			type: Boolean,
+			required: false
+		},
+		showTarget: {
+			type: Boolean,
+			required: false
+		},
+		verify: {
+			type: Function,
+			required: false
+		}
+	}, defaultRotateVerifyProps),
+	emits: [
+		"start",
+		"move",
+		"end",
+		"change"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const bem = createBem("rotate-verify");
+		const percent = ref(0);
+		const targetDegree = computed(() => (props.targetPos ?? 100) / 100 * 360);
+		const slideDegree = computed(() => percent.value / 100 * 360);
+		const onChange = (value) => {
+			percent.value = value;
+			emit("change", value);
+		};
+		const slideVerifyRef = ref();
+		const reset = () => {
+			slideVerifyRef.value?.reset();
+		};
+		__expose({ reset });
+		const imageStyle = computed(() => {
+			return { transform: `rotate(${targetDegree.value}deg) rotate(${-slideDegree.value}deg)` };
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", { class: normalizeClass(unref(bem).b()) }, [createElementVNode("img", {
+				class: normalizeClass(unref(bem).e("image")),
+				style: normalizeStyle(imageStyle.value),
+				src: __props.src
+			}, null, 14, _hoisted_1), createVNode(slide_verify_default, {
+				ref_key: "slideVerifyRef",
+				ref: slideVerifyRef,
+				"target-pos": __props.targetPos,
+				text: __props.text,
+				"success-text": __props.successText,
+				"error-text": __props.errorText,
+				disabled: __props.disabled,
+				"reset-when-error": __props.resetWhenError,
+				"show-target": __props.showTarget,
+				verify: __props.verify,
+				onStart: _cache[0] || (_cache[0] = ($event) => emit("start", $event)),
+				onMove: _cache[1] || (_cache[1] = ($event) => emit("move", $event)),
+				onEnd: _cache[2] || (_cache[2] = ($event) => emit("end", $event)),
+				onChange
+			}, null, 8, [
+				"target-pos",
+				"text",
+				"success-text",
+				"error-text",
+				"disabled",
+				"reset-when-error",
+				"show-target",
+				"verify"
+			])], 2);
+		};
+	}
+});
+//#endregion
+export { rotate_verify_default as default };

package/components/scroll-list/common.d.ts

@@ -0,0 +1,15 @@
+import type { DefaultProps } from '../config';
+export interface ScrollListProps {
+    scrollbarBg?: string;
+    scrollbarWidth?: number;
+    thumbBg?: string;
+}
+export declare const defaultScrollListProps: DefaultProps<ScrollListProps>;
+export interface ScrollListSlots {
+    default?(props: Record<string, never>): any;
+}
+export interface ScrollListEmits {
+    (e: 'scroll', event: Event): void;
+}
+export interface ScrollListExpose {
+}

package/components/scroll-list/common.js

@@ -0,0 +1,4 @@
+//#region packages/sard/components/scroll-list/common.ts
+const defaultScrollListProps = {};
+//#endregion
+export { defaultScrollListProps };

package/components/scroll-list/index.css

@@ -0,0 +1 @@
+:root{--s-scroll-list-scrollbar-width:50px;--s-scroll-list-scrollbar-height:4px;--s-scroll-list-scrollbar-margin-top:var(--s-size);--s-scroll-list-scrollbar-bg:var(--s-fill-color-secondary);--s-scroll-list-scrollbar-thumb-bg:var(--s-color-primary)}.s-scroll-list__scroll{overflow-x:auto;overflow-y:hidden}.s-scroll-list__wrapper{display:inline-flex}.s-scroll-list__scrollbar{position:relative;width:var(--s-scroll-list-scrollbar-width);height:var(--s-scroll-list-scrollbar-height);margin-top:var(--s-scroll-list-scrollbar-margin-top);margin-inline-start:auto;margin-inline-end:auto;border-radius:var(--s-border-radius-full);background:var(--s-scroll-list-scrollbar-bg)}.s-scroll-list__scrollbar-thumb{position:absolute;top:0;left:0;width:0;height:100%;border-radius:var(--s-border-radius-full);background:var(--s-scroll-list-scrollbar-thumb-bg)}

package/components/scroll-list/index.d.ts

@@ -0,0 +1,5 @@
+import { type EnhancedComponent } from '../../utils';
+import _ScrollList from './scroll-list.vue';
+export declare const ScrollList: EnhancedComponent<typeof _ScrollList>;
+export default ScrollList;
+export type { ScrollListProps, ScrollListSlots, ScrollListEmits, ScrollListExpose } from './common';

package/components/scroll-list/index.js

@@ -0,0 +1,7 @@
+import { enhanceComponent } from "../../utils/component.js";
+import "../../utils/index.js";
+import scroll_list_default from "./scroll-list.js";
+//#region packages/sard/components/scroll-list/index.ts
+const ScrollList = enhanceComponent(scroll_list_default);
+//#endregion
+export { ScrollList, ScrollList as default };

package/components/scroll-list/scroll-list.d.ts

@@ -0,0 +1,19 @@
+import { type ScrollListProps, type ScrollListSlots } from './common';
+type __VLS_Slots = ScrollListSlots;
+declare const __VLS_base: import("vue").DefineComponent<ScrollListProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    scroll: (event: Event) => any;
+}, string, import("vue").PublicProps, Readonly<ScrollListProps> & Readonly<{
+    onScroll?: ((event: Event) => any) | undefined;
+}>, {
+    scrollbarBg: string;
+    scrollbarWidth: number;
+    thumbBg: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/scroll-list/scroll-list.js

@@ -0,0 +1,89 @@
+import { createBem } from "../../utils/bem.js";
+import { useResizeObserver } from "../../use/useResizeObserver.js";
+import "../../use/index.js";
+import "../../utils/index.js";
+import { defaultScrollListProps } from "./common.js";
+import { computed, createCommentVNode, createElementBlock, createElementVNode, defineComponent, mergeDefaults, normalizeClass, normalizeStyle, openBlock, ref, renderSlot, unref, useTemplateRef } from "vue";
+//#region packages/sard/components/scroll-list/scroll-list.vue
+var scroll_list_default = /*@__PURE__*/ defineComponent({
+	__name: "scroll-list",
+	props: /*@__PURE__*/ mergeDefaults({
+		scrollbarBg: {
+			type: String,
+			required: false
+		},
+		scrollbarWidth: {
+			type: Number,
+			required: false
+		},
+		thumbBg: {
+			type: String,
+			required: false
+		}
+	}, defaultScrollListProps),
+	emits: ["scroll"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const bem = createBem("scroll-list");
+		const scrollRef = useTemplateRef("scroll");
+		const wrapperRef = useTemplateRef("wrapper");
+		const scrollLeft = ref(0);
+		const scrollWidth = ref(0);
+		const clientWidth = ref(0);
+		const update = () => {
+			clientWidth.value = scrollRef.value.clientWidth;
+			scrollWidth.value = scrollRef.value.scrollWidth;
+		};
+		useResizeObserver(wrapperRef, () => {
+			update();
+		});
+		useResizeObserver(scrollRef, () => {
+			update();
+		});
+		const onScroll = (event) => {
+			scrollLeft.value = scrollRef.value.scrollLeft;
+			emit("scroll", event);
+		};
+		const scrollbarStyle = computed(() => {
+			return {
+				width: props.scrollbarWidth || "",
+				backgroundColor: props.scrollbarBg
+			};
+		});
+		const thumbWidth = computed(() => {
+			let width = clientWidth.value / scrollWidth.value;
+			if (!Number.isFinite(width)) width = 0;
+			return width;
+		});
+		const hideScrollbar = computed(() => thumbWidth.value >= 1);
+		const thumbStyle = computed(() => {
+			let offset = Math.abs(scrollLeft.value) / scrollWidth.value;
+			if (!Number.isFinite(offset)) offset = 0;
+			return {
+				insetInlineStart: offset * 100 + "%",
+				width: thumbWidth.value * 100 + "%",
+				backgroundColor: props.thumbBg
+			};
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", { class: normalizeClass(unref(bem).b()) }, [createElementVNode("div", {
+				ref: "scroll",
+				class: normalizeClass(unref(bem).e("scroll")),
+				onScroll
+			}, [createElementVNode("div", {
+				ref: "wrapper",
+				class: normalizeClass(unref(bem).e("wrapper"))
+			}, [renderSlot(_ctx.$slots, "default")], 2)], 34), !hideScrollbar.value ? (openBlock(), createElementBlock("div", {
+				key: 0,
+				class: normalizeClass(unref(bem).e("scrollbar")),
+				style: normalizeStyle(scrollbarStyle.value)
+			}, [createElementVNode("div", {
+				class: normalizeClass(unref(bem).e("scrollbar-thumb")),
+				style: normalizeStyle(thumbStyle.value)
+			}, null, 6)], 6)) : createCommentVNode("v-if", true)], 2);
+		};
+	}
+});
+//#endregion
+export { scroll_list_default as default };

package/components/scroll-spy/common.d.ts

@@ -0,0 +1,32 @@
+import type { InjectionKey } from 'vue';
+export interface ScrollSpyProps {
+    modelValue?: string | number;
+    offset?: number;
+    disabled?: boolean;
+}
+export interface ScrollSpySlots {
+    default?(props: Record<string, never>): any;
+}
+export interface ScrollSpyEmits {
+    (e: 'update:modelValue', value: number | string): void;
+    (e: 'change', value: number | string): void;
+}
+export interface ScrollSpyExpose {
+    scrollTo: (name: string | number) => void;
+    update: () => void;
+}
+export interface ScrollSpyContext {
+    register: (name: string | number, getRect: () => DOMRect) => void;
+    unregister: (name: string | number) => void;
+}
+export declare const scrollSpyContextKey: InjectionKey<ScrollSpyContext>;
+export interface ScrollSpyAnchorProps {
+    name: string | number;
+}
+export interface ScrollSpyAnchorSlots {
+    default?(props: Record<string, never>): any;
+}
+export interface ScrollSpyAnchorEmits {
+}
+export interface ScrollSpyAnchorExpose {
+}

package/components/scroll-spy/common.js

@@ -0,0 +1,4 @@
+//#region packages/sard/components/scroll-spy/common.ts
+const scrollSpyContextKey = Symbol("scrollSpyContext");
+//#endregion
+export { scrollSpyContextKey };

package/components/scroll-spy/index.css

@@ -0,0 +1 @@
+.s-scroll-spy{overflow-x:hidden;overflow-y:auto}.s-scroll-spy:is(.is-disabled){overflow-y:hidden}

package/components/scroll-spy/index.d.ts

@@ -0,0 +1,7 @@
+import { type EnhancedComponent } from '../../utils';
+import _ScrollSpy from './scroll-spy.vue';
+import _ScrollSpyAnchor from './scroll-spy-anchor.vue';
+export declare const ScrollSpy: EnhancedComponent<typeof _ScrollSpy>;
+export declare const ScrollSpyAnchor: EnhancedComponent<typeof _ScrollSpyAnchor>;
+export default ScrollSpy;
+export type { ScrollSpyProps, ScrollSpySlots, ScrollSpyEmits, ScrollSpyExpose, ScrollSpyAnchorProps, ScrollSpyAnchorSlots, ScrollSpyAnchorEmits, ScrollSpyAnchorExpose, } from './common';

package/components/scroll-spy/index.js

@@ -0,0 +1,9 @@
+import { enhanceComponent } from "../../utils/component.js";
+import "../../utils/index.js";
+import scroll_spy_default from "./scroll-spy.js";
+import scroll_spy_anchor_default from "./scroll-spy-anchor.js";
+//#region packages/sard/components/scroll-spy/index.ts
+const ScrollSpy = enhanceComponent(scroll_spy_default);
+const ScrollSpyAnchor = enhanceComponent(scroll_spy_anchor_default);
+//#endregion
+export { ScrollSpy, ScrollSpy as default, ScrollSpyAnchor };

package/components/scroll-spy/scroll-spy-anchor.d.ts

@@ -0,0 +1,11 @@
+import { type ScrollSpyAnchorProps, type ScrollSpyAnchorSlots } from './common';
+type __VLS_Slots = ScrollSpyAnchorSlots;
+declare const __VLS_base: import("vue").DefineComponent<ScrollSpyAnchorProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ScrollSpyAnchorProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/scroll-spy/scroll-spy-anchor.js

@@ -0,0 +1,28 @@
+import { scrollSpyContextKey } from "./common.js";
+import { createElementBlock, defineComponent, inject, onBeforeMount, openBlock, renderSlot, useTemplateRef } from "vue";
+//#region packages/sard/components/scroll-spy/scroll-spy-anchor.vue
+const _hoisted_1 = { ref: "anchor" };
+var scroll_spy_anchor_default = /*@__PURE__*/ defineComponent({
+	__name: "scroll-spy-anchor",
+	props: { name: {
+		type: [String, Number],
+		required: true
+	} },
+	setup(__props) {
+		const props = __props;
+		const context = inject(scrollSpyContextKey, null);
+		if (!context) throw new Error("ScrollSpyAnchor must be included in ScrollSpy.");
+		const anchorRef = useTemplateRef("anchor");
+		const getRect = () => {
+			return anchorRef.value.getBoundingClientRect();
+		};
+		onBeforeMount(() => {
+			context.register(props.name, getRect);
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", _hoisted_1, [renderSlot(_ctx.$slots, "default")], 512);
+		};
+	}
+});
+//#endregion
+export { scroll_spy_anchor_default as default };

package/components/scroll-spy/scroll-spy.d.ts

@@ -0,0 +1,17 @@
+import { type ScrollSpyProps, type ScrollSpySlots, type ScrollSpyExpose } from './common';
+type __VLS_Slots = ScrollSpySlots;
+declare const __VLS_base: import("vue").DefineComponent<ScrollSpyProps, ScrollSpyExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    change: (value: string | number) => any;
+    "update:modelValue": (value: string | number) => any;
+}, string, import("vue").PublicProps, Readonly<ScrollSpyProps> & Readonly<{
+    onChange?: ((value: string | number) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/scroll-spy/scroll-spy.js

@@ -0,0 +1,65 @@
+import { createBem } from "../../utils/bem.js";
+import { isNullish } from "../../utils/is.js";
+import { useScrollSpy } from "../../use/useScrollSpy.js";
+import "../../use/index.js";
+import "../../utils/index.js";
+import { scrollSpyContextKey } from "./common.js";
+import { createElementBlock, defineComponent, normalizeClass, openBlock, provide, reactive, renderSlot, toRef, unref, useTemplateRef, watch } from "vue";
+//#region packages/sard/components/scroll-spy/scroll-spy.vue
+var scroll_spy_default = /*@__PURE__*/ defineComponent({
+	__name: "scroll-spy",
+	props: {
+		modelValue: {
+			type: [String, Number],
+			required: false
+		},
+		offset: {
+			type: Number,
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		}
+	},
+	emits: ["update:modelValue", "change"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const bem = createBem("scroll-spy");
+		const scrollRef = useTemplateRef("scroll");
+		const { innerCurrent, anchorRectList, register, unregister, scrollTo, update } = useScrollSpy(scrollRef, reactive({
+			startOffset: toRef(() => props.offset),
+			defaultCurrent: props.modelValue,
+			getSpiedRect() {
+				return scrollRef.value.getBoundingClientRect();
+			},
+			onChange(name) {
+				emit("update:modelValue", name);
+				emit("change", name);
+			}
+		}));
+		provide(scrollSpyContextKey, {
+			register,
+			unregister
+		});
+		watch(() => props.modelValue, () => {
+			if (!isNullish(props.modelValue) && anchorRectList.value.find((item) => item[0] === props.modelValue) && props.modelValue !== innerCurrent.value) {
+				innerCurrent.value = props.modelValue;
+				scrollTo(props.modelValue);
+			}
+		});
+		__expose({
+			scrollTo,
+			update
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				ref: "scroll",
+				class: normalizeClass([unref(bem).b(), unref(bem).is("disabled", __props.disabled)])
+			}, [renderSlot(_ctx.$slots, "default")], 2);
+		};
+	}
+});
+//#endregion
+export { scroll_spy_default as default };

package/components/search/common.d.ts

@@ -0,0 +1,37 @@
+import { type DefaultProps } from '../config';
+export interface SearchProps {
+    modelValue?: string;
+    placeholder?: string;
+    shape?: 'round' | 'square';
+    background?: string;
+    inputBackground?: string;
+    inputColor?: string;
+    readonly?: boolean;
+    disabled?: boolean;
+    align?: 'left' | 'center' | 'right';
+    cancel?: string;
+    search?: string;
+    focus?: boolean;
+}
+export declare const defaultSearchProps: DefaultProps<SearchProps>;
+export interface SearchSlots {
+    prepend?(props: Record<string, never>): any;
+    append?(props: Record<string, never>): any;
+    'input-prepend'?(props: Record<string, never>): any;
+    'input-append'?(props: Record<string, never>): any;
+}
+export interface SearchEmits {
+    (e: 'update:modelValue', value: string): void;
+    (e: 'input', value: string): void;
+    (e: 'change', value: string): void;
+    (e: 'cancel'): void;
+    (e: 'search', value: string): void;
+    (e: 'click', event: MouseEvent): void;
+    (e: 'clear'): void;
+    (e: 'focus', event: FocusEvent): void;
+    (e: 'blur', event: FocusEvent): void;
+}
+export interface SearchExpose {
+    focus: () => void;
+    blur: () => void;
+}

package/components/search/common.js

@@ -0,0 +1,7 @@
+//#region packages/sard/components/search/common.ts
+const defaultSearchProps = {
+	shape: "square",
+	focus: false
+};
+//#endregion
+export { defaultSearchProps };

package/components/search/index.css

@@ -0,0 +1 @@
+:root{--s-search-padding-x:var(--s-size-sm);--s-search-padding-y:var(--s-size-xs);--s-search-bg:var(--s-bg-color-container);--s-search-input-bg:var(--s-fill-color-tertiary);--s-search-input-bg-disabled:var(--s-bg-color-disabled);--s-search-icon-color:var(--s-text-color-fourth);--s-search-icon-font-size:var(--s-font-size)}.s-search{display:flex;align-items:stretch;padding:var(--s-search-padding-y) var(--s-search-padding-x);background:var(--s-search-bg)}.s-search--show-action{padding-inline-end:0}.s-search__input-wrapper{flex:1}.s-search__input{background:var(--s-search-input-bg)}.s-search__input--round{border-radius:var(--s-border-radius-full)}.s-search__prepend,.s-search__append{display:flex;align-items:center;flex:none}.s-search__prepend .s-button,.s-search__append .s-button{height:100%}.s-search__icon{font-size:var(--s-search-icon-font-size);color:var(--s-search-icon-color)}.s-search--disabled .s-search__input{background:var(--s-search-input-bg-disabled)}

package/components/search/index.d.ts

@@ -0,0 +1,5 @@
+import { type EnhancedComponent } from '../../utils';
+import _Search from './search.vue';
+export declare const Search: EnhancedComponent<typeof _Search>;
+export default Search;
+export type { SearchProps, SearchSlots, SearchEmits } from './common';

package/components/search/index.js

@@ -0,0 +1,7 @@
+import { enhanceComponent } from "../../utils/component.js";
+import "../../utils/index.js";
+import search_default from "./search.js";
+//#region packages/sard/components/search/index.ts
+const Search = enhanceComponent(search_default);
+//#endregion
+export { Search, Search as default };

package/components/search/search.d.ts

@@ -0,0 +1,44 @@
+import { type SearchProps, type SearchSlots, type SearchExpose } from './common';
+type __VLS_Slots = SearchSlots;
+declare const __VLS_base: import("vue").DefineComponent<SearchProps, SearchExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    input: (value: string) => any;
+    search: (value: string) => any;
+    clear: () => any;
+    blur: (event: FocusEvent) => any;
+    cancel: () => any;
+    change: (value: string) => any;
+    click: (event: MouseEvent) => any;
+    focus: (event: FocusEvent) => any;
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<SearchProps> & Readonly<{
+    onInput?: ((value: string) => any) | undefined;
+    onSearch?: ((value: string) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onCancel?: (() => any) | undefined;
+    onChange?: ((value: string) => any) | undefined;
+    onClick?: ((event: MouseEvent) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    search: string;
+    background: string;
+    readonly: boolean;
+    cancel: string;
+    focus: boolean;
+    disabled: boolean;
+    modelValue: string;
+    shape: "round" | "square";
+    placeholder: string;
+    align: "left" | "center" | "right";
+    inputBackground: string;
+    inputColor: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};