elbe-ui 1.0.8 → 2.0.0

package/dist/ui/theme/subthemes/color/colors/_color_scheme.d.ts

@@ -0,0 +1,256 @@
+import { KindColor } from "./_color_kind";
+import { LayerColor } from "./_color_layer";
+import { ColorThemeSeed } from "./colors";
+export declare const SchemeColor: {
+    is: (v: any) => v is import("./_colordef").ElbeColor<"state", {
+        primary: KindColor;
+        secondary: KindColor;
+        inverse: KindColor;
+    }, Omit<{
+        type: ["kind", ...string[]];
+    } & {
+        accent: import("./_color_manner").MannerColor;
+        info: import("./_color_manner").MannerColor;
+        success: import("./_color_manner").MannerColor;
+        warning: import("./_color_manner").MannerColor;
+        error: import("./_color_manner").MannerColor;
+    } & Omit<{
+        type: ["manner", ...string[]];
+    } & {
+        major: import("./_color_state").StateColor;
+        minor: import("./_color_state").StateColor;
+        flat: import("./_color_state").StateColor;
+        plain: import("./_color_state").StateColor;
+    } & Omit<{
+        type: ["state", ...string[]];
+    } & {
+        neutral: LayerColor;
+        hover: LayerColor;
+        active: LayerColor;
+        disabled: LayerColor;
+    } & Omit<{
+        type: ["layer", ...string[]];
+    } & {
+        back: import("./_color_rgba").RGBAColor;
+        front: import("./_color_rgba").RGBAColor;
+        border: import("./_color_rgba").RGBAColor;
+    } & Omit<{
+        interLayer: (other: import("./_color_rgba").RGBAColor, factor: number, factorFront?: number, factorBorder?: number) => LayerColor;
+        interLayerLayer: (other: LayerColor, factor: number, factorFront?: number, factorBorder?: number) => LayerColor;
+        mirrorBrightnessLayer: (factor?: number, factorBack?: number, factorBorder?: number) => LayerColor;
+        desaturatedLayer: () => LayerColor;
+        withBack: (back: import("./_color_rgba").RGBAColor) => LayerColor;
+        withFront: (front: import("./_color_rgba").RGBAColor) => LayerColor;
+        withBorder: (border: import("./_color_rgba").RGBAColor) => LayerColor;
+    } & {
+        type: ["rgba", ...string[]];
+    } & {
+        red: number;
+        green: number;
+        blue: number;
+        alpha: number;
+    } & Omit<{
+        asCss: () => string;
+        hex: () => string;
+        isDark: () => boolean;
+        luminance: () => number;
+        desaturated: (f?: number) => import("./_colordef").ElbeColor<"rgba", {
+            red: number;
+            green: number;
+            blue: number;
+            alpha: number;
+        }, Omit</*elided*/ any, "type">>;
+        withAlpha: (alpha: number) => import("./_colordef").ElbeColor<"rgba", {
+            red: number;
+            green: number;
+            blue: number;
+            alpha: number;
+        }, Omit</*elided*/ any, "type">>;
+        inter: (other: import("./_color_rgba").RGBAColor, factor: number) => import("./_colordef").ElbeColor<"rgba", {
+            red: number;
+            green: number;
+            blue: number;
+            alpha: number;
+        }, Omit</*elided*/ any, "type">>;
+        mirrorBrightness: (factor?: number) => import("./_colordef").ElbeColor<"rgba", {
+            red: number;
+            green: number;
+            blue: number;
+            alpha: number;
+        }, Omit</*elided*/ any, "type">>;
+        hasWCAGContrast: (color: import("./_color_rgba").RGBAColor) => boolean;
+        contrastRatio: (color: import("./_color_rgba").RGBAColor) => number;
+    }, "type">, "type">, "type">, "type">, "type">, "type">>;
+    new: (data: {
+        primary: KindColor;
+        secondary: KindColor;
+        inverse: KindColor;
+    }) => import("./_colordef").ElbeColor<"state", {
+        primary: KindColor;
+        secondary: KindColor;
+        inverse: KindColor;
+    }, Omit<{
+        type: ["kind", ...string[]];
+    } & {
+        accent: import("./_color_manner").MannerColor;
+        info: import("./_color_manner").MannerColor;
+        success: import("./_color_manner").MannerColor;
+        warning: import("./_color_manner").MannerColor;
+        error: import("./_color_manner").MannerColor;
+    } & Omit<{
+        type: ["manner", ...string[]];
+    } & {
+        major: import("./_color_state").StateColor;
+        minor: import("./_color_state").StateColor;
+        flat: import("./_color_state").StateColor;
+        plain: import("./_color_state").StateColor;
+    } & Omit<{
+        type: ["state", ...string[]];
+    } & {
+        neutral: LayerColor;
+        hover: LayerColor;
+        active: LayerColor;
+        disabled: LayerColor;
+    } & Omit<{
+        type: ["layer", ...string[]];
+    } & {
+        back: import("./_color_rgba").RGBAColor;
+        front: import("./_color_rgba").RGBAColor;
+        border: import("./_color_rgba").RGBAColor;
+    } & Omit<{
+        interLayer: (other: import("./_color_rgba").RGBAColor, factor: number, factorFront?: number, factorBorder?: number) => LayerColor;
+        interLayerLayer: (other: LayerColor, factor: number, factorFront?: number, factorBorder?: number) => LayerColor;
+        mirrorBrightnessLayer: (factor?: number, factorBack?: number, factorBorder?: number) => LayerColor;
+        desaturatedLayer: () => LayerColor;
+        withBack: (back: import("./_color_rgba").RGBAColor) => LayerColor;
+        withFront: (front: import("./_color_rgba").RGBAColor) => LayerColor;
+        withBorder: (border: import("./_color_rgba").RGBAColor) => LayerColor;
+    } & {
+        type: ["rgba", ...string[]];
+    } & {
+        red: number;
+        green: number;
+        blue: number;
+        alpha: number;
+    } & Omit<{
+        asCss: () => string;
+        hex: () => string;
+        isDark: () => boolean;
+        luminance: () => number;
+        desaturated: (f?: number) => import("./_colordef").ElbeColor<"rgba", {
+            red: number;
+            green: number;
+            blue: number;
+            alpha: number;
+        }, Omit</*elided*/ any, "type">>;
+        withAlpha: (alpha: number) => import("./_colordef").ElbeColor<"rgba", {
+            red: number;
+            green: number;
+            blue: number;
+            alpha: number;
+        }, Omit</*elided*/ any, "type">>;
+        inter: (other: import("./_color_rgba").RGBAColor, factor: number) => import("./_colordef").ElbeColor<"rgba", {
+            red: number;
+            green: number;
+            blue: number;
+            alpha: number;
+        }, Omit</*elided*/ any, "type">>;
+        mirrorBrightness: (factor?: number) => import("./_colordef").ElbeColor<"rgba", {
+            red: number;
+            green: number;
+            blue: number;
+            alpha: number;
+        }, Omit</*elided*/ any, "type">>;
+        hasWCAGContrast: (color: import("./_color_rgba").RGBAColor) => boolean;
+        contrastRatio: (color: import("./_color_rgba").RGBAColor) => number;
+    }, "type">, "type">, "type">, "type">, "type">, "type">>;
+    _typeHint: {
+        color: import("./_colordef").ElbeColor<"state", {
+            primary: KindColor;
+            secondary: KindColor;
+            inverse: KindColor;
+        }, Omit<{
+            type: ["kind", ...string[]];
+        } & {
+            accent: import("./_color_manner").MannerColor;
+            info: import("./_color_manner").MannerColor;
+            success: import("./_color_manner").MannerColor;
+            warning: import("./_color_manner").MannerColor;
+            error: import("./_color_manner").MannerColor;
+        } & Omit<{
+            type: ["manner", ...string[]];
+        } & {
+            major: import("./_color_state").StateColor;
+            minor: import("./_color_state").StateColor;
+            flat: import("./_color_state").StateColor;
+            plain: import("./_color_state").StateColor;
+        } & Omit<{
+            type: ["state", ...string[]];
+        } & {
+            neutral: LayerColor;
+            hover: LayerColor;
+            active: LayerColor;
+            disabled: LayerColor;
+        } & Omit<{
+            type: ["layer", ...string[]];
+        } & {
+            back: import("./_color_rgba").RGBAColor;
+            front: import("./_color_rgba").RGBAColor;
+            border: import("./_color_rgba").RGBAColor;
+        } & Omit<{
+            interLayer: (other: import("./_color_rgba").RGBAColor, factor: number, factorFront?: number, factorBorder?: number) => LayerColor;
+            interLayerLayer: (other: LayerColor, factor: number, factorFront?: number, factorBorder?: number) => LayerColor;
+            mirrorBrightnessLayer: (factor?: number, factorBack?: number, factorBorder?: number) => LayerColor;
+            desaturatedLayer: () => LayerColor;
+            withBack: (back: import("./_color_rgba").RGBAColor) => LayerColor;
+            withFront: (front: import("./_color_rgba").RGBAColor) => LayerColor;
+            withBorder: (border: import("./_color_rgba").RGBAColor) => LayerColor;
+        } & {
+            type: ["rgba", ...string[]];
+        } & {
+            red: number;
+            green: number;
+            blue: number;
+            alpha: number;
+        } & Omit<{
+            asCss: () => string;
+            hex: () => string;
+            isDark: () => boolean;
+            luminance: () => number;
+            desaturated: (f?: number) => import("./_colordef").ElbeColor<"rgba", {
+                red: number;
+                green: number;
+                blue: number;
+                alpha: number;
+            }, Omit</*elided*/ any, "type">>;
+            withAlpha: (alpha: number) => import("./_colordef").ElbeColor<"rgba", {
+                red: number;
+                green: number;
+                blue: number;
+                alpha: number;
+            }, Omit</*elided*/ any, "type">>;
+            inter: (other: import("./_color_rgba").RGBAColor, factor: number) => import("./_colordef").ElbeColor<"rgba", {
+                red: number;
+                green: number;
+                blue: number;
+                alpha: number;
+            }, Omit</*elided*/ any, "type">>;
+            mirrorBrightness: (factor?: number) => import("./_colordef").ElbeColor<"rgba", {
+                red: number;
+                green: number;
+                blue: number;
+                alpha: number;
+            }, Omit</*elided*/ any, "type">>;
+            hasWCAGContrast: (color: import("./_color_rgba").RGBAColor) => boolean;
+            contrastRatio: (color: import("./_color_rgba").RGBAColor) => number;
+        }, "type">, "type">, "type">, "type">, "type">, "type">>;
+        data: {
+            primary: KindColor;
+            secondary: KindColor;
+            inverse: KindColor;
+        };
+    };
+} & {
+    generate(path: string[], seed: ColorThemeSeed, base: LayerColor): SchemeColor;
+};
+export type SchemeColor = (typeof SchemeColor)["_typeHint"]["color"];

package/dist/ui/theme/subthemes/color/colors/_color_scheme.js

@@ -0,0 +1,17 @@
+import { KindColor } from "./_color_kind";
+import { defineColor } from "./_colordef";
+export const SchemeColor = defineColor({
+    type: "state",
+    static: {
+        generate(path, seed, base) {
+            const m = seed.scheme;
+            return SchemeColor.new({
+                primary: KindColor.generate([...path, "primary"], seed, m.primary({ path, seed, base })),
+                secondary: KindColor.generate([...path, "secondary"], seed, m.secondary({ path, seed, base })),
+                inverse: KindColor.generate([...path, "inverse"], seed, m.inverse({ path, seed, base })),
+            });
+        },
+    },
+    parent: (data) => data.primary,
+    compute: (_) => ({}),
+});

package/dist/ui/theme/subthemes/color/colors/_color_state.d.ts

@@ -0,0 +1,252 @@
+import { LayerColor } from "./_color_layer";
+import { ColorThemeSeed } from "./colors";
+export declare const StateColor: {
+    is: (v: any) => v is import("./_colordef").ElbeColor<"state", {
+        neutral: LayerColor;
+        hover: LayerColor;
+        active: LayerColor;
+        disabled: LayerColor;
+    }, Omit<{
+        type: ["layer", ...string[]];
+    } & {
+        back: import("./_color_rgba").RGBAColor;
+        front: import("./_color_rgba").RGBAColor;
+        border: import("./_color_rgba").RGBAColor;
+    } & Omit<{
+        interLayer: (other: import("./_color_rgba").RGBAColor, factor: number, factorFront?: number, factorBorder?: number) => LayerColor;
+        interLayerLayer: (other: LayerColor, factor: number, factorFront?: number, factorBorder?: number) => LayerColor;
+        mirrorBrightnessLayer: (factor?: number, factorBack?: number, factorBorder?: number) => LayerColor;
+        desaturatedLayer: () => LayerColor;
+        withBack: (back: import("./_color_rgba").RGBAColor) => LayerColor;
+        withFront: (front: import("./_color_rgba").RGBAColor) => LayerColor;
+        withBorder: (border: import("./_color_rgba").RGBAColor) => LayerColor;
+    } & {
+        type: ["rgba", ...string[]];
+    } & {
+        red: number;
+        green: number;
+        blue: number;
+        alpha: number;
+    } & Omit<{
+        asCss: () => string;
+        hex: () => string;
+        isDark: () => boolean;
+        luminance: () => number;
+        desaturated: (f?: number) => import("./_colordef").ElbeColor<"rgba", {
+            red: number;
+            green: number;
+            blue: number;
+            alpha: number;
+        }, Omit</*elided*/ any, "type">>;
+        withAlpha: (alpha: number) => import("./_colordef").ElbeColor<"rgba", {
+            red: number;
+            green: number;
+            blue: number;
+            alpha: number;
+        }, Omit</*elided*/ any, "type">>;
+        inter: (other: import("./_color_rgba").RGBAColor, factor: number) => import("./_colordef").ElbeColor<"rgba", {
+            red: number;
+            green: number;
+            blue: number;
+            alpha: number;
+        }, Omit</*elided*/ any, "type">>;
+        mirrorBrightness: (factor?: number) => import("./_colordef").ElbeColor<"rgba", {
+            red: number;
+            green: number;
+            blue: number;
+            alpha: number;
+        }, Omit</*elided*/ any, "type">>;
+        hasWCAGContrast: (color: import("./_color_rgba").RGBAColor) => boolean;
+        contrastRatio: (color: import("./_color_rgba").RGBAColor) => number;
+    }, "type">, "type">, "type">>;
+    new: (data: {
+        neutral: LayerColor;
+        hover: LayerColor;
+        active: LayerColor;
+        disabled: LayerColor;
+    }) => import("./_colordef").ElbeColor<"state", {
+        neutral: LayerColor;
+        hover: LayerColor;
+        active: LayerColor;
+        disabled: LayerColor;
+    }, Omit<{
+        type: ["layer", ...string[]];
+    } & {
+        back: import("./_color_rgba").RGBAColor;
+        front: import("./_color_rgba").RGBAColor;
+        border: import("./_color_rgba").RGBAColor;
+    } & Omit<{
+        interLayer: (other: import("./_color_rgba").RGBAColor, factor: number, factorFront?: number, factorBorder?: number) => LayerColor;
+        interLayerLayer: (other: LayerColor, factor: number, factorFront?: number, factorBorder?: number) => LayerColor;
+        mirrorBrightnessLayer: (factor?: number, factorBack?: number, factorBorder?: number) => LayerColor;
+        desaturatedLayer: () => LayerColor;
+        withBack: (back: import("./_color_rgba").RGBAColor) => LayerColor;
+        withFront: (front: import("./_color_rgba").RGBAColor) => LayerColor;
+        withBorder: (border: import("./_color_rgba").RGBAColor) => LayerColor;
+    } & {
+        type: ["rgba", ...string[]];
+    } & {
+        red: number;
+        green: number;
+        blue: number;
+        alpha: number;
+    } & Omit<{
+        asCss: () => string;
+        hex: () => string;
+        isDark: () => boolean;
+        luminance: () => number;
+        desaturated: (f?: number) => import("./_colordef").ElbeColor<"rgba", {
+            red: number;
+            green: number;
+            blue: number;
+            alpha: number;
+        }, Omit</*elided*/ any, "type">>;
+        withAlpha: (alpha: number) => import("./_colordef").ElbeColor<"rgba", {
+            red: number;
+            green: number;
+            blue: number;
+            alpha: number;
+        }, Omit</*elided*/ any, "type">>;
+        inter: (other: import("./_color_rgba").RGBAColor, factor: number) => import("./_colordef").ElbeColor<"rgba", {
+            red: number;
+            green: number;
+            blue: number;
+            alpha: number;
+        }, Omit</*elided*/ any, "type">>;
+        mirrorBrightness: (factor?: number) => import("./_colordef").ElbeColor<"rgba", {
+            red: number;
+            green: number;
+            blue: number;
+            alpha: number;
+        }, Omit</*elided*/ any, "type">>;
+        hasWCAGContrast: (color: import("./_color_rgba").RGBAColor) => boolean;
+        contrastRatio: (color: import("./_color_rgba").RGBAColor) => number;
+    }, "type">, "type">, "type">>;
+    _typeHint: {
+        color: import("./_colordef").ElbeColor<"state", {
+            neutral: LayerColor;
+            hover: LayerColor;
+            active: LayerColor;
+            disabled: LayerColor;
+        }, Omit<{
+            type: ["layer", ...string[]];
+        } & {
+            back: import("./_color_rgba").RGBAColor;
+            front: import("./_color_rgba").RGBAColor;
+            border: import("./_color_rgba").RGBAColor;
+        } & Omit<{
+            interLayer: (other: import("./_color_rgba").RGBAColor, factor: number, factorFront?: number, factorBorder?: number) => LayerColor;
+            interLayerLayer: (other: LayerColor, factor: number, factorFront?: number, factorBorder?: number) => LayerColor;
+            mirrorBrightnessLayer: (factor?: number, factorBack?: number, factorBorder?: number) => LayerColor;
+            desaturatedLayer: () => LayerColor;
+            withBack: (back: import("./_color_rgba").RGBAColor) => LayerColor;
+            withFront: (front: import("./_color_rgba").RGBAColor) => LayerColor;
+            withBorder: (border: import("./_color_rgba").RGBAColor) => LayerColor;
+        } & {
+            type: ["rgba", ...string[]];
+        } & {
+            red: number;
+            green: number;
+            blue: number;
+            alpha: number;
+        } & Omit<{
+            asCss: () => string;
+            hex: () => string;
+            isDark: () => boolean;
+            luminance: () => number;
+            desaturated: (f?: number) => import("./_colordef").ElbeColor<"rgba", {
+                red: number;
+                green: number;
+                blue: number;
+                alpha: number;
+            }, Omit</*elided*/ any, "type">>;
+            withAlpha: (alpha: number) => import("./_colordef").ElbeColor<"rgba", {
+                red: number;
+                green: number;
+                blue: number;
+                alpha: number;
+            }, Omit</*elided*/ any, "type">>;
+            inter: (other: import("./_color_rgba").RGBAColor, factor: number) => import("./_colordef").ElbeColor<"rgba", {
+                red: number;
+                green: number;
+                blue: number;
+                alpha: number;
+            }, Omit</*elided*/ any, "type">>;
+            mirrorBrightness: (factor?: number) => import("./_colordef").ElbeColor<"rgba", {
+                red: number;
+                green: number;
+                blue: number;
+                alpha: number;
+            }, Omit</*elided*/ any, "type">>;
+            hasWCAGContrast: (color: import("./_color_rgba").RGBAColor) => boolean;
+            contrastRatio: (color: import("./_color_rgba").RGBAColor) => number;
+        }, "type">, "type">, "type">>;
+        data: {
+            neutral: LayerColor;
+            hover: LayerColor;
+            active: LayerColor;
+            disabled: LayerColor;
+        };
+    };
+} & {
+    generate(path: string[], seed: ColorThemeSeed, context: LayerColor, style: LayerColor, fromFront?: boolean): StateColor;
+    fromBack(back: string): import("./_colordef").ElbeColor<"state", {
+        neutral: LayerColor;
+        hover: LayerColor;
+        active: LayerColor;
+        disabled: LayerColor;
+    }, Omit<{
+        type: ["layer", ...string[]];
+    } & {
+        back: import("./_color_rgba").RGBAColor;
+        front: import("./_color_rgba").RGBAColor;
+        border: import("./_color_rgba").RGBAColor;
+    } & Omit<{
+        interLayer: (other: import("./_color_rgba").RGBAColor, factor: number, factorFront?: number, factorBorder?: number) => LayerColor;
+        interLayerLayer: (other: LayerColor, factor: number, factorFront?: number, factorBorder?: number) => LayerColor;
+        mirrorBrightnessLayer: (factor?: number, factorBack?: number, factorBorder?: number) => LayerColor;
+        desaturatedLayer: () => LayerColor;
+        withBack: (back: import("./_color_rgba").RGBAColor) => LayerColor;
+        withFront: (front: import("./_color_rgba").RGBAColor) => LayerColor;
+        withBorder: (border: import("./_color_rgba").RGBAColor) => LayerColor;
+    } & {
+        type: ["rgba", ...string[]];
+    } & {
+        red: number;
+        green: number;
+        blue: number;
+        alpha: number;
+    } & Omit<{
+        asCss: () => string;
+        hex: () => string;
+        isDark: () => boolean;
+        luminance: () => number;
+        desaturated: (f?: number) => import("./_colordef").ElbeColor<"rgba", {
+            red: number;
+            green: number;
+            blue: number;
+            alpha: number;
+        }, Omit</*elided*/ any, "type">>;
+        withAlpha: (alpha: number) => import("./_colordef").ElbeColor<"rgba", {
+            red: number;
+            green: number;
+            blue: number;
+            alpha: number;
+        }, Omit</*elided*/ any, "type">>;
+        inter: (other: import("./_color_rgba").RGBAColor, factor: number) => import("./_colordef").ElbeColor<"rgba", {
+            red: number;
+            green: number;
+            blue: number;
+            alpha: number;
+        }, Omit</*elided*/ any, "type">>;
+        mirrorBrightness: (factor?: number) => import("./_colordef").ElbeColor<"rgba", {
+            red: number;
+            green: number;
+            blue: number;
+            alpha: number;
+        }, Omit</*elided*/ any, "type">>;
+        hasWCAGContrast: (color: import("./_color_rgba").RGBAColor) => boolean;
+        contrastRatio: (color: import("./_color_rgba").RGBAColor) => number;
+    }, "type">, "type">, "type">>;
+};
+export type StateColor = (typeof StateColor)["_typeHint"]["color"];

package/dist/ui/theme/subthemes/color/colors/_color_state.js

@@ -0,0 +1,49 @@
+import { LayerColor } from "./_color_layer";
+import { defineColor } from "./_colordef";
+export const StateColor = defineColor({
+    type: "state",
+    static: {
+        generate(path, seed, context, style, fromFront) {
+            var _a, _b;
+            function _make(factor) {
+                const front = style.front;
+                return LayerColor.new({
+                    back: (fromFront
+                        ? context.back.inter(front, factor)
+                        : style.back.inter(context.back.mirrorBrightness(), factor)).withAlpha(Math.max(style.back.alpha, 0.2)),
+                    front,
+                    border: style.border,
+                });
+            }
+            return StateColor.new({
+                neutral: style,
+                hover: (_a = _make(0.05)) !== null && _a !== void 0 ? _a : style,
+                active: (_b = _make(0.15)) !== null && _b !== void 0 ? _b : style,
+                disabled: path.includes("plain") || path.includes("flat")
+                    ? style.interLayer(style.back, 0.35, 0.5, 0.35).desaturatedLayer()
+                    : style.desaturatedLayer().mirrorBrightnessLayer(0.05),
+            });
+        },
+        fromBack(back) {
+            var _a, _b;
+            const style = LayerColor.fromBack(back);
+            function _make(factor) {
+                return LayerColor.new({
+                    back: style.back
+                        .inter(style.mirrorBrightness(), factor)
+                        .withAlpha(Math.max(style.back.alpha, 0.2)),
+                    front: style.front,
+                    border: style.border,
+                });
+            }
+            return StateColor.new({
+                neutral: style,
+                hover: (_a = _make(0.05)) !== null && _a !== void 0 ? _a : style,
+                active: (_b = _make(0.15)) !== null && _b !== void 0 ? _b : style,
+                disabled: style.desaturatedLayer(),
+            });
+        },
+    },
+    parent: (data) => data.neutral,
+    compute: (_) => ({}),
+});

package/dist/ui/theme/subthemes/color/colors/_colordef.d.ts

@@ -0,0 +1,22 @@
+export type ElbeColor<T extends string, Data extends Dict<any>, Computed extends Dict<any>> = {
+    type: [T, ...string[]];
+} & Data & Computed;
+export declare function defineColor<Name extends string, Data extends Dict<any>, Computed extends Dict<any>, Parent extends Dict<any>, T extends ElbeColor<Name, Data, Omit<Computed & Parent, "type">>, Static extends Dict<any> = {}>(p: {
+    type: Name;
+    static: Static;
+    compute: (data: Data) => Computed;
+    parent: (data: Data) => Parent;
+}): {
+    is: (v: any) => v is T;
+    new: (data: Data) => T;
+    _typeHint: {
+        color: T;
+        data: Data;
+    };
+} & Static;
+export type ColorDataKeys<T extends {
+    _typeHint: {
+        data: Dict<any>;
+    };
+}> = keyof T["_typeHint"]["data"];
+export declare function withoutType<T extends Dict<any>>(obj: T): Omit<T, "type">;

package/dist/ui/theme/subthemes/color/colors/_colordef.js

@@ -0,0 +1,34 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+export function defineColor(p) {
+    function _new(data) {
+        var _a;
+        const comp = p.compute(data);
+        const parent = p.parent(data);
+        return Object.assign(Object.assign(Object.assign(Object.assign({}, data), comp), parent), { type: [p.type, ...((_a = parent.type) !== null && _a !== void 0 ? _a : [])] });
+    }
+    function is(v) {
+        return (v &&
+            typeof v === "object" &&
+            v.type &&
+            Array.isArray(v.type) &&
+            v.type.includes(p.type));
+    }
+    return Object.assign({ is, new: _new, _typeHint: {
+            color: undefined,
+            data: undefined,
+        } }, p.static);
+}
+export function withoutType(obj) {
+    const { type } = obj, rest = __rest(obj, ["type"]);
+    return rest;
+}