cbvirtua 1.0.41 → 1.0.42

package/hanzi-writer/dist/types/LoadingManager.d.ts

@@ -0,0 +1,20 @@
+import { CharacterJson, LoadingManagerOptions } from './typings/types';
+type CustomError = Error & {
+    reason: string;
+};
+export default class LoadingManager {
+    _loadCounter: number;
+    _isLoading: boolean;
+    _resolve: ((data: CharacterJson) => void) | undefined;
+    _reject: ((error?: Error | CustomError | string) => void) | undefined;
+    _options: LoadingManagerOptions;
+    /** Set when calling LoadingManager.loadCharData  */
+    _loadingChar: string | undefined;
+    /** use this to attribute to determine if there was a problem with loading */
+    loadingFailed: boolean;
+    constructor(options: LoadingManagerOptions);
+    _debouncedLoad(char: string, count: number): void;
+    _setupLoadingPromise(): Promise<void | CharacterJson>;
+    loadCharData(char: string): Promise<void | CharacterJson>;
+}
+export {};

package/hanzi-writer/dist/types/Positioner.d.ts

@@ -0,0 +1,22 @@
+import { Point } from './typings/types';
+export type PositionerOptions = {
+    /** Default: 0 */
+    width: number;
+    /** Default: 0 */
+    height: number;
+    /** Default: 20 */
+    padding: number;
+};
+export default class Positioner {
+    padding: number;
+    width: number;
+    height: number;
+    xOffset: number;
+    yOffset: number;
+    scale: number;
+    constructor(options: PositionerOptions);
+    convertExternalPoint(point: Point): {
+        x: number;
+        y: number;
+    };
+}

package/hanzi-writer/dist/types/Quiz.d.ts

@@ -0,0 +1,40 @@
+import { StrokeMatchResultMeta } from './strokeMatches';
+import UserStroke from './models/UserStroke';
+import Positioner from './Positioner';
+import Character from './models/Character';
+import { ParsedHanziWriterOptions, Point, StrokeData } from './typings/types';
+import RenderState from './RenderState';
+export default class Quiz {
+    _character: Character;
+    _renderState: RenderState;
+    _isActive: boolean;
+    _positioner: Positioner;
+    /** Set on startQuiz */
+    _options: ParsedHanziWriterOptions | undefined;
+    _currentStrokeIndex: number;
+    _mistakesOnStroke: number;
+    _totalMistakes: number;
+    _userStroke: UserStroke | undefined;
+    _userStrokesIds: Array<number> | undefined;
+    constructor(character: Character, renderState: RenderState, positioner: Positioner);
+    startQuiz(options: ParsedHanziWriterOptions): Promise<{
+        canceled: boolean;
+    }>;
+    startUserStroke(externalPoint: Point): void | Promise<{
+        canceled: boolean;
+    }> | null;
+    continueUserStroke(externalPoint: Point): Promise<void> | Promise<{
+        canceled: boolean;
+    }>;
+    setPositioner(positioner: Positioner): void;
+    endUserStroke(): void;
+    cancel(): void;
+    _getStrokeData({ isCorrect, meta, }: {
+        isCorrect: boolean;
+        meta: StrokeMatchResultMeta;
+    }): StrokeData;
+    nextStroke(): void;
+    _handleSuccess(meta: StrokeMatchResultMeta): void;
+    _handleFailure(meta: StrokeMatchResultMeta): void;
+    _getCurrentStroke(): import("./models/Stroke").default;
+}

package/hanzi-writer/dist/types/RenderState.d.ts

@@ -0,0 +1,74 @@
+import Character from './models/Character';
+import { GenericMutation } from './Mutation';
+import { ColorObject, OnCompleteFunction, Point, RecursivePartial } from './typings/types';
+export type StrokeRenderState = {
+    opacity: number;
+    displayPortion: number;
+};
+export type CharacterRenderState = {
+    opacity: number;
+    strokes: Record<number | string, StrokeRenderState>;
+};
+export type RenderStateObject = {
+    options: {
+        drawingFadeDuration: number;
+        drawingWidth: number;
+        drawingColor: ColorObject;
+        strokeColor: ColorObject;
+        outlineColor: ColorObject;
+        radicalColor: ColorObject;
+        highlightColor: ColorObject;
+    };
+    character: {
+        main: CharacterRenderState;
+        outline: CharacterRenderState;
+        highlight: CharacterRenderState;
+    };
+    userStrokes: Record<string, {
+        points: Point[];
+        opacity: number;
+    } | undefined> | null;
+};
+export type CharacterName = keyof RenderStateObject['character'];
+type OnStateChangeCallback = (nextState: RenderStateObject, currentState: RenderStateObject) => void;
+type MutationChain = {
+    _isActive: boolean;
+    _index: number;
+    _resolve: OnCompleteFunction;
+    _mutations: GenericMutation[];
+    _loop: boolean | undefined;
+    _scopes: string[];
+};
+export type RenderStateOptions = {
+    strokeColor: string;
+    radicalColor: string | null;
+    highlightColor: string;
+    outlineColor: string;
+    drawingColor: string;
+    drawingFadeDuration: number;
+    drawingWidth: number;
+    outlineWidth: number;
+    showCharacter: boolean;
+    showOutline: boolean;
+};
+export default class RenderState {
+    _mutationChains: MutationChain[];
+    _onStateChange: OnStateChangeCallback;
+    state: RenderStateObject;
+    constructor(character: Character, options: RenderStateOptions, onStateChange?: OnStateChangeCallback);
+    overwriteOnStateChange(onStateChange: OnStateChangeCallback): void;
+    updateState(stateChanges: RecursivePartial<RenderStateObject>): void;
+    run(mutations: GenericMutation[], options?: {
+        loop?: boolean;
+    }): Promise<{
+        canceled: boolean;
+    }>;
+    _run(mutationChain: MutationChain): void;
+    _getActiveMutations(): GenericMutation<RenderState>[];
+    pauseAll(): void;
+    resumeAll(): void;
+    cancelMutations(scopesToCancel: string[]): void;
+    cancelAll(): void;
+    _cancelMutationChain(mutationChain: MutationChain): void;
+}
+export {};

package/hanzi-writer/dist/types/__tests__/HanziWriter-test.d.ts

@@ -0,0 +1 @@
+export {};

package/hanzi-writer/dist/types/__tests__/LoadingManager-test.d.ts

@@ -0,0 +1 @@
+export {};

package/hanzi-writer/dist/types/__tests__/Mutation-test.d.ts

@@ -0,0 +1 @@
+export {};

package/hanzi-writer/dist/types/__tests__/Positioner-test.d.ts

@@ -0,0 +1 @@
+export {};

package/hanzi-writer/dist/types/__tests__/Quiz-test.d.ts

@@ -0,0 +1 @@
+export {};

package/hanzi-writer/dist/types/__tests__/RenderState-test.d.ts

@@ -0,0 +1 @@
+export {};

package/hanzi-writer/dist/types/__tests__/defaultCharDataLoader-test.d.ts

@@ -0,0 +1 @@
+export {};

package/hanzi-writer/dist/types/__tests__/geometry-test.d.ts

@@ -0,0 +1 @@
+export {};

package/hanzi-writer/dist/types/__tests__/parseCharData-test.d.ts

@@ -0,0 +1 @@
+export {};

package/hanzi-writer/dist/types/__tests__/strokeMatches-test.d.ts

@@ -0,0 +1 @@
+export {};

package/hanzi-writer/dist/types/__tests__/utils-test.d.ts

@@ -0,0 +1 @@
+export {};

package/hanzi-writer/dist/types/characterActions.d.ts

@@ -0,0 +1,18 @@
+import Stroke from './models/Stroke';
+import { ColorObject, RecursivePartial } from './typings/types';
+import Character from './models/Character';
+import Mutation, { GenericMutation } from './Mutation';
+import { CharacterName } from './RenderState';
+export declare const showStrokes: (charName: CharacterName, character: Character, duration: number) => GenericMutation[];
+export declare const showCharacter: (charName: CharacterName, character: Character, duration: number) => GenericMutation[];
+export declare const hideCharacter: (charName: CharacterName, character: Character, duration?: number) => GenericMutation[];
+export declare const updateColor: (colorName: string, colorVal: ColorObject | null, duration: number) => Mutation<{
+    state: any;
+    updateState(changes: RecursivePartial<any>): void;
+}, any>[];
+export declare const highlightStroke: (stroke: Stroke, color: ColorObject | null, speed: number) => GenericMutation[];
+export declare const animateStroke: (charName: CharacterName, stroke: Stroke, speed: number) => GenericMutation[];
+export declare const animateSingleStroke: (charName: CharacterName, character: Character, strokeNum: number, speed: number) => GenericMutation[];
+export declare const showStroke: (charName: CharacterName, strokeNum: number, duration: number) => GenericMutation[];
+export declare const animateCharacter: (charName: CharacterName, character: Character, fadeDuration: number, speed: number, delayBetweenStrokes: number) => GenericMutation[];
+export declare const animateCharacterLoop: (charName: CharacterName, character: Character, fadeDuration: number, speed: number, delayBetweenStrokes: number, delayBetweenLoops: number) => GenericMutation[];

package/hanzi-writer/dist/types/defaultCharDataLoader.d.ts

@@ -0,0 +1,3 @@
+import { CharacterJson } from './typings/types';
+declare const defaultCharDataLoader: (char: string, onLoad: (parsedJson: CharacterJson) => void, onError: (error?: any, context?: any) => void) => void;
+export default defaultCharDataLoader;

package/hanzi-writer/dist/types/defaultOptions.d.ts

@@ -0,0 +1,3 @@
+import { HanziWriterOptions } from './typings/types';
+declare const defaultOptions: HanziWriterOptions;
+export default defaultOptions;

package/hanzi-writer/dist/types/geometry.d.ts

@@ -0,0 +1,38 @@
+import { Point } from './typings/types';
+export declare const subtract: (p1: Point, p2: Point) => {
+    x: number;
+    y: number;
+};
+export declare const magnitude: (point: Point) => number;
+export declare const distance: (point1: Point, point2: Point) => number;
+export declare const equals: (point1: Point, point2: Point) => boolean;
+export declare const round: (point: Point, precision?: number) => {
+    x: number;
+    y: number;
+};
+export declare const length: (points: Point[]) => number;
+export declare const cosineSimilarity: (point1: Point, point2: Point) => number;
+/**
+ * return a new point, p3, which is on the same line as p1 and p2, but distance away
+ * from p2. p1, p2, p3 will always lie on the line in that order
+ */
+export declare const _extendPointOnLine: (p1: Point, p2: Point, dist: number) => {
+    x: number;
+    y: number;
+};
+/** based on http://www.kr.tuwien.ac.at/staff/eiter/et-archive/cdtr9464.pdf */
+export declare const frechetDist: (curve1: Point[], curve2: Point[]) => number;
+/** break up long segments in the curve into smaller segments of len maxLen or smaller */
+export declare const subdivideCurve: (curve: Point[], maxLen?: number) => Point[];
+/** redraw the curve using numPoints equally spaced out along the length of the curve */
+export declare const outlineCurve: (curve: Point[], numPoints?: number) => Point[];
+/** translate and scale from https://en.wikipedia.org/wiki/Procrustes_analysis */
+export declare const normalizeCurve: (curve: Point[]) => Point[];
+export declare const rotate: (curve: Point[], theta: number) => {
+    x: number;
+    y: number;
+}[];
+export declare const _filterParallelPoints: (points: Point[]) => Point[];
+export declare function getPathString(points: Point[], close?: boolean): string;
+/** take points on a path and move their start point backwards by distance */
+export declare const extendStart: (points: Point[], dist: number) => Point[];

package/hanzi-writer/dist/types/models/Character.d.ts

@@ -0,0 +1,6 @@
+import Stroke from './Stroke';
+export default class Character {
+    symbol: string;
+    strokes: Stroke[];
+    constructor(symbol: string, strokes: Stroke[]);
+}

package/hanzi-writer/dist/types/models/Stroke.d.ts

@@ -0,0 +1,17 @@
+import { Point } from '../typings/types';
+export default class Stroke {
+    path: string;
+    points: Point[];
+    strokeNum: number;
+    isInRadical: boolean;
+    constructor(path: string, points: Point[], strokeNum: number, isInRadical?: boolean);
+    getStartingPoint(): Point;
+    getEndingPoint(): Point;
+    getLength(): number;
+    getVectors(): {
+        x: number;
+        y: number;
+    }[];
+    getDistance(point: Point): number;
+    getAverageDistance(points: Point[]): number;
+}

package/hanzi-writer/dist/types/models/UserStroke.d.ts

@@ -0,0 +1,8 @@
+import { Point } from '../typings/types';
+export default class UserStroke {
+    id: number;
+    points: Point[];
+    externalPoints: Point[];
+    constructor(id: number, startingPoint: Point, startingExternalPoint: Point);
+    appendPoint(point: Point, externalPoint: Point): void;
+}

package/hanzi-writer/dist/types/parseCharData.d.ts

@@ -0,0 +1,3 @@
+import Character from './models/Character';
+import { CharacterJson } from './typings/types';
+export default function parseCharData(symbol: string, charJson: CharacterJson): Character;

package/hanzi-writer/dist/types/quizActions.d.ts

@@ -0,0 +1,10 @@
+import { GenericMutation } from './Mutation';
+import Character from './models/Character';
+import { ColorObject, Point } from './typings/types';
+export declare const startQuiz: (character: Character, fadeDuration: number, startStrokeNum: number) => GenericMutation[];
+export declare const startUserStroke: (id: string | number, point: Point) => GenericMutation[];
+export declare const updateUserStroke: (userStrokeId: string | number, points: Point[]) => GenericMutation[];
+export declare const hideUserStroke: (userStrokeId: string | number, duration: number) => GenericMutation[];
+export declare const removeAllUserStrokes: (userStrokeIds: Array<number>) => GenericMutation[];
+export declare const highlightCompleteChar: (character: Character, color: ColorObject | null, duration: number) => GenericMutation[];
+export declare const highlightStroke: (stroke: import("./models/Stroke").default, color: ColorObject | null, speed: number) => GenericMutation<import("./RenderState").default>[];

package/hanzi-writer/dist/types/renderers/HanziWriterRendererBase.d.ts

@@ -0,0 +1,14 @@
+import Character from '../models/Character';
+import Positioner from '../Positioner';
+import { RenderStateObject } from '../RenderState';
+import RenderTargetBase from './RenderTargetBase';
+export default interface HanziWriterRendererBase<TElementType extends HTMLElement | HTMLCanvasElement | SVGElement | SVGSVGElement, TRenderTarget extends RenderTargetBase<TElementType>> {
+    _character: Character;
+    _positioner: Positioner;
+    mount(target: TRenderTarget): void;
+    render(props: RenderStateObject): void;
+    destroy(): void;
+}
+export interface HanziWriterRendererConstructor {
+    new (character: Character, positioner: Positioner): HanziWriterRendererBase<any, any>;
+}

package/hanzi-writer/dist/types/renderers/RenderTargetBase.d.ts

@@ -0,0 +1,22 @@
+import { Point } from '../typings/types';
+type BoundEvent = {
+    getPoint(): Point;
+    preventDefault(): void;
+};
+/** Generic render target */
+export default class RenderTargetBase<TElement extends HTMLElement | SVGElement | SVGSVGElement | HTMLCanvasElement = HTMLElement> {
+    node: TElement;
+    constructor(node: TElement);
+    addPointerStartListener(callback: (arg: BoundEvent) => void): void;
+    addPointerMoveListener(callback: (arg: BoundEvent) => void): void;
+    addPointerEndListener(callback: () => void): void;
+    getBoundingClientRect(): DOMRect;
+    updateDimensions(width: string | number, height: string | number): void;
+    _eventify<TEvent extends Event>(evt: TEvent, pointFunc: (event: TEvent) => Point): {
+        getPoint: () => Point;
+        preventDefault: () => void;
+    };
+    _getMousePoint(evt: MouseEvent): Point;
+    _getTouchPoint(evt: TouchEvent): Point;
+}
+export {};

package/hanzi-writer/dist/types/renderers/StrokeRendererBase.d.ts

@@ -0,0 +1,13 @@
+import Stroke from '../models/Stroke';
+import { ColorObject } from '../typings/types';
+export default class StrokeRendererBase {
+    _pathLength: number;
+    stroke: Stroke;
+    static STROKE_WIDTH: number;
+    constructor(stroke: Stroke);
+    _getStrokeDashoffset(displayPortion: number): number;
+    _getColor({ strokeColor, radicalColor, }: {
+        strokeColor: ColorObject;
+        radicalColor?: ColorObject | null;
+    }): ColorObject;
+}

package/hanzi-writer/dist/types/renderers/canvas/CharacterRenderer.d.ts

@@ -0,0 +1,14 @@
+import Character from '../../models/Character';
+import { StrokeRenderState } from '../../RenderState';
+import { ColorObject } from '../../typings/types';
+import StrokeRenderer from './StrokeRenderer';
+export default class CharacterRenderer {
+    _strokeRenderers: StrokeRenderer[];
+    constructor(character: Character);
+    render(ctx: CanvasRenderingContext2D, props: {
+        opacity: number;
+        strokes: Record<number, StrokeRenderState>;
+        strokeColor: ColorObject;
+        radicalColor?: ColorObject | null;
+    }): void;
+}

package/hanzi-writer/dist/types/renderers/canvas/HanziWriterRenderer.d.ts

@@ -0,0 +1,19 @@
+import Character from '../../models/Character';
+import Positioner from '../../Positioner';
+import HanziWriterRendererBase from '../HanziWriterRendererBase';
+import CanvasRenderTarget from '../canvas/RenderTarget';
+import CharacterRenderer from './CharacterRenderer';
+import { RenderStateObject } from '../../RenderState';
+export default class HanziWriterRenderer implements HanziWriterRendererBase<HTMLCanvasElement, CanvasRenderTarget> {
+    _character: Character;
+    _positioner: Positioner;
+    _mainCharRenderer: CharacterRenderer;
+    _outlineCharRenderer: CharacterRenderer;
+    _highlightCharRenderer: CharacterRenderer;
+    _target: CanvasRenderTarget | undefined;
+    constructor(character: Character, positioner: Positioner);
+    mount(target: CanvasRenderTarget): void;
+    destroy: () => void;
+    _animationFrame(cb: (ctx: CanvasRenderingContext2D) => void): void;
+    render(props: RenderStateObject): void;
+}

package/hanzi-writer/dist/types/renderers/canvas/RenderTarget.d.ts

@@ -0,0 +1,6 @@
+import RenderTargetBase from '../RenderTargetBase';
+export default class RenderTarget extends RenderTargetBase<HTMLCanvasElement> {
+    constructor(canvas: HTMLCanvasElement);
+    static init(elmOrId: string | HTMLCanvasElement, width?: string, height?: string): RenderTarget;
+    getContext(): CanvasRenderingContext2D | null;
+}

package/hanzi-writer/dist/types/renderers/canvas/StrokeRenderer.d.ts

@@ -0,0 +1,16 @@
+import StrokeRendererBase from '../StrokeRendererBase';
+import Stroke from '../../models/Stroke';
+import { ColorObject, Point } from '../../typings/types';
+/** this is a stroke composed of several stroke parts */
+export default class StrokeRenderer extends StrokeRendererBase {
+    _extendedMaskPoints: Point[];
+    _path2D: Path2D | undefined;
+    _pathCmd: ((ctx: CanvasRenderingContext2D) => void) | undefined;
+    constructor(stroke: Stroke, usePath2D?: boolean);
+    render(ctx: CanvasRenderingContext2D, props: {
+        opacity: number;
+        strokeColor: ColorObject;
+        radicalColor?: ColorObject | null;
+        displayPortion: number;
+    }): void;
+}

package/hanzi-writer/dist/types/renderers/canvas/__tests__/CharacterRenderer-test.d.ts

@@ -0,0 +1 @@
+export {};

package/hanzi-writer/dist/types/renderers/canvas/__tests__/HanziWriterRenderer-test.d.ts

@@ -0,0 +1 @@
+export {};

package/hanzi-writer/dist/types/renderers/canvas/__tests__/RenderTarget-test.d.ts

@@ -0,0 +1 @@
+export {};

package/hanzi-writer/dist/types/renderers/canvas/__tests__/StrokeRenderer-test.d.ts

@@ -0,0 +1 @@
+export {};

package/hanzi-writer/dist/types/renderers/canvas/__tests__/canvasUtils-test.d.ts

@@ -0,0 +1 @@
+export {};

package/hanzi-writer/dist/types/renderers/canvas/__tests__/renderUserStroke-test.d.ts

@@ -0,0 +1 @@
+export {};

package/hanzi-writer/dist/types/renderers/canvas/canvasUtils.d.ts

@@ -0,0 +1,9 @@
+import { Point } from '../../typings/types';
+export declare const drawPath: (ctx: CanvasRenderingContext2D, points: Point[]) => void;
+/**
+ * Break a path string into a series of canvas path commands
+ *
+ * Note: only works with the subset of SVG paths used by MakeMeAHanzi data
+ * @param pathString
+ */
+export declare const pathStringToCanvas: (pathString: string) => (ctx: CanvasRenderingContext2D) => void;

package/hanzi-writer/dist/types/renderers/canvas/index.d.ts

@@ -0,0 +1,7 @@
+import { RenderTargetInitFunction } from '../../typings/types';
+import HanziWriterRenderer from './HanziWriterRenderer';
+declare const _default: {
+    HanziWriterRenderer: typeof HanziWriterRenderer;
+    createRenderTarget: RenderTargetInitFunction<HTMLCanvasElement>;
+};
+export default _default;

package/hanzi-writer/dist/types/renderers/canvas/renderUserStroke.d.ts

@@ -0,0 +1,7 @@
+import { ColorObject, Point } from '../../typings/types';
+export default function renderUserStroke(ctx: CanvasRenderingContext2D, props: {
+    opacity: number;
+    strokeWidth: number;
+    strokeColor: ColorObject;
+    points: Point[];
+}): void;

package/hanzi-writer/dist/types/renderers/svg/CharacterRenderer.d.ts

@@ -0,0 +1,20 @@
+import StrokeRenderer from './StrokeRenderer';
+import SVGRenderTarget from './RenderTarget';
+import Character from '../../models/Character';
+import { ColorObject } from '../../typings/types';
+import { StrokeRenderState } from '../../RenderState';
+type SvgCharacterRenderProps = {
+    opacity: number;
+    strokes: Record<number, StrokeRenderState>;
+    strokeColor: ColorObject;
+    radicalColor?: ColorObject | null;
+};
+export default class CharacterRenderer {
+    _oldProps: SvgCharacterRenderProps | undefined;
+    _strokeRenderers: StrokeRenderer[];
+    _group: SVGElement | SVGSVGElement | undefined;
+    constructor(character: Character);
+    mount(target: SVGRenderTarget): void;
+    render(props: SvgCharacterRenderProps): void;
+}
+export {};

package/hanzi-writer/dist/types/renderers/svg/HanziWriterRenderer.d.ts

@@ -0,0 +1,20 @@
+import CharacterRenderer from './CharacterRenderer';
+import UserStrokeRenderer from './UserStrokeRenderer';
+import Character from '../../models/Character';
+import Positioner from '../../Positioner';
+import SVGRenderTarget from './RenderTarget';
+import HanziWriterRendererBase from '../HanziWriterRendererBase';
+import { RenderStateObject } from '../../RenderState';
+export default class HanziWriterRenderer implements HanziWriterRendererBase<SVGElement | SVGSVGElement, SVGRenderTarget> {
+    _character: Character;
+    _positioner: Positioner;
+    _mainCharRenderer: CharacterRenderer;
+    _outlineCharRenderer: CharacterRenderer;
+    _highlightCharRenderer: CharacterRenderer;
+    _userStrokeRenderers: Record<string, UserStrokeRenderer | undefined>;
+    _positionedTarget: SVGRenderTarget | undefined;
+    constructor(character: Character, positioner: Positioner);
+    mount(target: SVGRenderTarget): void;
+    render(props: RenderStateObject): void;
+    destroy(): void;
+}

package/hanzi-writer/dist/types/renderers/svg/RenderTarget.d.ts

@@ -0,0 +1,11 @@
+import RenderTargetBase from '../RenderTargetBase';
+export default class RenderTarget extends RenderTargetBase<SVGSVGElement | SVGElement> {
+    static init(elmOrId: Element | string, width?: string, height?: string): RenderTarget;
+    svg: SVGSVGElement | SVGElement;
+    defs: SVGElement;
+    _pt: DOMPoint | undefined;
+    constructor(svg: SVGElement | SVGSVGElement, defs: SVGElement);
+    createSubRenderTarget(): RenderTarget;
+    _getMousePoint(evt: MouseEvent): import("../../HanziWriter").Point;
+    _getTouchPoint(evt: TouchEvent): import("../../HanziWriter").Point;
+}

package/hanzi-writer/dist/types/renderers/svg/StrokeRenderer.d.ts

@@ -0,0 +1,21 @@
+import StrokeRendererBase from '../StrokeRendererBase';
+import Stroke from '../../models/Stroke';
+import SVGRenderTarget from './RenderTarget';
+import { ColorObject } from '../../typings/types';
+type StrokeRenderProps = {
+    strokeColor: ColorObject;
+    radicalColor: ColorObject | null;
+    displayPortion: number;
+    opacity: number;
+};
+/** This is a stroke composed of several stroke parts **/
+export default class StrokeRenderer extends StrokeRendererBase {
+    _oldProps: StrokeRenderProps | undefined;
+    _animationPath: SVGPathElement | undefined;
+    _clip: SVGClipPathElement | undefined;
+    _strokePath: SVGPathElement | undefined;
+    constructor(stroke: Stroke);
+    mount(target: SVGRenderTarget): this;
+    render(props: StrokeRenderProps): void;
+}
+export {};

package/hanzi-writer/dist/types/renderers/svg/UserStrokeRenderer.d.ts

@@ -0,0 +1,15 @@
+import { ColorObject, Point } from '../../typings/types';
+import SVGRenderTarget from './RenderTarget';
+export type UserStrokeProps = {
+    strokeWidth: number;
+    strokeColor: ColorObject;
+    opacity: number;
+    points: Point[];
+};
+export default class UserStrokeRenderer {
+    _oldProps: UserStrokeProps | undefined;
+    _path: SVGElement | undefined;
+    mount(target: SVGRenderTarget): void;
+    render(props: UserStrokeProps): void;
+    destroy(): void;
+}

package/hanzi-writer/dist/types/renderers/svg/__tests__/CharacterRenderer-test.d.ts

@@ -0,0 +1 @@
+export {};

package/hanzi-writer/dist/types/renderers/svg/__tests__/HanziWriterRenderer-test.d.ts

@@ -0,0 +1 @@
+export {};

package/hanzi-writer/dist/types/renderers/svg/__tests__/StrokeRenderer-test.d.ts

@@ -0,0 +1 @@
+export {};

package/hanzi-writer/dist/types/renderers/svg/__tests__/svgUtils-test.d.ts

@@ -0,0 +1 @@
+export {};

package/hanzi-writer/dist/types/renderers/svg/index.d.ts

@@ -0,0 +1,7 @@
+import { RenderTargetInitFunction } from '../../typings/types';
+import HanziWriterRenderer from './HanziWriterRenderer';
+declare const _default: {
+    HanziWriterRenderer: typeof HanziWriterRenderer;
+    createRenderTarget: RenderTargetInitFunction<SVGElement | SVGSVGElement>;
+};
+export default _default;

package/hanzi-writer/dist/types/renderers/svg/svgUtils.d.ts

@@ -0,0 +1,5 @@
+export declare function createElm(elmType: string): SVGElement;
+export declare function attr(elm: Element, name: string, value: string): void;
+export declare function attrs(elm: Element, attrsMap: Record<string, string>): void;
+export declare function urlIdRef(id: string): string;
+export declare function removeElm(elm: Element | undefined): void;

package/hanzi-writer/dist/types/strokeMatches.d.ts

@@ -0,0 +1,14 @@
+import UserStroke from './models/UserStroke';
+import Character from './models/Character';
+export interface StrokeMatchResultMeta {
+    isStrokeBackwards: boolean;
+}
+export interface StrokeMatchResult {
+    isMatch: boolean;
+    meta: StrokeMatchResultMeta;
+}
+export default function strokeMatches(userStroke: UserStroke, character: Character, strokeNum: number, options?: {
+    leniency?: number;
+    isOutlineVisible?: boolean;
+    averageDistanceThreshold?: number;
+}): StrokeMatchResult;

package/hanzi-writer/dist/types/testUtils.d.ts

@@ -0,0 +1 @@
+export declare const resolvePromises: (num?: number) => Promise<void>;