@nil-/doc 0.2.45 → 0.2.46

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @nil-/doc
 
+## 0.2.46
+
+### Patch Changes
+
+-   [doc][new] added event control support ([#77](https://github.com/njaldea/mono/pull/77))
+
 ## 0.2.45
 
 ### Patch Changes

package/components/block/Controls.svelte

@@ -1,11 +1,12 @@
 
 <script>import { getControls, getControlsState } from "./context";
 export let props = [];
+export let events = [];
 export let hide = false;
 export let position = void 0;
 const controls = getControls();
 $:
-  $controls = props;
+  $controls = { props, events };
 const state = getControlsState();
 $:
   $state.hide = hide;

package/components/block/Controls.svelte.d.ts

@@ -1,8 +1,9 @@
 import { SvelteComponentTyped } from "svelte";
-import type { Control } from "./controls/types";
+import type { Prop } from "./controls/types";
 declare const __propDef: {
     props: {
-        props?: Control[] | undefined;
+        props?: Prop[] | undefined;
+        events?: string[] | undefined;
         hide?: boolean | undefined;
         position?: undefined | "bottom" | "right";
     };

package/components/block/Instance.svelte

@@ -74,13 +74,27 @@
 import { cquery } from "./action";
 import { getControls, getControlsState } from "./context";
 import { getTheme } from "../context";
-import Controls from "./controls/Controls.svelte";
+import Props from "./controls/props/Props.svelte";
+import Events from "./controls/events/Events.svelte";
 import { resolve } from "./utils";
 const controls = getControls();
 const controlsState = getControlsState();
 const dark = getTheme();
 $:
-  expanded = $controls.length > 0 && !$controlsState.hide;
+  hasProps = $controls.props.length > 0;
+$:
+  hasEvents = $controls.events.length > 0;
+let cvisible = null;
+$:
+  if (cvisible == null && hasProps) {
+    cvisible = "props";
+  } else if (cvisible == null && hasEvents) {
+    cvisible = "events";
+  } else if (!hasProps && !hasEvents) {
+    cvisible = null;
+  }
+$:
+  expanded = !$controlsState.hide && cvisible != null;
 export let defaults = void 0;
 export let noreset = false;
 export let scale = false;
@@ -88,11 +102,10 @@ let key = false;
 beforeUpdate(() => key = !key);
 const resolveArgs = resolve;
 let bound = {};
-const updateBound = (d) => {
-  bound = resolve(d ?? {}, {});
-};
+const updateBound = (d) => bound = resolve(d ?? {}, {});
 $:
   updateBound(defaults);
+let handlers;
 </script>
 <div
     class="instance"
@@ -107,18 +120,32 @@ $:
 >
     {#if noreset}
         <div class="content scrollable" class:dark={$dark}>
-            <slot props={resolveArgs(defaults ?? {}, bound)} {key} />
+            <slot props={resolveArgs(defaults ?? {}, bound)} events={handlers} {key} />
         </div>
     {:else}
         {#key key}
             <div class="content scrollable" class:dark={$dark}>
-                <slot props={resolveArgs(defaults ?? {}, bound)} {key} />
+                <slot props={resolveArgs(defaults ?? {}, bound)} events={handlers} {key} />
             </div>
         {/key}
     {/if}
     {#if expanded}
         <div class="misc scrollable" class:dark={$dark}>
-            <Controls infos={$controls} bind:values={bound} />
+            <Props infos={$controls.props} bind:values={bound} visible={cvisible == "props"}>
+                <div on:dblclick={() => hasEvents && (cvisible = "events")}>
+                    <div>Properties</div>
+                    <div>Value</div>
+                    <div>Use</div>
+                </div>
+            </Props>
+            <Events events={$controls.events} bind:handlers visible={cvisible == "events"}>
+                {#if cvisible == "events"}
+                    <div on:dblclick={() => hasProps && (cvisible = "props")}>
+                        <div>Events</div>
+                        <div>Detail</div>
+                    </div>
+                {/if}
+            </Events>
         </div>
     {/if}
 </div>

package/components/block/Instance.svelte.d.ts

@@ -1,7 +1,7 @@
 import { SvelteComponentTyped } from "svelte";
-declare class __sveltets_Render<Args> {
+declare class __sveltets_Render<PropArgs> {
     props(): {
-        defaults?: Args | undefined;
+        defaults?: PropArgs | undefined;
         noreset?: boolean | undefined;
         scale?: boolean | undefined;
     };
@@ -10,14 +10,15 @@ declare class __sveltets_Render<Args> {
     };
     slots(): {
         default: {
-            props: Args;
+            props: PropArgs;
+            events: Record<string, (ev: CustomEvent<unknown>) => void>;
             key: boolean;
         };
     };
 }
-export type InstanceProps<Args> = ReturnType<__sveltets_Render<Args>['props']>;
-export type InstanceEvents<Args> = ReturnType<__sveltets_Render<Args>['events']>;
-export type InstanceSlots<Args> = ReturnType<__sveltets_Render<Args>['slots']>;
-export default class Instance<Args> extends SvelteComponentTyped<InstanceProps<Args>, InstanceEvents<Args>, InstanceSlots<Args>> {
+export type InstanceProps<PropArgs> = ReturnType<__sveltets_Render<PropArgs>['props']>;
+export type InstanceEvents<PropArgs> = ReturnType<__sveltets_Render<PropArgs>['events']>;
+export type InstanceSlots<PropArgs> = ReturnType<__sveltets_Render<PropArgs>['slots']>;
+export default class Instance<PropArgs> extends SvelteComponentTyped<InstanceProps<PropArgs>, InstanceEvents<PropArgs>, InstanceSlots<PropArgs>> {
 }
 export {};

package/components/block/Template.svelte

@@ -30,7 +30,8 @@ const cast = (t) => t;
         {scale}
         let:key
         let:props
+        let:events
     >
-        <slot id={param.id} tag={param.tag} props={cast(props)} {key} />
+        <slot id={param.id} tag={param.tag} props={cast(props)} {events} {key} />
     </Instance>
 {/each}

package/components/block/Template.svelte.d.ts

@@ -14,6 +14,7 @@ declare class __sveltets_Render<Args> {
             id: number;
             tag: string;
             props: Args;
+            events: Record<string, (ev: CustomEvent<unknown>) => void>;
             key: boolean;
         };
     };

package/components/block/context.d.ts

@@ -1,5 +1,5 @@
 import type { Writable } from "svelte/store";
-import type { Control } from "./controls/types";
+import type { Prop, Event } from "./controls/types";
 import type { ValueType } from "./types";
 export type Params = {
     id: number;
@@ -11,7 +11,12 @@ export type ControlState = {
     position?: "bottom" | "right";
 };
 export declare const initParams: () => Writable<Params[]>, getParams: () => Writable<Params[]>;
-export declare const initControls: () => Writable<Control[]>, getControls: () => Writable<Control[]>;
+type Controls = {
+    props: Prop[];
+    events: Event[];
+};
+export declare const initControls: () => Writable<Controls>, getControls: () => Writable<Controls>;
 export declare const initDefaults: () => Writable<Record<string, ValueType>>, getDefaults: () => Writable<Record<string, ValueType>>;
 export declare const initControlsState: () => Writable<ControlState>, getControlsState: () => Writable<ControlState>;
 export declare const initOrientation: () => Writable<boolean>, getOrientation: () => Writable<boolean>;
+export {};

package/components/block/context.js

@@ -8,7 +8,10 @@ const create = (defaulter) => {
     };
 };
 export const { init: initParams, get: getParams } = create(() => []);
-export const { init: initControls, get: getControls } = create(() => []);
+export const { init: initControls, get: getControls } = create(() => ({
+    props: [],
+    events: []
+}));
 export const { init: initDefaults, get: getDefaults } = create(() => ({}));
 export const { init: initControlsState, get: getControlsState } = create(() => ({
     hide: false

package/components/block/controls/events/Events.svelte

@@ -0,0 +1,69 @@
+<style>
+    .count {
+        display: grid;
+        place-items: center;
+        text-align: center;
+        font-size: 0.8rem;
+    }
+</style>
+
+<script>import Styler from "./misc/Styler.svelte";
+export let visible;
+export let events;
+export let handlers;
+let history = [];
+const stringify = (detail) => {
+  if (detail) {
+    if (typeof detail === "string") {
+      return detail;
+    }
+    return JSON.stringify(detail);
+  }
+  return "";
+};
+const wrap = (ext) => {
+  const obj = {};
+  if (ext != null) {
+    for (const name of ext) {
+      obj[name] = (ev) => {
+        const detail = stringify(ev.detail);
+        if (history.length > 0) {
+          const last = history[history.length - 1];
+          if (last.name === name && last.detail === detail && last.count < 99) {
+            last.count += 1;
+            history = history;
+            return;
+          }
+        }
+        history.push({ name, detail, count: 1 });
+        if (history.length > 10) {
+          history.shift();
+        }
+        history = history;
+      };
+    }
+  }
+  return obj;
+};
+$:
+  handlers = wrap(events);
+</script>
+{#if visible}
+    <Styler>
+        <slot />
+        {#each history as { count, detail, name }, i (i)}
+            <div>
+                <div>
+                    <div>{name}</div>
+                    <div class="count">
+                        {#if count > 1}
+                            [{count.toString().padStart(2, "0")}]
+                        {/if}
+                    </div>
+                </div>
+                <div>{detail}</div>
+            </div>
+        {/each}
+    </Styler>
+{/if}
+

package/components/block/controls/events/Events.svelte.d.ts

@@ -0,0 +1,21 @@
+import { SvelteComponentTyped } from "svelte";
+import type { Event } from "../types";
+declare const __propDef: {
+    props: {
+        visible: boolean;
+        events: Event[];
+        handlers: Record<string, (ev: CustomEvent<unknown>) => void> | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export type EventsProps = typeof __propDef.props;
+export type EventsEvents = typeof __propDef.events;
+export type EventsSlots = typeof __propDef.slots;
+export default class Events extends SvelteComponentTyped<EventsProps, EventsEvents, EventsSlots> {
+}
+export {};

package/components/block/controls/events/misc/Styler.svelte

@@ -0,0 +1,83 @@
+<script>import { getTheme } from "../../../../context";
+const dark = getTheme();
+</script>
+<style>
+    div {
+        width: 100%;
+        height: 330px;
+        min-width: 500px;
+        overflow: hidden;
+        display: grid;
+        grid-auto-rows: 30px;
+        box-sizing: border-box;
+    }
+
+    div :global(*),
+    div :global(*::before),
+    div :global(*::after) {
+        box-sizing: inherit;
+    }
+
+    div > :global(div) {
+        display: grid;
+        width: 100%;
+        padding: 2px 0px;
+        grid-template-columns: 1fr 2fr;
+    }
+
+    div > :global(div > div) {
+        padding: 0px 10px;
+    }
+
+    div > :global(div:first-child) {
+        text-align: center;
+    }
+
+    div > :global(div:not(:first-child) > div:first-child) {
+        display: grid;
+        grid-template-columns: 1fr 30px;
+    }
+
+    /* colors */
+    div {
+        --pri-color: hsl(0, 0%, 100%);
+        --sec-color: hsl(210, 29%, 97%);
+        --hover-color: hsl(210, 100%, 90%);
+    }
+
+    div.dark {
+        --pri-color: hsl(213, 26%, 7%);
+        --sec-color: hsl(213, 26%, 11%);
+        --hover-color: hsl(203, 100%, 15%);
+    }
+
+    div {
+        transition: background-color 150ms;
+        background-repeat: repeat;
+        background-size: 100% 60px;
+        background-image: linear-gradient(to bottom, var(--pri-color) 30px, var(--sec-color) 30px);
+    }
+
+    div > :global(div:nth-child(n + 2):hover) {
+        background-color: var(--hover-color);
+    }
+</style>
+
+
+<!--
+    <div> this component
+        <div> Header
+            <div></div>
+            <div></div>
+        </div>
+        <div> Controls
+            <div></div>
+            <div></div>
+        </div>
+        ...
+    </div>
+-->
+<div class:dark={$dark}>
+    <slot />
+</div>
+

package/components/block/controls/{Component.svelte.d.ts → props/Component.svelte.d.ts}

@@ -1,9 +1,9 @@
 import { SvelteComponentTyped } from "svelte";
-import type { Control } from "./types";
+import type { Prop } from "../types";
 declare const __propDef: {
     props: {
         value: any;
-        info: Control;
+        info: Prop;
         depth: number;
         disabled?: boolean | undefined;
         visible?: boolean | undefined;

package/components/block/controls/{Number.svelte.d.ts → props/Number.svelte.d.ts}

@@ -1,9 +1,9 @@
 import { SvelteComponentTyped } from "svelte";
-import type { ControlNumber } from "./types";
+import type { PropNumber } from "../types";
 declare const __propDef: {
     props: {
         value: number | undefined;
-        info: ControlNumber;
+        info: PropNumber;
         depth: number;
         disabled?: boolean | undefined;
         visible?: boolean | undefined;

package/components/block/controls/{Object.svelte.d.ts → props/Object.svelte.d.ts}

@@ -1,10 +1,10 @@
 import { SvelteComponentTyped } from "svelte";
-import type { ValueType } from "../types";
-import type { ControlObject } from "./types";
+import type { ValueType } from "../../types";
+import type { PropObject } from "../types";
 declare const __propDef: {
     props: {
         value: Record<string, ValueType> | undefined;
-        info: ControlObject;
+        info: PropObject;
         depth: number;
         disabled?: boolean | undefined;
         visible?: boolean | undefined;

package/components/block/controls/{Controls.svelte → props/Props.svelte}

@@ -1,13 +1,15 @@
 
 <script>import Component from "./Component.svelte";
-import Header from "./misc/TopHeader.svelte";
 import Styler from "./misc/Styler.svelte";
 export let infos;
 export let values;
+export let visible;
 </script>
 <Styler>
-    <Header />
+    {#if visible}
+        <slot />
+    {/if}
     {#each infos as info}
-        <Component {info} bind:value={values[info.name]} depth={10} visible />
+        <Component {info} bind:value={values[info.name]} depth={10} {visible} />
     {/each}
 </Styler>

package/components/block/controls/props/Props.svelte.d.ts

@@ -0,0 +1,22 @@
+import { SvelteComponentTyped } from "svelte";
+import type { ValueType } from "../../types";
+import type { Prop } from "../types";
+declare const __propDef: {
+    props: {
+        infos: Prop[];
+        values: Record<string, ValueType>;
+        visible: boolean;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export type PropsProps = typeof __propDef.props;
+export type PropsEvents = typeof __propDef.events;
+export type PropsSlots = typeof __propDef.slots;
+export default class Props extends SvelteComponentTyped<PropsProps, PropsEvents, PropsSlots> {
+}
+export {};

package/components/block/controls/{Range.svelte.d.ts → props/Range.svelte.d.ts}

@@ -1,9 +1,9 @@
 import { SvelteComponentTyped } from "svelte";
-import type { ControlRange } from "./types";
+import type { PropRange } from "../types";
 declare const __propDef: {
     props: {
         value: number | undefined;
-        info: ControlRange;
+        info: PropRange;
         depth: number;
         disabled?: boolean | undefined;
         visible?: boolean | undefined;

package/components/block/controls/{Select.svelte.d.ts → props/Select.svelte.d.ts}

@@ -1,9 +1,9 @@
 import { SvelteComponentTyped } from "svelte";
-import type { ControlSelect } from "./types";
+import type { PropSelect } from "../types";
 declare const __propDef: {
     props: {
         value: string | undefined;
-        info: ControlSelect;
+        info: PropSelect;
         depth: number;
         disabled?: boolean | undefined;
         visible?: boolean | undefined;

package/components/block/controls/{Switch.svelte.d.ts → props/Switch.svelte.d.ts}

@@ -1,9 +1,9 @@
 import { SvelteComponentTyped } from "svelte";
-import type { ControlSwitch } from "./types";
+import type { PropSwitch } from "../types";
 declare const __propDef: {
     props: {
         value: boolean | undefined;
-        info: ControlSwitch;
+        info: PropSwitch;
         depth: number;
         disabled?: boolean | undefined;
         visible?: boolean | undefined;

package/components/block/controls/{Text.svelte.d.ts → props/Text.svelte.d.ts}

@@ -1,9 +1,9 @@
 import { SvelteComponentTyped } from "svelte";
-import type { ControlText } from "./types";
+import type { PropText } from "../types";
 declare const __propDef: {
     props: {
         value: string | undefined;
-        info: ControlText;
+        info: PropText;
         depth: number;
         disabled?: boolean | undefined;
         visible?: boolean | undefined;

package/components/block/controls/{Tuple.svelte.d.ts → props/Tuple.svelte.d.ts}

@@ -1,10 +1,10 @@
 import { SvelteComponentTyped } from "svelte";
-import type { ValueType } from "../types";
-import type { ControlTuple } from "./types";
+import type { ValueType } from "../../types";
+import type { PropTuple } from "../types";
 declare const __propDef: {
     props: {
         value: ValueType[] | undefined;
-        info: ControlTuple;
+        info: PropTuple;
         depth: number;
         disabled?: boolean | undefined;
         visible?: boolean | undefined;

package/components/block/controls/{misc → props/misc}/Styler.svelte

@@ -1,4 +1,4 @@
-<script>import { getTheme } from "../../../context";
+<script>import { getTheme } from "../../../../context";
 const dark = getTheme();
 </script>
 <style>
@@ -24,45 +24,44 @@ const dark = getTheme();
         grid-template-columns: minmax(250px, 1fr) 200px 40px;
     }
 
+    div > :global(div:first-child) {
+        text-align: center;
+    }
+
     div > :global(div > div:not(:first-child) > *) {
         width: 100%;
         height: 100%;
     }
 
     /* colors */
-    div > :global(div) {
-        transition: background-color 150ms;
-        background-color: hsl(0, 0%, 100%);
-    }
-
-    div > :global(div:nth-child(even)) {
-        background-color: hsl(210, 29%, 97%);
-    }
-
-    div > :global(div:nth-child(n + 2):hover) {
-        background-color: hsl(210, 100%, 90%);
-    }
-
-    div > :global(div:hover .tooltip) {
-        background-color: hsl(0, 0%, 100%);
-        outline: hsl(0, 100%, 0%) 1px solid;
+    div {
+        --pri-color: hsl(0, 0%, 100%);
+        --sec-color: hsl(210, 29%, 97%);
+        --hover-color: hsl(210, 100%, 90%);
+        --outline-color: hsl(0, 0%, 0%);
     }
 
-    div.dark > :global(div) {
-        background-color: hsl(213, 26%, 7%);
+    div.dark {
+        --pri-color: hsl(213, 26%, 7%);
+        --sec-color: hsl(213, 26%, 11%);
+        --hover-color: hsl(203, 100%, 15%);
+        --outline-color: hsl(200, 6%, 80%);
     }
 
-    div.dark > :global(div:nth-child(even)) {
-        background-color: hsl(213, 26%, 11%);
+    div {
+        transition: background-color 150ms;
+        background-repeat: repeat;
+        background-size: 100% 60px;
+        background-image: linear-gradient(to bottom, var(--pri-color) 30px, var(--sec-color) 30px);
     }
 
-    div.dark > :global(div:nth-child(n + 2):hover) {
-        background-color: hsl(203, 100%, 15%);
+    div > :global(div:nth-child(n + 2):hover) {
+        background-color: var(--hover-color);
     }
 
-    div.dark > :global(div:hover .tooltip) {
-        background-color: hsl(213, 26%, 7%);
-        outline: hsl(200, 6%, 80%) 1px solid;
+    div > :global(div:hover .tooltip) {
+        background-color: var(--pri-color);
+        outline: var(--outline-color) 1px solid;
     }
 </style>
 

package/components/block/controls/props/misc/Styler.svelte.d.ts

@@ -0,0 +1,16 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export type StylerProps = typeof __propDef.props;
+export type StylerEvents = typeof __propDef.events;
+export type StylerSlots = typeof __propDef.slots;
+export default class Styler extends SvelteComponentTyped<StylerProps, StylerEvents, StylerSlots> {
+}
+export {};

package/components/block/controls/props/misc/defaulter.d.ts

@@ -0,0 +1,10 @@
+import type { ValueType } from "../../../types";
+import type { Prop, PropNumber, PropRange, PropSelect, PropSwitch, PropText, PropTuple, PropObject } from "../../types";
+export declare function getDefault(i: PropTuple): ValueType[];
+export declare function getDefault(i: PropObject): Record<string, ValueType>;
+export declare function getDefault(i: PropNumber): number;
+export declare function getDefault(i: PropRange): number;
+export declare function getDefault(i: PropSelect): string;
+export declare function getDefault(i: PropText): string;
+export declare function getDefault(i: PropSwitch): boolean;
+export declare function getDefault(i: Prop): ValueType;

package/components/block/controls/types.d.ts

@@ -1,28 +1,28 @@
-export type ControlTuple = {
+export type PropTuple = {
     name: string;
     type: "tuple";
     // eslint-disable-next-line no-use-before-define
-    values: NonNamedControl[];
+    values: NonNamedProp[];
 };
 
-export type ControlObject = {
+export type PropObject = {
     name: string;
     type: "object";
     // eslint-disable-next-line no-use-before-define
-    values: Control[];
+    values: Prop[];
 };
 
-export type ControlText = {
+export type PropText = {
     name: string;
     type: "text";
 };
 
-export type ControlNumber = {
+export type PropNumber = {
     name: string;
     type: "number";
 };
 
-export type ControlRange = {
+export type PropRange = {
     name: string;
     type: "range";
     min: number;
@@ -30,31 +30,33 @@ export type ControlRange = {
     step: number;
 };
 
-export type ControlSelect = {
+export type PropSelect = {
     name: string;
     type: "select";
     values: string[];
 };
 
-export type ControlSwitch = {
+export type PropSwitch = {
     name: string;
     type: "switch";
 };
 
-export type Control =
-    | ControlTuple
-    | ControlObject
-    | ControlText
-    | ControlNumber
-    | ControlRange
-    | ControlSelect
-    | ControlSwitch;
-
-type NonNamedControl =
-    | Omit<ControlTuple, "name">
-    | Omit<ControlObject, "name">
-    | Omit<ControlText, "name">
-    | Omit<ControlNumber, "name">
-    | Omit<ControlRange, "name">
-    | Omit<ControlSelect, "name">
-    | Omit<ControlSwitch, "name">;
+export type Prop =
+    | PropTuple
+    | PropObject
+    | PropText
+    | PropNumber
+    | PropRange
+    | PropSelect
+    | PropSwitch;
+
+type NonNamedProp =
+    | Omit<PropTuple, "name">
+    | Omit<PropObject, "name">
+    | Omit<PropText, "name">
+    | Omit<PropNumber, "name">
+    | Omit<PropRange, "name">
+    | Omit<PropSelect, "name">
+    | Omit<PropSwitch, "name">;
+
+export type Event = string;

package/index.d.ts

@@ -1,6 +1,6 @@
 export { renamer } from "./components/navigation/utils/renamer";
 export { sorter } from "./components/navigation/utils/sorter";
-export type { Control } from "./components/block/controls/types";
+export type { Prop, Event } from "./components/block/controls/types";
 export { default as Layout } from "./components/Layout.svelte";
 export { default as Instance } from "./components/block/Instance.svelte";
 export { default as Block } from "./components/block/Block.svelte";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nil-/doc",
-  "version": "0.2.45",
+  "version": "0.2.46",
   "author": {
     "email": "njaldea@gmail.com",
     "name": "Neil Aldea"

package/components/block/controls/Controls.svelte.d.ts

@@ -1,19 +0,0 @@
-import { SvelteComponentTyped } from "svelte";
-import type { ValueType } from "../types";
-import type { Control } from "./types";
-declare const __propDef: {
-    props: {
-        infos: Control[];
-        values: Record<string, ValueType>;
-    };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-export type ControlsProps = typeof __propDef.props;
-export type ControlsEvents = typeof __propDef.events;
-export type ControlsSlots = typeof __propDef.slots;
-export default class Controls extends SvelteComponentTyped<ControlsProps, ControlsEvents, ControlsSlots> {
-}
-export {};

package/components/block/controls/misc/TopHeader.svelte

@@ -1,12 +0,0 @@
-<style>
-    div > div {
-        text-align: center;
-    }
-</style>
-
-<div>
-    <div>Name</div>
-    <div>Value</div>
-    <div>Use</div>
-</div>
-

package/components/block/controls/misc/TopHeader.svelte.d.ts

@@ -1,23 +0,0 @@
-/** @typedef {typeof __propDef.props}  TopHeaderProps */
-/** @typedef {typeof __propDef.events}  TopHeaderEvents */
-/** @typedef {typeof __propDef.slots}  TopHeaderSlots */
-export default class TopHeader extends SvelteComponentTyped<{
-    [x: string]: never;
-}, {
-    [evt: string]: CustomEvent<any>;
-}, {}> {
-}
-export type TopHeaderProps = typeof __propDef.props;
-export type TopHeaderEvents = typeof __propDef.events;
-export type TopHeaderSlots = typeof __propDef.slots;
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: {
-        [x: string]: never;
-    };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-export {};

package/components/block/controls/misc/defaulter.d.ts

@@ -1,10 +0,0 @@
-import type { ValueType } from "../../types";
-import type { Control, ControlNumber, ControlRange, ControlSelect, ControlSwitch, ControlText, ControlTuple, ControlObject } from "../types";
-export declare function getDefault(i: ControlTuple): ValueType[];
-export declare function getDefault(i: ControlObject): Record<string, ValueType>;
-export declare function getDefault(i: ControlNumber): number;
-export declare function getDefault(i: ControlRange): number;
-export declare function getDefault(i: ControlSelect): string;
-export declare function getDefault(i: ControlText): string;
-export declare function getDefault(i: ControlSwitch): boolean;
-export declare function getDefault(i: Control): ValueType;