yuyeon 0.1.0-rc.9 → 0.1.0

package/types/shims.d.ts

@@ -1,48 +1,5 @@
-import {
-  YAlert,
-  YApp,
-  YBadge,
-  YButton,
-  YCard,
-  YCardBody,
-  YCardFooter,
-  YCardHeader,
-  YCheckbox,
-  YChip,
-  YDataTable,
-  YDataTableServer,
-  YDateCalendar,
-  YDatePicker,
-  YDialog,
-  YDividePanel,
-  YDivider,
-  YDropdown,
-  YExpandHTransition,
-  YExpandVTransition,
-  YFieldInput,
-  YForm,
-  YIcon,
-  YInput,
-  YInputCheckbox,
-  YLayer,
-  YList,
-  YListItem,
-  YMenu,
-  YMonthPicker,
-  YPagination,
-  YProgressBar,
-  YSelect,
-  YSnackbar,
-  YSpinnerRing,
-  YSwitch,
-  YTab,
-  YTable,
-  YTabs,
-  YTextarea,
-  YTooltip,
-  YTreeView,
-  YTreeViewNode,
-} from 'yuyeon/components';
+import { YAlert, YApp, YBadge, YButton, YCard, YCardBody, YCardFooter, YCardHeader, YCheckbox, YChip, YDataTable, YDataTableServer, YDateCalendar, YDatePicker, YDialog, YDividePanel, YDivider, YDropdown, YExpandHTransition, YExpandVTransition, YFieldInput, YForm, YHover, YIcon, YInput, YInputCheckbox, YIpv4Field, YLayer, YList, YListItem, YMenu, YMonthPicker, YPagination, YProgressBar, YSelect, YSnackbar, YSpinnerRing, YSwitch, YTab, YTable, YTabs, YTextarea, YTooltip, YTreeView, YTreeViewNode, YTi } from 'yuyeon/components';
+
 
 declare module '@vue/runtime-core' {
   export interface GlobalComponents {
@@ -90,5 +47,8 @@ declare module '@vue/runtime-core' {
     YDatePicker: typeof YDatePicker;
     YMonthPicker: typeof YMonthPicker;
     YBadge: typeof YBadge;
+    YIpv4Field: typeof YIpv4Field;
+    YHover: typeof YHover;
+    YTi: typeof YTi;
   }
 }

package/types/types/index.d.ts

@@ -1,5 +1,6 @@
 import { HTMLAttributes } from '@vue/runtime-dom';
-import type { ComponentPublicInstance, FunctionalComponent } from 'vue';
+import { ComponentPublicInstance, FunctionalComponent } from 'vue';
+
 export type CandidateKey = string | number;
 export type JSXComponent<Props = any> = FunctionalComponent<Props | Props & HTMLAttributes> | {
     new (): ComponentPublicInstance<Props | Props & HTMLAttributes>;

package/types/util/anchor.d.ts

@@ -15,7 +15,7 @@ export type ParsedAnchor = {
 };
 /** Parse a raw anchor string into an object */
 export declare function parseAnchor(anchor: Anchor, isRtl: boolean): ParsedAnchor;
-export declare function toPhysical(str: 'center' | Tblock | Tinline, isRtl: boolean): "top" | "right" | "bottom" | "left" | "center";
+export declare function toPhysical(str: 'center' | Tblock | Tinline, isRtl: boolean): "top" | "bottom" | "left" | "right" | "center";
 export declare function flipSide(anchor: ParsedAnchor): ParsedAnchor;
 export declare function flipAlign(anchor: ParsedAnchor): ParsedAnchor;
 export declare function flipCorner(anchor: ParsedAnchor): ParsedAnchor;

package/types/util/color/contrast/contrast.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Utility methods for calculating contrast given two colors, or calculating a
+ * color given one color and a contrast ratio.
+ *
+ * Contrast ratio is calculated using XYZ's Y. When linearized to match human
+ * perception, Y becomes HCT's tone and L*a*b*'s' L*. Informally, this is the
+ * lightness of a color.
+ *
+ * Methods refer to tone, T in the the HCT color space.
+ * Tone is equivalent to L* in the L*a*b* color space, or L in the LCH color
+ * space.
+ */
+export declare class Contrast {
+    /**
+     * Returns a contrast ratio, which ranges from 1 to 21.
+     *
+     * @param toneA Tone between 0 and 100. Values outside will be clamped.
+     * @param toneB Tone between 0 and 100. Values outside will be clamped.
+     */
+    static ratioOfTones(toneA: number, toneB: number): number;
+    static ratioOfYs(y1: number, y2: number): number;
+    /**
+     * Returns a tone >= tone parameter that ensures ratio parameter.
+     * Return value is between 0 and 100.
+     * Returns -1 if ratio cannot be achieved with tone parameter.
+     *
+     * @param tone Tone return value must contrast with.
+     * Range is 0 to 100. Invalid values will result in -1 being returned.
+     * @param ratio Contrast ratio of return value and tone.
+     * Range is 1 to 21, invalid values have undefined behavior.
+     */
+    static lighter(tone: number, ratio: number): number;
+    /**
+     * Returns a tone <= tone parameter that ensures ratio parameter.
+     * Return value is between 0 and 100.
+     * Returns -1 if ratio cannot be achieved with tone parameter.
+     *
+     * @param tone Tone return value must contrast with.
+     * Range is 0 to 100. Invalid values will result in -1 being returned.
+     * @param ratio Contrast ratio of return value and tone.
+     * Range is 1 to 21, invalid values have undefined behavior.
+     */
+    static darker(tone: number, ratio: number): number;
+    /**
+     * Returns a tone >= tone parameter that ensures ratio parameter.
+     * Return value is between 0 and 100.
+     * Returns 100 if ratio cannot be achieved with tone parameter.
+     *
+     * This method is unsafe because the returned value is guaranteed to be in
+     * bounds for tone, i.e. between 0 and 100. However, that value may not reach
+     * the ratio with tone. For example, there is no color lighter than T100.
+     *
+     * @param tone Tone return value must contrast with.
+     * Range is 0 to 100. Invalid values will result in 100 being returned.
+     * @param ratio Desired contrast ratio of return value and tone parameter.
+     * Range is 1 to 21, invalid values have undefined behavior.
+     */
+    static lighterUnsafe(tone: number, ratio: number): number;
+    /**
+     * Returns a tone >= tone parameter that ensures ratio parameter.
+     * Return value is between 0 and 100.
+     * Returns 100 if ratio cannot be achieved with tone parameter.
+     *
+     * This method is unsafe because the returned value is guaranteed to be in
+     * bounds for tone, i.e. between 0 and 100. However, that value may not reach
+     * the [ratio with [tone]. For example, there is no color darker than T0.
+     *
+     * @param tone Tone return value must contrast with.
+     * Range is 0 to 100. Invalid values will result in 0 being returned.
+     * @param ratio Desired contrast ratio of return value and tone parameter.
+     * Range is 1 to 21, invalid values have undefined behavior.
+     */
+    static darkerUnsafe(tone: number, ratio: number): number;
+}

package/types/util/color/conversion.d.ts

@@ -1,4 +1,5 @@
 import { Rgba } from './types';
+
 export declare function rgbFromHex(color: string): number[] | undefined;
 export declare function hexFromRgb(red: number, green: number, blue: number): string;
 export declare function hexFromArgb(argb: number): string;

package/types/util/color/hct/cam16.d.ts

@@ -1,20 +1,5 @@
-/**
- * @license
- * Copyright 2021 Google LLC
- *
- * 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 { ViewingConditions } from './viewing_conditions';
+import { ViewingConditions } from './viewing-conditions';
+
 /**
  * CAM16, a color appearance model. Colors are not just defined by their hex
  * code, but rather, a hex code and viewing conditions.

package/types/util/color/hct/hct-solver.d.ts

@@ -0,0 +1,131 @@
+import { Cam16 } from './cam16';
+
+/**
+ * A class that solves the HCT equation.
+ */
+export declare class HctSolver {
+    static SCALED_DISCOUNT_FROM_LINRGB: number[][];
+    static LINRGB_FROM_SCALED_DISCOUNT: number[][];
+    static Y_FROM_LINRGB: number[];
+    static CRITICAL_PLANES: number[];
+    /**
+     * Sanitizes a small enough angle in radians.
+     *
+     * @param angle An angle in radians; must not deviate too much
+     * from 0.
+     * @return A coterminal angle between 0 and 2pi.
+     */
+    private static sanitizeRadians;
+    /**
+     * Delinearizes an RGB component, returning a floating-point
+     * number.
+     *
+     * @param rgbComponent 0.0 <= rgb_component <= 100.0, represents
+     * linear R/G/B channel
+     * @return 0.0 <= output <= 255.0, color channel converted to
+     * regular RGB space
+     */
+    private static trueDelinearized;
+    private static chromaticAdaptation;
+    /**
+     * Returns the hue of a linear RGB color in CAM16.
+     *
+     * @param linrgb The linear RGB coordinates of a color.
+     * @return The hue of the color in CAM16, in radians.
+     */
+    private static hueOf;
+    private static areInCyclicOrder;
+    /**
+     * Solves the lerp equation.
+     *
+     * @param source The starting number.
+     * @param mid The number in the middle.
+     * @param target The ending number.
+     * @return A number t such that lerp(source, target, t) = mid.
+     */
+    private static intercept;
+    private static lerpPoint;
+    /**
+     * Intersects a segment with a plane.
+     *
+     * @param source The coordinates of point A.
+     * @param coordinate The R-, G-, or B-coordinate of the plane.
+     * @param target The coordinates of point B.
+     * @param axis The axis the plane is perpendicular with. (0: R, 1:
+     * G, 2: B)
+     * @return The intersection point of the segment AB with the plane
+     * R=coordinate, G=coordinate, or B=coordinate
+     */
+    private static setCoordinate;
+    private static isBounded;
+    /**
+     * Returns the nth possible vertex of the polygonal intersection.
+     *
+     * @param y The Y value of the plane.
+     * @param n The zero-based index of the point. 0 <= n <= 11.
+     * @return The nth possible vertex of the polygonal intersection
+     * of the y plane and the RGB cube, in linear RGB coordinates, if
+     * it exists. If this possible vertex lies outside of the cube,
+     * [-1.0, -1.0, -1.0] is returned.
+     */
+    private static nthVertex;
+    /**
+     * Finds the segment containing the desired color.
+     *
+     * @param y The Y value of the color.
+     * @param targetHue The hue of the color.
+     * @return A list of two sets of linear RGB coordinates, each
+     * corresponding to an endpoint of the segment containing the
+     * desired color.
+     */
+    private static bisectToSegment;
+    private static midpoint;
+    private static criticalPlaneBelow;
+    private static criticalPlaneAbove;
+    /**
+     * Finds a color with the given Y and hue on the boundary of the
+     * cube.
+     *
+     * @param y The Y value of the color.
+     * @param targetHue The hue of the color.
+     * @return The desired color, in linear RGB coordinates.
+     */
+    private static bisectToLimit;
+    private static inverseChromaticAdaptation;
+    /**
+     * Finds a color with the given hue, chroma, and Y.
+     *
+     * @param hueRadians The desired hue in radians.
+     * @param chroma The desired chroma.
+     * @param y The desired Y.
+     * @return The desired color as a hexadecimal integer, if found; 0
+     * otherwise.
+     */
+    private static findResultByJ;
+    /**
+     * Finds an sRGB color with the given hue, chroma, and L*, if
+     * possible.
+     *
+     * @param hueDegrees The desired hue, in degrees.
+     * @param chroma The desired chroma.
+     * @param lstar The desired L*.
+     * @return A hexadecimal representing the sRGB color. The color
+     * has sufficiently close hue, chroma, and L* to the desired
+     * values, if possible; otherwise, the hue and L* will be
+     * sufficiently close, and chroma will be maximized.
+     */
+    static solveToInt(hueDegrees: number, chroma: number, lstar: number): number;
+    /**
+     * Finds an sRGB color with the given hue, chroma, and L*, if
+     * possible.
+     *
+     * @param hueDegrees The desired hue, in degrees.
+     * @param chroma The desired chroma.
+     * @param lstar The desired L*.
+     * @return An CAM16 object representing the sRGB color. The color
+     * has sufficiently close hue, chroma, and L* to the desired
+     * values, if possible; otherwise, the hue and L* will be
+     * sufficiently close, and chroma will be maximized.
+     */
+    static solveToCam(hueDegrees: number, chroma: number, lstar: number): Cam16;
+}

package/types/util/color/hct/hct.d.ts

@@ -1,20 +1,5 @@
-/**
- * @license
- * Copyright 2021 Google LLC
- *
- * 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 { ViewingConditions } from './viewing_conditions';
+import { ViewingConditions } from './viewing-conditions';
+
 /**
  * HCT, hue, chroma, and tone. A color system that provides a perceptually
  * accurate color measurement system that can also accurately render what colors

package/types/util/color/hct/viewing-conditions.d.ts

@@ -0,0 +1,58 @@
+/**
+ * In traditional color spaces, a color can be identified solely by the
+ * observer's measurement of the color. Color appearance models such as CAM16
+ * also use information about the environment where the color was
+ * observed, known as the viewing conditions.
+ *
+ * For example, white under the traditional assumption of a midday sun white
+ * point is accurately measured as a slightly chromatic blue by CAM16. (roughly,
+ * hue 203, chroma 3, lightness 100)
+ *
+ * This class caches intermediate values of the CAM16 conversion process that
+ * depend only on viewing conditions, enabling speed ups.
+ */
+export declare class ViewingConditions {
+    n: number;
+    aw: number;
+    nbb: number;
+    ncb: number;
+    c: number;
+    nc: number;
+    rgbD: number[];
+    fl: number;
+    fLRoot: number;
+    z: number;
+    /** sRGB-like viewing conditions.  */
+    static DEFAULT: ViewingConditions;
+    /**
+     * Create ViewingConditions from a simple, physically relevant, set of
+     * parameters.
+     *
+     * @param whitePoint White point, measured in the XYZ color space.
+     *     default = D65, or sunny day afternoon
+     * @param adaptingLuminance The luminance of the adapting field. Informally,
+     *     how bright it is in the room where the color is viewed. Can be
+     *     calculated from lux by multiplying lux by 0.0586. default = 11.72,
+     *     or 200 lux.
+     * @param backgroundLstar The lightness of the area surrounding the color.
+     *     measured by L* in L*a*b*. default = 50.0
+     * @param surround A general description of the lighting surrounding the
+     *     color. 0 is pitch dark, like watching a movie in a theater. 1.0 is a
+     *     dimly light room, like watching TV at home at night. 2.0 means there
+     *     is no difference between the lighting on the color and around it.
+     *     default = 2.0
+     * @param discountingIlluminant Whether the eye accounts for the tint of the
+     *     ambient lighting, such as knowing an apple is still red in green light.
+     *     default = false, the eye does not perform this process on
+     *       self-luminous objects like displays.
+     */
+    static make(whitePoint?: number[], adaptingLuminance?: number, backgroundLstar?: number, surround?: number, discountingIlluminant?: boolean): ViewingConditions;
+    /**
+     * Parameters are intermediate values of the CAM16 conversion process. Their
+     * names are shorthand for technical color science terminology, this class
+     * would not benefit from documenting them individually. A brief overview
+     * is available in the CAM16 specification, and a complete overview requires
+     * a color science textbook, such as Fairchild's Color Appearance Models.
+     */
+    private constructor();
+}

package/types/util/color/index.d.ts

@@ -1,4 +1,4 @@
 export declare function isColorValue(value: string): boolean;
 export declare function isTextColorIsLight(r: number, g: number, b: number): boolean;
 export * from './const';
-export * from "./conversion";
+export * from './conversion';

package/types/util/color/palettes/core-palette.d.ts

@@ -0,0 +1,44 @@
+import { TonalPalette } from './tonal-palette';
+
+/**
+ * Set of colors to generate a [CorePalette] from
+ */
+export interface CorePaletteColors {
+    primary: number;
+    secondary?: number;
+    tertiary?: number;
+    neutral?: number;
+    neutralVariant?: number;
+    error?: number;
+}
+/**
+ * An intermediate concept between the key color for a UI theme, and a full
+ * color scheme. 5 sets of tones are generated, all except one use the same hue
+ * as the key color, and all vary in chroma.
+ */
+export declare class CorePalette {
+    a1: TonalPalette;
+    a2: TonalPalette;
+    a3: TonalPalette;
+    n1: TonalPalette;
+    n2: TonalPalette;
+    error: TonalPalette;
+    /**
+     * @param argb ARGB representation of a color
+     */
+    static of(argb: number): CorePalette;
+    /**
+     * @param argb ARGB representation of a color
+     */
+    static contentOf(argb: number): CorePalette;
+    /**
+     * Create a [CorePalette] from a set of colors
+     */
+    static fromColors(colors: CorePaletteColors): CorePalette;
+    /**
+     * Create a content [CorePalette] from a set of colors
+     */
+    static contentFromColors(colors: CorePaletteColors): CorePalette;
+    private static createPaletteFromColors;
+    private constructor();
+}

package/types/util/color/palettes/tonal-palette.d.ts

@@ -0,0 +1,40 @@
+import { Hct } from '../hct/hct';
+
+/**
+ *  A convenience class for retrieving colors that are constant in hue and
+ *  chroma, but vary in tone.
+ */
+export declare class TonalPalette {
+    readonly hue: number;
+    readonly chroma: number;
+    readonly keyColor: Hct;
+    private readonly cache;
+    /**
+     * @param argb ARGB representation of a color
+     * @return Tones matching that color's hue and chroma.
+     */
+    static fromInt(argb: number): TonalPalette;
+    /**
+     * @param hct Hct
+     * @return Tones matching that color's hue and chroma.
+     */
+    static fromHct(hct: Hct): TonalPalette;
+    /**
+     * @param hue HCT hue
+     * @param chroma HCT chroma
+     * @return Tones matching hue and chroma.
+     */
+    static fromHueAndChroma(hue: number, chroma: number): TonalPalette;
+    private constructor();
+    private static createKeyColor;
+    /**
+     * @param tone HCT tone, measured from 0 to 100.
+     * @return ARGB representation of a color with that tone.
+     */
+    tone(tone: number): number;
+    /**
+     * @param tone HCT tone.
+     * @return HCT representation of a color with that tone.
+     */
+    getHct(tone: number): Hct;
+}

package/types/util/date/adapters/yuyeon-date-adapter.d.ts

@@ -1,4 +1,5 @@
 import { DateAdapter, DateFormatOptions } from '../types';
+
 export declare class YuyeonDateAdapter implements DateAdapter<Date> {
     locale: string;
     formats?: Record<string, DateFormatOptions>;

package/types/util/date/built-in.d.ts

@@ -1,4 +1,5 @@
-import type { DateAdapter, DateFormatOptions } from './types';
+import { DateAdapter, DateFormatOptions } from './types';
+
 export declare const ONE_DAY: number;
 export declare const YYYY_MM_DD_REGEX: RegExp;
 export declare const FIRST_SUNDAY: Date;

package/types/util/date/index.d.ts

@@ -1,3 +1,3 @@
 export * from './built-in';
-export { YuyeonDateAdapter } from "./adapters/yuyeon-date-adapter";
+export { YuyeonDateAdapter } from './adapters/yuyeon-date-adapter';
 export declare function createDateAdapter(): void;

package/types/util/parser.d.ts

@@ -0,0 +1,4 @@
+export declare function simpleBraceParse(input: string): {
+    type: string;
+    content: string;
+}[];

package/types/util/reactivity.d.ts

@@ -1,6 +1,7 @@
-import type { ComputedGetter } from 'vue';
+import { ComputedGetter } from 'vue';
+
 /**
  * For Destructuring assignment
  * @param getter
  */
-export declare function $computed<T extends object>(getter: ComputedGetter<T>): import("vue").ToRefs<T>;
+export declare function $computed<T extends object>(getter: ComputedGetter<T>): import('vue').ToRefs<T>;

package/types/util/string.d.ts

@@ -2,3 +2,7 @@ export declare function camelToPascal(str: string): string;
 export declare function toKebabCase(str: string, from?: 'camel' | 'pascal'): string;
 export declare function kebabToCamel(str: string): string;
 export declare function randomCharOne(str: string): string;
+export declare function simpleBraceParse(input: string): {
+    type: string;
+    content: string;
+}[];

package/types/util/vue-component.d.ts

@@ -1,13 +1,14 @@
 import { ComponentInternalInstance } from '@vue/runtime-core';
-import type { IfAny } from '@vue/shared';
-import type { ComponentObjectPropsOptions, ComponentPublicInstance, ExtractPropTypes, InjectionKey, Prop, PropType, VNode, VNodeChild } from 'vue';
+import { IfAny } from '@vue/shared';
+import { ComponentObjectPropsOptions, ComponentPublicInstance, ExtractPropTypes, InjectionKey, Prop, PropType, VNode, VNodeChild } from 'vue';
+
 export declare function getSlot(vm: ComponentPublicInstance | any, name?: string, data?: any | (() => any), optional?: boolean): VNode[] | undefined;
 export declare function getUid(): number | undefined;
 export declare function chooseProps<PropsOptions extends ComponentObjectPropsOptions>(props: any, target: PropsOptions): ExtractPropTypes<PropsOptions>;
 export declare function bindClasses(classes: string | string[] | Record<string, any> | undefined): Record<string, boolean>;
 export declare function getHtmlElement<N extends object | undefined>(node: N): Exclude<N, ComponentPublicInstance> | HTMLElement;
 export declare function findChildrenWithProvide(key: InjectionKey<any> | symbol, vnode?: VNodeChild): ComponentInternalInstance[];
-export declare function propsFactory<PropsOptions extends ComponentObjectPropsOptions>(props: PropsOptions, source: string): <Defaults extends PartialKeys<PropsOptions> = {}>(defaults?: Defaults | undefined) => OverwrittenPropOptions<PropsOptions, Defaults>;
+export declare function propsFactory<PropsOptions extends ComponentObjectPropsOptions>(props: PropsOptions, source: string): <Defaults extends PartialKeys<PropsOptions> = {}>(defaults?: Defaults) => OverwrittenPropOptions<PropsOptions, Defaults>;
 export declare function hasEventProp(props: Record<string, any>, type: string): boolean;
 type OverwrittenPropOptions<T extends ComponentObjectPropsOptions, D extends PartialKeys<T>> = {
     [P in keyof T]-?: unknown extends D[P] ? T[P] : T[P] extends Record<string, unknown> ? Omit<T[P], 'type' | 'default'> & {