windups
Advanced tools
Comparing version 1.1.9 to 1.2.0-alpha.0
| export { default as useWindupString } from "./react/useWindupString"; | ||
| export { default as WindupChildren, useIsFinished, useRewind, useSkip } from "./react/WindupChildren"; | ||
| export { default as WindupChildren, useIsFinished, useRewind, useSkip, } from "./react/WindupChildren"; | ||
| export { default as OnChar } from "./react/OnChar"; | ||
@@ -10,1 +10,3 @@ export { default as Pace, defaultGetPace } from "./react/Pace"; | ||
| export { default as textFromChildren } from "./react/textFromChildren"; | ||
| export { default as useRewindupString } from "./react/useRewindupString"; | ||
| export { default as RewindupChildren } from './react/RewindupChildren'; |
@@ -9,1 +9,3 @@ export { default as useWindupString } from "./useWindupString"; | ||
| export { default as Effect } from "./Effect"; | ||
| export { default as useRewindupString } from "./useRewindupString"; | ||
| export { default as RewindupChildren } from './RewindupChildren'; |
| import * as React from "react"; | ||
| import { Windup } from "../Windup"; | ||
| import { PlayedSuffixedWindup, SuffixedWindup } from "../SuffixedWindup"; | ||
| import { Windup, PlayedWindup } from "../Windup"; | ||
| import { SuffixedHookMetadata } from "./useRewindup"; | ||
| import { HookMetadata } from "./useWindup"; | ||
| declare type OnCharProps = { | ||
| fn: (char: string) => void; | ||
| fn: (char: string, reversing?: boolean) => void; | ||
| }; | ||
| declare const OnChar: React.FC<OnCharProps>; | ||
| export declare function isOnCharElement(element: React.ReactElement): element is React.ReactElement<OnCharProps>; | ||
| export declare function onCharsFromWindup<M extends HookMetadata, W extends Windup<string, M>>(windup: W): ((char: string) => void)[]; | ||
| export declare function onCharsFromWindup<MetadataType extends HookMetadata>(windup: Windup<string, MetadataType> | PlayedWindup<string, MetadataType>): ((char: string, reversing?: boolean) => void)[]; | ||
| export declare function onCharsFromSuffixedWindup<MetadataType extends SuffixedHookMetadata>(windup: SuffixedWindup<string, MetadataType> | PlayedSuffixedWindup<string, MetadataType>): ((char: string, reversing?: boolean) => void)[]; | ||
| export default OnChar; |
| import * as React from "react"; | ||
| import { Windup } from "../Windup"; | ||
| import { PlayedSuffixedWindup, SuffixedWindup } from "../SuffixedWindup"; | ||
| import { PlayedWindup, Windup } from "../Windup"; | ||
| import { SuffixedHookMetadata } from "./useRewindup"; | ||
| import { HookMetadata } from "./useWindup"; | ||
| declare type MsProp = { | ||
| ms: number; | ||
| reverseMs?: number; | ||
| }; | ||
| declare type ReverseMsProp = { | ||
| ms?: number; | ||
| reverseMs: number; | ||
| }; | ||
| declare type GetPaceProp = { | ||
| getPace: (char: string) => number; | ||
| getReversePace?: (char: string) => number; | ||
| }; | ||
| declare type PaceProps = MsProp | GetPaceProp; | ||
| declare type ReverseGetPaceProp = { | ||
| getPace?: (char: string) => number; | ||
| getReversePace: (char: string) => number; | ||
| }; | ||
| declare type PaceProps = MsProp | ReverseMsProp | GetPaceProp | ReverseGetPaceProp; | ||
| export declare function defaultGetPace(lastChar: string, nextChar: string | undefined): number; | ||
@@ -15,3 +27,13 @@ declare const Pace: React.FC<PaceProps>; | ||
| export declare function isMsProp(props: PaceProps): props is MsProp; | ||
| export declare function paceFromWindup<M extends HookMetadata, W extends Windup<string, M>>(windup: W, parentPace?: (char: string, nextChar: string | undefined) => number): ((char: string, nextChar: string | undefined) => number) | undefined; | ||
| export declare function isReverseMsProp(props: PaceProps): props is ReverseMsProp; | ||
| export declare function isReverseGetPaceProp(props: PaceProps): props is ReverseGetPaceProp; | ||
| export declare function paceMetadataFromProps(props: PaceProps): { | ||
| pace: (char: string) => number; | ||
| reversePace?: (char: string) => number; | ||
| } | { | ||
| pace?: (char: string) => number; | ||
| reversePace: (char: string) => number; | ||
| }; | ||
| export declare function paceFromWindup<MetadataType extends HookMetadata>(windup: Windup<string, MetadataType> | PlayedWindup<string, MetadataType>, parentPace?: (char: string, nextChar: string | undefined) => number): ((char: string, nextChar: string | undefined) => number) | undefined; | ||
| export declare function paceFromSuffixedWindup<MetadataType extends SuffixedHookMetadata>(windup: SuffixedWindup<string, MetadataType> | PlayedSuffixedWindup<string, MetadataType>, rewinding: boolean, parentPace?: (char: string, nextChar: string | undefined) => number): ((char: string, nextChar: string | undefined) => number) | undefined; | ||
| export default Pace; |
@@ -8,2 +8,3 @@ import * as React from "react"; | ||
| export declare function renderStringWindup(windup: StringWindup | PlayedStringWindup): string; | ||
| export declare const VOID_TAGS: string[]; | ||
| export declare function renderChildrenWindup(windup: ChildrenWindup | PlayedChildrenWindup): React.ReactNode; |
@@ -1,11 +0,11 @@ | ||
| import { Windup } from "../Windup"; | ||
| import { Windup, PlayedWindup } from "../Windup"; | ||
| export interface HookMetadata { | ||
| onChar?: (char: string) => void; | ||
| onChar?: (char: string, reversing?: boolean) => void; | ||
| pace?: (char: string, nextChar: string | undefined) => number; | ||
| } | ||
| export default function useWindup<M extends HookMetadata>(windupInit: Windup<string, M>, options: { | ||
| export default function useWindup<MetadataType extends HookMetadata>(windupInit: Windup<string, MetadataType>, options: { | ||
| onFinished?: () => void; | ||
| skipped?: boolean; | ||
| }): { | ||
| windup: Windup<string, M>; | ||
| windup: Windup<string, MetadataType> | PlayedWindup<string, MetadataType>; | ||
| skip: () => void; | ||
@@ -12,0 +12,0 @@ rewind: () => void; |
| import { Windup } from "../Windup"; | ||
| import { HookMetadata } from "./useWindup"; | ||
| export declare type WindupOptions = { | ||
| onChar?: (char: string) => void; | ||
| onChar?: (char: string, reversing?: boolean) => void; | ||
| onFinished?: () => void; | ||
@@ -6,0 +6,0 @@ pace?: (char: string) => number; |
| import * as React from "react"; | ||
| import { Windup } from "../Windup"; | ||
| import { Windup, WindupMember } from "../Windup"; | ||
| import { HookMetadata } from "./useWindup"; | ||
| export declare const WindupContext: React.Context<{ | ||
| skip: () => void; | ||
| rewind: () => void; | ||
| isFinished: boolean; | ||
| }>; | ||
| export declare function useSkip(): () => void; | ||
@@ -14,2 +19,4 @@ export declare function useRewind(): () => void; | ||
| export declare type ChildrenWindup = Windup<string, ChildrenMetadata>; | ||
| declare type ChildrenWindupMember = WindupMember<string, ChildrenMetadata>; | ||
| export declare function reduceWindupArgs(prevArgs: ChildrenWindupMember[], children: React.ReactNode): WindupMember<string, ChildrenMetadata>[]; | ||
| declare type WindupChildrenProps = { | ||
@@ -19,3 +26,4 @@ onFinished?: () => void; | ||
| }; | ||
| export declare function useChildrenMemo<T>(factory: () => T, children: React.ReactNode): T; | ||
| declare const WindupChildren: React.FC<WindupChildrenProps>; | ||
| export default WindupChildren; |
| export declare type WindupMember<ElementType, MetadataType> = ElementType | Windup<ElementType, MetadataType>; | ||
| export declare type Windup<ElementType, MetadataType> = [Array<WindupMember<ElementType, MetadataType>>, Array<WindupMember<ElementType, MetadataType>>, MetadataType]; | ||
| export declare type Windup<ElementType, MetadataType> = [Array<PlayedWindupMember<ElementType, MetadataType>>, Array<WindupMember<ElementType, MetadataType>>, MetadataType]; | ||
| export declare type PlayedWindupMember<ElementType, MetadataType> = ElementType | PlayedWindup<ElementType, MetadataType>; | ||
| export declare type PlayedWindup<ElementType, MetadataType> = [Array<PlayedWindupMember<ElementType, MetadataType>>, MetadataType]; | ||
| export declare function isPlayedWindup<ElementType, MetadataType>(windup: PlayedWindup<ElementType, MetadataType> | Windup<ElementType, MetadataType>): windup is PlayedWindup<ElementType, MetadataType>; | ||
| export declare function memberIsWindup<ElementType, MetadataType>(member: WindupMember<ElementType, MetadataType>): member is Windup<ElementType, MetadataType>; | ||
| export declare function playedMemberIsWindup<ElementType, MetadataType>(member: PlayedWindupMember<ElementType, MetadataType>): member is PlayedWindup<ElementType, MetadataType>; | ||
| export declare function windupFromString<MetadataType>(str: string, metadata: MetadataType): Windup<string, MetadataType>; | ||
| export declare function newWindup<ElementType, MetadataType>(arg: Array<WindupMember<ElementType, MetadataType>>, metadata: MetadataType): Windup<ElementType, MetadataType>; | ||
| export declare function isUnplayed<ElementType, MetadataType>(windup: Windup<ElementType, MetadataType>): boolean; | ||
| export declare function isFinished<ElementType, MetadataType>([_played, remaining]: Windup<ElementType, MetadataType>): boolean; | ||
| export declare function fastForward<ElementType, MetadataType>(windup: Windup<ElementType, MetadataType>): Windup<ElementType, MetadataType>; | ||
| export declare function rewind<ElementType, MetadataType>(windup: Windup<ElementType, MetadataType>): Windup<ElementType, MetadataType>; | ||
| export declare function windupAsString<MetadataType>(windup: Windup<string, MetadataType>): string; | ||
| export declare function lastPlayedMember<ElementType, MetadataType>([played, remaining]: Windup<ElementType, MetadataType>): WindupMember<ElementType, MetadataType> | undefined; | ||
| export declare function lastPlayedElement<ElementType, MetadataType>(windup: Windup<ElementType, MetadataType>): ElementType | undefined; | ||
| export declare type PlayedWindup<ElementType, MetadataType> = [Array<ElementType>, MetadataType]; | ||
| export declare function playedElements<ElementType, MetadataType>([played, remaining]: Windup<ElementType, MetadataType>): Array<ElementType | PlayedWindup<ElementType, MetadataType>>; | ||
| export declare function nextElement<ElementType, MetadataType>([_played, remaining]: Windup<ElementType, MetadataType>): ElementType | undefined; | ||
| export declare function next<ElementType, MetadataType>(windup: Windup<ElementType, MetadataType>): Windup<ElementType, MetadataType>; | ||
| export declare function isUnplayed<ElementType, MetadataType>(windup: Windup<ElementType, MetadataType> | PlayedWindup<ElementType, MetadataType>): boolean; | ||
| export declare function isFinished<ElementType, MetadataType>(windup: Windup<ElementType, MetadataType> | PlayedWindup<ElementType, MetadataType>): boolean; | ||
| export declare function fastForward<ElementType, MetadataType>(windup: Windup<ElementType, MetadataType> | PlayedWindup<ElementType, MetadataType>): PlayedWindup<ElementType, MetadataType>; | ||
| export declare function rewind<ElementType, MetadataType>(windup: Windup<ElementType, MetadataType> | PlayedWindup<ElementType, MetadataType>): Windup<ElementType, MetadataType>; | ||
| export declare function windupAsString<MetadataType>(windup: Windup<string, MetadataType> | PlayedWindup<string, MetadataType>): string; | ||
| export declare function lastPlayedMember<ElementType, MetadataType>(windup: Windup<ElementType, MetadataType> | PlayedWindup<ElementType, MetadataType>): PlayedWindupMember<ElementType, MetadataType> | undefined; | ||
| export declare function lastPlayedElement<ElementType, MetadataType>(windup: Windup<ElementType, MetadataType> | PlayedWindup<ElementType, MetadataType>): ElementType | undefined; | ||
| export declare function playedElements<ElementType, MetadataType>(windup: Windup<ElementType, MetadataType> | PlayedWindup<ElementType, MetadataType>): Array<PlayedWindupMember<ElementType, MetadataType>>; | ||
| export declare function nextElement<ElementType, MetadataType>(windup: Windup<ElementType, MetadataType> | PlayedWindup<ElementType, MetadataType>): ElementType | undefined; | ||
| export declare function prev<ElementType, MetadataType>(windup: Windup<ElementType, MetadataType> | PlayedWindup<ElementType, MetadataType>): Windup<ElementType, MetadataType>; | ||
| export declare function next<ElementType, MetadataType>(windup: Windup<ElementType, MetadataType>): Windup<ElementType, MetadataType> | PlayedWindup<ElementType, MetadataType>; |
@@ -8,7 +8,26 @@ 'use strict'; | ||
| var React = require('react'); | ||
| var isEqual = _interopDefault(require('fast-deep-equal')); | ||
| var breakLines = _interopDefault(require('break-styled-lines')); | ||
| var isEqual$1 = _interopDefault(require('fast-deep-equal/es6/react')); | ||
| // Is the windup of type PlayedWindup? | ||
| function isPlayedWindup(windup) { | ||
| return windup.length === 2; | ||
| } | ||
| // If it's not an array it can't be a windup | ||
| if (!Array.isArray(windup)) { | ||
| return false; | ||
| } // If it has less or more than three members it's not a windup | ||
| if (windup.length !== 2) { | ||
| return false; | ||
| } // If its first member is not anarrays it's not a windup | ||
| if (!Array.isArray(windup[0])) { | ||
| return false; | ||
| } | ||
| return true; | ||
| } // Is the member a windup, or just a member type? | ||
| function memberIsWindup(member) { | ||
@@ -32,3 +51,25 @@ // If it's not an array it can't be a windup | ||
| return true; | ||
| } | ||
| } // Is the member a windup, or just a member type? | ||
| function playedMemberIsWindup(member) { | ||
| // If it's not an array it can't be a windup | ||
| if (!Array.isArray(member)) { | ||
| return false; | ||
| } // If it has less or more than three members it's not a windup | ||
| if (member.length !== 2) { | ||
| return false; | ||
| } // If its first member is not an array it's not a windup | ||
| if (!Array.isArray(member[0])) { | ||
| return false; | ||
| } // Past here we just have to hope ElementType isn't a windup. | ||
| return true; | ||
| } // Create a windup from a given string | ||
| // "Hello", metadata -> [[], ["H", "e", "l", "l", "o"], metadata] | ||
| function windupFromString(str, metadata) { | ||
@@ -39,4 +80,10 @@ return [[], str.split(""), metadata]; | ||
| return [[], arg, metadata]; | ||
| } | ||
| } // Checks if the windup is unplayed | ||
| // INCLUDING any nested windups in the remaining part of the windup | ||
| function isUnplayed(windup) { | ||
| if (isPlayedWindup(windup)) { | ||
| return false; | ||
| } | ||
| var played = windup[0], | ||
@@ -55,11 +102,21 @@ remaining = windup[1]; | ||
| }, true); | ||
| } | ||
| function isFinished(_ref) { | ||
| var remaining = _ref[1]; | ||
| } // Checks if a windup has any remaining parts | ||
| function isFinished(windup) { | ||
| if (isPlayedWindup(windup)) { | ||
| return true; | ||
| } | ||
| var remaining = windup[1]; | ||
| return remaining.length === 0; | ||
| } | ||
| } // Turn a Windup into a PlayedWindup | ||
| function fastForward(windup) { | ||
| if (isPlayedWindup(windup)) { | ||
| return windup; | ||
| } | ||
| var forwardedWindup = next(windup); | ||
| if (isFinished(forwardedWindup)) { | ||
| if (isPlayedWindup(forwardedWindup)) { | ||
| return forwardedWindup; | ||
@@ -69,11 +126,11 @@ } | ||
| return fastForward(forwardedWindup); | ||
| } | ||
| } // Turn an in-progress Windup or PlayedWindup into an unplayed Windup | ||
| function rewind(windup) { | ||
| if (isUnplayed(windup)) { | ||
| if (!isPlayedWindup(windup) && isUnplayed(windup)) { | ||
| return windup; | ||
| } | ||
| var played = windup[0], | ||
| remaining = windup[1], | ||
| metadata = windup[2]; | ||
| var played = windup[0]; | ||
| var metadata = isPlayedWindup(windup) ? windup[1] : windup[2]; | ||
@@ -88,7 +145,26 @@ var mapRewind = function mapRewind(member) { | ||
| return [[], [].concat(played.map(mapRewind), remaining.map(mapRewind)), metadata]; | ||
| var playedMapRewind = function playedMapRewind(member) { | ||
| if (playedMemberIsWindup(member)) { | ||
| return rewind(member); | ||
| } | ||
| return member; | ||
| }; | ||
| if (isPlayedWindup(windup)) { | ||
| return [[], played.map(playedMapRewind), metadata]; | ||
| } | ||
| var remaining = windup[1]; | ||
| return [[], [].concat(played.map(playedMapRewind), remaining.map(mapRewind)), metadata]; | ||
| } | ||
| function lastPlayedMember(_ref2) { | ||
| var played = _ref2[0], | ||
| remaining = _ref2[1]; | ||
| function lastPlayedMember(windup) { | ||
| if (isPlayedWindup(windup)) { | ||
| var _played = windup[0]; | ||
| var _last = _played[_played.length - 1]; | ||
| return _last; | ||
| } | ||
| var played = windup[0], | ||
| remaining = windup[1]; | ||
| var playedFromRemaining = remaining.reduce(function (playedEl, member) { | ||
@@ -114,3 +190,3 @@ if (memberIsWindup(member)) { | ||
| if (memberIsWindup(lastPlayed)) { | ||
| if (playedMemberIsWindup(lastPlayed)) { | ||
| return lastPlayedElement(lastPlayed); | ||
@@ -120,25 +196,28 @@ } | ||
| return lastPlayed; | ||
| } | ||
| function playedElements(_ref3) { | ||
| var played = _ref3[0], | ||
| remaining = _ref3[1]; | ||
| var playedTransformed = played.map(function (member) { | ||
| if (memberIsWindup(member)) { | ||
| var metadata = member[2]; | ||
| return [playedElements(member), metadata]; | ||
| } | ||
| } // Return the played elements of a windup | ||
| // INCLUDING any played elements from nested windups in the remaining part of the windup | ||
| return member; | ||
| }); | ||
| var firstRemaning = remaining[0]; | ||
| function playedElements(windup) { | ||
| if (isPlayedWindup(windup)) { | ||
| var _played2 = windup[0]; | ||
| return _played2; | ||
| } | ||
| if (memberIsWindup(firstRemaning) && !isUnplayed(firstRemaning)) { | ||
| var metadata = firstRemaning[2]; | ||
| return [].concat(playedTransformed, [[playedElements(firstRemaning), metadata]]); | ||
| var played = windup[0], | ||
| remaining = windup[1]; | ||
| var firstRemaining = remaining[0]; | ||
| if (memberIsWindup(firstRemaining) && !isUnplayed(firstRemaining)) { | ||
| var firstRemainingMetadata = firstRemaining[2]; | ||
| return [].concat(played, [[playedElements(firstRemaining), firstRemainingMetadata]]); | ||
| } | ||
| return playedTransformed; | ||
| return played; | ||
| } | ||
| function nextElement(_ref4) { | ||
| var remaining = _ref4[1]; | ||
| function nextElement(windup) { | ||
| if (isPlayedWindup(windup)) { | ||
| return undefined; | ||
| } | ||
| var remaining = windup[1]; | ||
| var nextVal = remaining[0]; | ||
@@ -161,3 +240,3 @@ | ||
| // [["h", "i"] ["n", "o"]], []] | ||
| if (isFinished(windup)) { | ||
| if (isPlayedWindup(windup)) { | ||
| return windup; | ||
@@ -172,6 +251,14 @@ } | ||
| if (!firstRemaining) { | ||
| return [played, metadata]; | ||
| } | ||
| if (memberIsWindup(firstRemaining)) { | ||
| var nextFirstRemaining = next(firstRemaining); | ||
| if (isFinished(nextFirstRemaining)) { | ||
| if (isPlayedWindup(nextFirstRemaining)) { | ||
| if (restRemaining.length === 0) { | ||
| return [[].concat(played, [nextFirstRemaining]), metadata]; | ||
| } | ||
| return [[].concat(played, [nextFirstRemaining]), restRemaining, metadata]; | ||
@@ -183,2 +270,6 @@ } | ||
| if (restRemaining.length === 0) { | ||
| return [[].concat(played, [firstRemaining]), metadata]; | ||
| } | ||
| return [[].concat(played, [firstRemaining]), restRemaining, metadata]; | ||
@@ -220,2 +311,759 @@ } | ||
| function isSuffixedWindup(windup) { | ||
| // If it's not an array it can't be a windup | ||
| if (!Array.isArray(windup)) { | ||
| return false; | ||
| } // If it has less or more than three members it's not a windup | ||
| if (windup.length !== 4) { | ||
| return false; | ||
| } // If its first or second members are not arrays it's not a windup | ||
| if (!Array.isArray(windup[0]) || !Array.isArray(windup[1])) { | ||
| return false; | ||
| } // Past here we just have to hope ElementType isn't a windup. | ||
| return true; | ||
| } | ||
| function isPlayedSuffixedWindup(windup) { | ||
| // If it's not an array it can't be a windup | ||
| if (!Array.isArray(windup)) { | ||
| return false; | ||
| } // If it has less or more than three members it's not a windup | ||
| if (windup.length !== 3) { | ||
| return false; | ||
| } // If its first or second members are not arrays it's not a windup | ||
| if (!Array.isArray(windup[0]) || !Array.isArray(windup[1])) { | ||
| return false; | ||
| } // Past here we just have to hope ElementType isn't a windup. | ||
| return true; | ||
| } | ||
| function isUnplayed$1(windup) { | ||
| var played = windup[0], | ||
| remaining = windup[1]; | ||
| if (isPlayedSuffixedWindup(windup)) { | ||
| return false; | ||
| } | ||
| if (played.length > 0) { | ||
| return false; | ||
| } | ||
| return remaining.reduce(function (unplayed, member) { | ||
| if (isSuffixedWindup(member)) if (isSuffixedWindup(windup) && unplayed) { | ||
| return isUnplayed$1(member); | ||
| } | ||
| return unplayed; | ||
| }, true); | ||
| } | ||
| function playedElements$1(suffixedWindup) { | ||
| if (isPlayedSuffixedWindup(suffixedWindup)) { | ||
| return suffixedWindup[0]; | ||
| } | ||
| var suffixedPlayed = suffixedWindup[0], | ||
| remaining = suffixedWindup[1]; | ||
| var remainingMembers = remaining.reduce(function (acc, member) { | ||
| if (isPlayedSuffixedWindup(member)) { | ||
| return [].concat(acc, playedElementsWithSuffix(member)); | ||
| } | ||
| if (isSuffixedWindup(member)) { | ||
| var metadata = member[3]; | ||
| var els = playedElementsWithSuffix(member); | ||
| if (els.length === 0) { | ||
| return acc; | ||
| } | ||
| return [].concat(acc, [[playedElementsWithSuffix(member), [], metadata]]); | ||
| } | ||
| return acc; | ||
| }, []); | ||
| return [].concat(suffixedPlayed, remainingMembers); | ||
| } | ||
| function playedElementsWithSuffix(windup) { | ||
| if (isPlayedSuffixedWindup(windup)) { | ||
| var _played = windup[0], | ||
| _suffix = windup[1]; | ||
| return [].concat(_played, _suffix.map(function (member) { | ||
| if (playedMemberIsWindup(member)) { | ||
| return playedWindupToSuffixed(member); | ||
| } | ||
| return member; | ||
| })); | ||
| } | ||
| var played = playedElements$1(windup); | ||
| var suffix = windup[2]; | ||
| var suffixAsSuffixPlayedMembers = suffix.map(function (member) { | ||
| if (playedMemberIsWindup(member)) { | ||
| return playedWindupToSuffixed(member); | ||
| } | ||
| return member; | ||
| }); | ||
| return [].concat(played, suffixAsSuffixPlayedMembers); | ||
| } | ||
| function prev(suffixedWindup) { | ||
| if (isPlayedSuffixedWindup(suffixedWindup)) { | ||
| var _played2 = suffixedWindup[0], | ||
| _suffix2 = suffixedWindup[1], | ||
| _metadata = suffixedWindup[2]; | ||
| var _restPlayed = _played2.slice(0, -1); | ||
| var _lastPlayed = _played2[_played2.length - 1]; | ||
| if (!_lastPlayed) { | ||
| return [_played2, [], _suffix2, _metadata]; | ||
| } | ||
| if (isPlayedSuffixedWindup(_lastPlayed)) { | ||
| return [_restPlayed, [prev(_lastPlayed)], _suffix2, _metadata]; | ||
| } | ||
| return [_restPlayed, [_lastPlayed], _suffix2, _metadata]; | ||
| } | ||
| var played = suffixedWindup[0], | ||
| remaining = suffixedWindup[1], | ||
| suffix = suffixedWindup[2], | ||
| metadata = suffixedWindup[3]; | ||
| var firstRemaining = remaining[0], | ||
| restRemaining = remaining.slice(1); | ||
| if (!firstRemaining) { | ||
| var _restPlayed2 = played.slice(0, -1); | ||
| var _lastPlayed2 = played[played.length - 1]; | ||
| if (!_lastPlayed2) { | ||
| return [played, [], suffix, metadata]; | ||
| } | ||
| if (isPlayedSuffixedWindup(_lastPlayed2)) { | ||
| return [_restPlayed2, [prev(_lastPlayed2)], suffix, metadata]; | ||
| } | ||
| return [_restPlayed2, [_lastPlayed2], suffix, metadata]; | ||
| } // check if first remaining is an inprogress windup | ||
| if (isSuffixedWindup(firstRemaining) && !isUnplayed$1(firstRemaining)) { | ||
| return [played, [prev(firstRemaining)].concat(restRemaining), suffix, metadata]; | ||
| } // if it's not (element or unplayed) | ||
| // take the last element of the played value | ||
| var restPlayed = played.slice(0, -1); | ||
| var lastPlayed = played[played.length - 1]; | ||
| if (isPlayedSuffixedWindup(lastPlayed)) { | ||
| return [restPlayed, [prev(lastPlayed)].concat(remaining), suffix, metadata]; | ||
| } // if it's an element, just take it | ||
| return [restPlayed, [lastPlayed].concat(remaining), suffix, metadata]; | ||
| } | ||
| function next$1(suffixedWindup) { | ||
| if (isPlayedSuffixedWindup(suffixedWindup)) { | ||
| return suffixedWindup; | ||
| } | ||
| var played = suffixedWindup[0], | ||
| remaining = suffixedWindup[1], | ||
| suffix = suffixedWindup[2], | ||
| metadata = suffixedWindup[3]; | ||
| var firstRemaining = remaining[0], | ||
| restRemaining = remaining.slice(1); | ||
| if (!firstRemaining) { | ||
| return [played, suffix, metadata]; | ||
| } | ||
| if (isSuffixedWindup(firstRemaining)) { | ||
| var nextFirstRemaining = next$1(firstRemaining); | ||
| if (isPlayedSuffixedWindup(nextFirstRemaining)) { | ||
| if (restRemaining.length === 0) { | ||
| return [[].concat(played, [nextFirstRemaining]), suffix, metadata]; | ||
| } | ||
| return [[].concat(played, [nextFirstRemaining]), restRemaining, suffix, metadata]; | ||
| } | ||
| return [played, [nextFirstRemaining].concat(restRemaining), suffix, metadata]; | ||
| } | ||
| if (restRemaining.length === 0) { | ||
| return [[].concat(played, [firstRemaining]), suffix, metadata]; | ||
| } | ||
| return [[].concat(played, [firstRemaining]), restRemaining, suffix, metadata]; | ||
| } | ||
| function fastForward$1(windup) { | ||
| var forwardedWindup = next$1(windup); | ||
| if (isPlayedSuffixedWindup(forwardedWindup)) { | ||
| return forwardedWindup; | ||
| } | ||
| return fastForward$1(forwardedWindup); | ||
| } | ||
| function windupToSuffixed(windup) { | ||
| var played = windup[0], | ||
| remainder = windup[1], | ||
| metadata = windup[2]; | ||
| return [played.map(function (member) { | ||
| if (!playedMemberIsWindup(member)) { | ||
| return member; | ||
| } | ||
| return playedWindupToSuffixed(member); | ||
| }), remainder.map(function (member) { | ||
| if (!memberIsWindup(member)) { | ||
| return member; | ||
| } | ||
| return windupToSuffixed(member); | ||
| }), [], metadata]; | ||
| } | ||
| function playedWindupToSuffixed(windup) { | ||
| var played = windup[0], | ||
| metadata = windup[1]; | ||
| return [played.map(function (member) { | ||
| if (!playedMemberIsWindup(member)) { | ||
| return member; | ||
| } | ||
| return playedWindupToSuffixed(member); | ||
| }), [], metadata]; | ||
| } | ||
| var MemberKind; | ||
| (function (MemberKind) { | ||
| MemberKind[MemberKind["Played"] = 0] = "Played"; | ||
| MemberKind[MemberKind["InProgress"] = 1] = "InProgress"; | ||
| })(MemberKind || (MemberKind = {})); | ||
| function allMembers(windup) { | ||
| var played = isPlayedWindup(windup) ? windup[0] : windup[0]; | ||
| var remainder = !isPlayedWindup(windup) ? windup[1] : []; | ||
| return [].concat(played.map(function (member) { | ||
| return playedMemberIsWindup(member) ? { | ||
| member: member, | ||
| kind: MemberKind.Played, | ||
| isWindup: true | ||
| } : { | ||
| member: member, | ||
| kind: MemberKind.Played, | ||
| isWindup: false | ||
| }; | ||
| }), remainder.map(function (member) { | ||
| return memberIsWindup(member) ? { | ||
| member: member, | ||
| kind: MemberKind.InProgress, | ||
| isWindup: true | ||
| } : { | ||
| member: member, | ||
| kind: MemberKind.InProgress, | ||
| isWindup: false | ||
| }; | ||
| })); | ||
| } // Check if members are equivalent | ||
| function isMemberEquivalent(memberA, memberB) { | ||
| if (!memberA.isWindup && memberB.isWindup || memberA.isWindup && !memberB.isWindup) { | ||
| return false; | ||
| } | ||
| if (memberA.isWindup && memberB.isWindup) { | ||
| // TODO: look at metadata here | ||
| var aMetadata = getMetadata(memberA.member); | ||
| var bMetadata = getMetadata(memberB.member); | ||
| if (!isEqual(aMetadata, bMetadata)) { | ||
| return false; | ||
| } | ||
| var aMembers = allMembers(memberA.member); | ||
| var bMembers = allMembers(memberB.member); | ||
| if (aMembers.length !== bMembers.length) { | ||
| return false; | ||
| } | ||
| var zipped = zipMembersFromLeft(aMembers, bMembers); | ||
| return zipped.every(function (_ref) { | ||
| var a = _ref[0], | ||
| b = _ref[1]; | ||
| return b ? isMemberEquivalent(a, b) : false; | ||
| }); | ||
| } | ||
| return isEqual(memberA.member, memberB.member); | ||
| } | ||
| function matchesFromLeft(zipped) { | ||
| return zipped.reduce(function (matches, _ref2) { | ||
| var aMember = _ref2[0], | ||
| bMember = _ref2[1]; | ||
| if (bMember && isMemberEquivalent(aMember, bMember) && matches.unmatched.length === 0) { | ||
| return _extends({}, matches, { | ||
| matched: [].concat(matches.matched, [aMember]) | ||
| }); | ||
| } | ||
| return _extends({}, matches, { | ||
| unmatched: [].concat(matches.unmatched, [[aMember, bMember]]) | ||
| }); | ||
| }, { | ||
| matched: [], | ||
| unmatched: [] | ||
| }); | ||
| } | ||
| function matchesFromRight(zipped) { | ||
| return zipped.reduce(function (matches, _ref3) { | ||
| var aMember = _ref3[0], | ||
| bMember = _ref3[1]; | ||
| if (bMember && isMemberEquivalent(aMember, bMember) && matches.unmatched.length === 0) { | ||
| return _extends({}, matches, { | ||
| matched: [aMember].concat(matches.matched) | ||
| }); | ||
| } | ||
| return _extends({}, matches, { | ||
| unmatched: [[aMember, bMember]].concat(matches.unmatched) | ||
| }); | ||
| }, { | ||
| matched: [], | ||
| unmatched: [] | ||
| }); | ||
| } | ||
| function zipMembersFromLeft(baseMembers, againstMembers) { | ||
| return baseMembers.map(function (member, i) { | ||
| return [member, againstMembers[i]]; | ||
| }); | ||
| } | ||
| function zipMembersFromRight(baseMembers, againstMembers) { | ||
| var zippedFromEnd = []; | ||
| for (var i = 0; i <= baseMembers.length - 1; i++) { | ||
| zippedFromEnd.push([baseMembers[baseMembers.length - 1 - i], againstMembers[againstMembers.length - 1 - i]]); | ||
| } | ||
| return zippedFromEnd; | ||
| } | ||
| function prefixFromPair(pair) { | ||
| var baseMember = pair[0], | ||
| againstMember = pair[1]; | ||
| if (!baseMember.isWindup) { | ||
| return undefined; | ||
| } | ||
| if (!(againstMember != null && againstMember.isWindup)) { | ||
| return undefined; | ||
| } | ||
| var metadata = getMetadata(baseMember.member); | ||
| var baseMembers = allMembers(baseMember.member); | ||
| var againstMembers = allMembers(againstMember.member); | ||
| var zipped = zipMembersFromLeft(baseMembers, againstMembers); | ||
| var _matchesFromLeft = matchesFromLeft(zipped), | ||
| matched = _matchesFromLeft.matched, | ||
| unmatchedFromLeft = _matchesFromLeft.unmatched; | ||
| var played = matched.map(function (member) { | ||
| if (member.kind === MemberKind.InProgress && member.isWindup) { | ||
| return playedWindupToSuffixed(fastForward(member.member)); | ||
| } | ||
| if (member.kind === MemberKind.Played && member.isWindup) { | ||
| return playedWindupToSuffixed(member.member); | ||
| } | ||
| return member.member; | ||
| }); | ||
| var firstUnmatchedFromLeft = unmatchedFromLeft[0]; | ||
| var maybePrefix = prefixFromPair(firstUnmatchedFromLeft); | ||
| var fromLeftBaseMembers = unmatchedFromLeft.map(function (_ref4) { | ||
| var baseAnnotated = _ref4[0]; | ||
| return baseAnnotated; | ||
| }).map(annotatedMemberToRemaining); | ||
| if (maybePrefix) { | ||
| var remaining = fromLeftBaseMembers.slice(1, 0); | ||
| return [played, [maybePrefix].concat(remaining), [], metadata]; | ||
| } | ||
| return [played, fromLeftBaseMembers, [], metadata]; | ||
| } | ||
| function suffixFromPair(pair) { | ||
| var baseMember = pair[0], | ||
| againstMember = pair[1]; | ||
| if (!baseMember.isWindup) { | ||
| return undefined; | ||
| } | ||
| if (!(againstMember != null && againstMember.isWindup)) { | ||
| return undefined; | ||
| } | ||
| var metadata = getMetadata(baseMember.member); | ||
| var baseMembers = allMembers(baseMember.member); | ||
| var againstMembers = allMembers(againstMember.member); | ||
| var zipped = zipMembersFromRight(baseMembers, againstMembers); | ||
| var _matchesFromRight = matchesFromRight(zipped), | ||
| matched = _matchesFromRight.matched, | ||
| unmatchedFromRight = _matchesFromRight.unmatched; | ||
| var lastUnmatchedFromRight = unmatchedFromRight[unmatchedFromRight.length - 1]; | ||
| var maybeSuffix = prefixFromPair(lastUnmatchedFromRight); | ||
| var suffix = matched.map(annotatedMemberToPlayed); | ||
| if (maybeSuffix) { | ||
| var _remaining = baseMembers.slice(0, unmatchedFromRight.length - 1).map(annotatedMemberToRemaining); | ||
| return [[], [].concat(_remaining, [maybeSuffix]), suffix, metadata]; | ||
| } | ||
| var remaining = [].concat(unmatchedFromRight).map(function (_ref5) { | ||
| var baseAnnotated = _ref5[0]; | ||
| return baseAnnotated; | ||
| }).map(annotatedMemberToRemaining); | ||
| return [[], remaining, suffix, metadata]; | ||
| } | ||
| function annotatedMemberToRemaining(annotated) { | ||
| if (annotated.isWindup && annotated.kind === MemberKind.Played) { | ||
| // This shouldn't happen when this is used... | ||
| return prev(playedWindupToSuffixed(annotated.member)); | ||
| } | ||
| if (annotated.isWindup) { | ||
| return windupToSuffixed(annotated.member); | ||
| } | ||
| return annotated.member; | ||
| } | ||
| function annotatedMemberToPlayed(annotated) { | ||
| if (annotated.isWindup && annotated.kind === MemberKind.InProgress) { | ||
| // This shouldn't happen when this is used... | ||
| return fastForward(annotated.member); | ||
| } | ||
| return annotated.member; | ||
| } | ||
| function playedAndRemainingFromUnmatched(fromLeft, fromRight) { | ||
| if (fromLeft.length === 0 || fromRight.length === 0) { | ||
| return { | ||
| played: [], | ||
| remaining: [] | ||
| }; | ||
| } | ||
| var _fromLeft$ = fromLeft[0], | ||
| firstBaseFromLeft = _fromLeft$[0], | ||
| firstAgainstFromLeft = _fromLeft$[1]; | ||
| var _fromRight = fromRight[fromRight.length - 1], | ||
| firstBaseFromRight = _fromRight[0], | ||
| firstAgainstFromRight = _fromRight[1]; | ||
| if (fromLeft.length === 1 && fromRight.length === 1 && firstBaseFromLeft.isWindup && firstAgainstFromLeft != null && firstAgainstFromLeft.isWindup) { | ||
| var merged = mergeWindupsToSuffixedWindup(firstBaseFromLeft.member, firstAgainstFromLeft.member); | ||
| if (isPlayedSuffixedWindup(merged)) { | ||
| return { | ||
| played: [merged], | ||
| remaining: [] | ||
| }; | ||
| } | ||
| return { | ||
| played: [], | ||
| remaining: [merged] | ||
| }; | ||
| } | ||
| var playedEls = fromLeft.filter(function (_ref6) { | ||
| var baseAnnotated = _ref6[0]; | ||
| return baseAnnotated.kind === MemberKind.Played; | ||
| }); | ||
| var played = playedEls.map(function (_ref7) { | ||
| var baseAnnotated = _ref7[0]; | ||
| return baseAnnotated; | ||
| }).map(function (baseAnnotated) { | ||
| if (baseAnnotated.isWindup && baseAnnotated.kind === MemberKind.InProgress) { | ||
| return fastForward$1(windupToSuffixed(baseAnnotated.member)); | ||
| } | ||
| if (baseAnnotated.isWindup) { | ||
| return playedWindupToSuffixed(baseAnnotated.member); | ||
| } | ||
| return baseAnnotated.member; | ||
| }); | ||
| var shiftedLeft = fromLeft.slice(played.length); | ||
| if (shiftedLeft.length === 0 && playedEls.length === 0) { | ||
| return { | ||
| played: played, | ||
| remaining: [] | ||
| }; | ||
| } | ||
| if (shiftedLeft.length === 0) { | ||
| var shiftedFromRight = fromRight.slice(0, playedEls.length); | ||
| var _shiftedFromRight = shiftedFromRight[shiftedFromRight.length - 1], | ||
| baseFromRight = _shiftedFromRight[0], | ||
| againstFromRight = _shiftedFromRight[1]; | ||
| var _maybeWindupSuffix = suffixFromPair([baseFromRight, againstFromRight]); | ||
| if (_maybeWindupSuffix) { | ||
| var playedWithoutSuffix = played.slice(0, -1); | ||
| return { | ||
| played: [].concat(playedWithoutSuffix, [fastForward$1(_maybeWindupSuffix)]), | ||
| remaining: [] | ||
| }; | ||
| } | ||
| return { | ||
| played: played, | ||
| remaining: [] | ||
| }; | ||
| } | ||
| var _shiftedLeft$ = shiftedLeft[0], | ||
| firstBaseFromShiftedLeft = _shiftedLeft$[0], | ||
| firstAgainstFromShiftedLeft = _shiftedLeft$[1]; | ||
| var maybeWindupPrefix = prefixFromPair([firstBaseFromShiftedLeft, firstAgainstFromShiftedLeft]); | ||
| var maybeWindupSuffix = suffixFromPair([firstBaseFromRight, firstAgainstFromRight]); | ||
| var shiftedLeftBaseMembers = shiftedLeft.map(function (_ref8) { | ||
| var baseAnnotated = _ref8[0]; | ||
| return baseAnnotated; | ||
| }).map(annotatedMemberToRemaining); | ||
| if (maybeWindupPrefix && maybeWindupSuffix) { | ||
| var remaining = shiftedLeftBaseMembers.slice(1, -1); | ||
| return { | ||
| played: played, | ||
| remaining: [maybeWindupPrefix].concat(remaining, [maybeWindupSuffix]) | ||
| }; | ||
| } | ||
| if (!maybeWindupPrefix && maybeWindupSuffix) { | ||
| var _remaining2 = shiftedLeftBaseMembers.slice(0, -1); | ||
| return { | ||
| played: played, | ||
| remaining: [].concat(_remaining2, [maybeWindupSuffix]) | ||
| }; | ||
| } | ||
| if (maybeWindupPrefix && !maybeWindupSuffix) { | ||
| var _remaining3 = shiftedLeftBaseMembers.slice(1); | ||
| return { | ||
| played: played, | ||
| remaining: [maybeWindupPrefix].concat(_remaining3) | ||
| }; | ||
| } | ||
| return { | ||
| played: played, | ||
| remaining: shiftedLeftBaseMembers | ||
| }; | ||
| } | ||
| function mergeWindupsToSuffixedWindup(baseWindup, againstWindup) { | ||
| var metadata = getMetadata(baseWindup); // Get all the members and zip them up. | ||
| var baseMembers = allMembers(baseWindup); | ||
| var againstMembers = allMembers(againstWindup); | ||
| var zipped = zipMembersFromLeft(baseMembers, againstMembers); | ||
| var _matchesFromLeft2 = matchesFromLeft(zipped), | ||
| matched = _matchesFromLeft2.matched, | ||
| unmatchedFromLeft = _matchesFromLeft2.unmatched; | ||
| var played = matched.map(function (member) { | ||
| if (member.kind === MemberKind.InProgress && member.isWindup) { | ||
| return playedWindupToSuffixed(fastForward(member.member)); | ||
| } | ||
| if (member.kind === MemberKind.Played && member.isWindup) { | ||
| return playedWindupToSuffixed(member.member); | ||
| } | ||
| return member.member; | ||
| }); | ||
| var lengthToZipRight = baseMembers.length - played.length; | ||
| var zippedRight = zipMembersFromRight(baseMembers, againstMembers).slice(0, lengthToZipRight); | ||
| var _matchesFromRight2 = matchesFromRight(zippedRight), | ||
| matchedFromRight = _matchesFromRight2.matched, | ||
| unmatchedZippedFromRight = _matchesFromRight2.unmatched; | ||
| var unmatchedZippedFromLeft = unmatchedFromLeft.slice(0, unmatchedZippedFromRight.length); | ||
| var _playedAndRemainingFr = playedAndRemainingFromUnmatched(unmatchedZippedFromLeft, unmatchedZippedFromRight), | ||
| playedFromUnmatched = _playedAndRemainingFr.played, | ||
| remaining = _playedAndRemainingFr.remaining; | ||
| var suffix = matchedFromRight.map(function (member) { | ||
| if (member.kind === MemberKind.InProgress && member.isWindup) { | ||
| return fastForward(member.member); | ||
| } | ||
| if (member.kind === MemberKind.Played && member.isWindup) { | ||
| return member.member; | ||
| } | ||
| return member.member; | ||
| }); | ||
| if (remaining.length === 0) { | ||
| return [[].concat(played, playedFromUnmatched), suffix, metadata]; | ||
| } | ||
| return [[].concat(played, playedFromUnmatched), remaining, suffix, metadata]; | ||
| } | ||
| function getMetadata(windup) { | ||
| return isPlayedWindup(windup) ? windup[1] : windup[2]; | ||
| } | ||
| function lastPlayedSuffixedMember(windup) { | ||
| if (isPlayedSuffixedWindup(windup)) { | ||
| var _played3 = windup[0]; | ||
| var _last = _played3[_played3.length - 1]; | ||
| return _last; | ||
| } | ||
| var played = windup[0], | ||
| remaining = windup[1]; | ||
| var playedFromRemaining = remaining.reduce(function (playedEl, member) { | ||
| if (isSuffixedWindup(member)) { | ||
| if (!isUnplayed$1(member)) { | ||
| return lastPlayedSuffixedElement(member); | ||
| } | ||
| } | ||
| return playedEl; | ||
| }, undefined); | ||
| if (playedFromRemaining) { | ||
| return playedFromRemaining; | ||
| } | ||
| var last = played[played.length - 1]; | ||
| return last; | ||
| } | ||
| function lastPlayedSuffixedElement(windup) { | ||
| var lastPlayed = lastPlayedSuffixedMember(windup); | ||
| if (isPlayedSuffixedWindup(lastPlayed)) { | ||
| return lastPlayedSuffixedElement(lastPlayed); | ||
| } | ||
| return lastPlayed; | ||
| } | ||
| function nextSuffixedElement(windup) { | ||
| if (isPlayedSuffixedWindup(windup)) { | ||
| return undefined; | ||
| } | ||
| var remaining = windup[1]; | ||
| var nextVal = remaining[0]; | ||
| if (isSuffixedWindup(nextVal)) { | ||
| return nextSuffixedElement(nextVal); | ||
| } | ||
| return nextVal; | ||
| } | ||
| function unsuffixWindup(suffixed) { | ||
| var played = suffixed[0], | ||
| remaining = suffixed[1], | ||
| suffix = suffixed[2], | ||
| metadata = suffixed[3]; | ||
| var nextPlayed = played.map(function (member) { | ||
| if (isPlayedSuffixedWindup(member)) { | ||
| return unsuffixPlayedWindup(member); | ||
| } | ||
| return member; | ||
| }); | ||
| var nextRemaining = remaining.map(function (member) { | ||
| if (isSuffixedWindup(member)) { | ||
| return unsuffixWindup(member); | ||
| } | ||
| return member; | ||
| }); | ||
| var suffixAsMoreRemaining = suffix.map(function (member) { | ||
| if (playedMemberIsWindup(member)) { | ||
| return rewind(member); | ||
| } | ||
| return member; | ||
| }); | ||
| return [nextPlayed, [].concat(nextRemaining, suffixAsMoreRemaining), metadata]; | ||
| } | ||
| function unsuffixPlayedWindup(suffixed) { | ||
| var played = suffixed[0], | ||
| suffix = suffixed[1], | ||
| metadata = suffixed[2]; | ||
| var nextPlayed = played.map(function (member) { | ||
| if (isPlayedSuffixedWindup(member)) { | ||
| return unsuffixPlayedWindup(member); | ||
| } | ||
| return member; | ||
| }); | ||
| return [[].concat(nextPlayed, suffix), metadata]; | ||
| } | ||
| function commonPrefix(base, against) { | ||
| var baseMembers = allMembers(base); | ||
| var againstMembers = allMembers(against); | ||
| var zipped = zipMembersFromLeft(baseMembers, againstMembers); | ||
| var _matchesFromLeft3 = matchesFromLeft(zipped), | ||
| matched = _matchesFromLeft3.matched; | ||
| return matched.map(function (annotated) { | ||
| if (annotated.isWindup) { | ||
| return isPlayedWindup(annotated.member) ? playedWindupToSuffixed(annotated.member) : playedWindupToSuffixed(fastForward(annotated.member)); | ||
| } | ||
| return annotated.member; | ||
| }); | ||
| } | ||
| function defaultGetPace(lastChar, nextChar) { | ||
@@ -264,4 +1112,61 @@ switch (lastChar) { | ||
| } | ||
| function isReverseMsProp(props) { | ||
| if ("reverseMs" in props) { | ||
| return true; | ||
| } | ||
| return false; | ||
| } | ||
| function isReverseGetPaceProp(props) { | ||
| if ("reverseGetPace" in props) { | ||
| return true; | ||
| } | ||
| return false; | ||
| } | ||
| function paceMetadataFromProps(props) { | ||
| if (isMsProp(props)) { | ||
| var ms = props.ms, | ||
| reverseMs = props.reverseMs; | ||
| return _extends({ | ||
| pace: function pace() { | ||
| return ms; | ||
| } | ||
| }, reverseMs ? { | ||
| reversePace: function reversePace() { | ||
| return reverseMs; | ||
| } | ||
| } : {}); | ||
| } | ||
| if (isReverseMsProp(props)) { | ||
| var _ms = props.ms, | ||
| _reverseMs = props.reverseMs; | ||
| return _extends({ | ||
| reversePace: function reversePace() { | ||
| return _reverseMs; | ||
| } | ||
| }, _ms ? { | ||
| pace: function pace() { | ||
| return _ms; | ||
| } | ||
| } : {}); | ||
| } | ||
| if (isReverseGetPaceProp(props)) { | ||
| return _extends({ | ||
| reversePace: props.getReversePace | ||
| }, props.getPace ? { | ||
| pace: props.getPace | ||
| } : {}); | ||
| } | ||
| return _extends({ | ||
| pace: props.getPace | ||
| }, props.getReversePace ? { | ||
| reversePace: props.getReversePace | ||
| } : {}); | ||
| } | ||
| function paceFromWindup(windup, parentPace) { | ||
| if (isFinished(windup)) { | ||
| if (isPlayedWindup(windup)) { | ||
| return undefined; | ||
@@ -280,3 +1185,19 @@ } | ||
| } | ||
| function paceFromSuffixedWindup(windup, rewinding, parentPace) { | ||
| if (isPlayedSuffixedWindup(windup)) { | ||
| return undefined; | ||
| } | ||
| var remaining = windup[1], | ||
| metadata = windup[3]; | ||
| var firstRemaining = remaining[0]; | ||
| var paceToUse = rewinding ? metadata.reversePace : metadata.pace; | ||
| if (firstRemaining && isSuffixedWindup(firstRemaining)) { | ||
| return paceFromSuffixedWindup(firstRemaining, rewinding, paceToUse || parentPace); | ||
| } | ||
| return paceToUse || parentPace; | ||
| } | ||
| var OnChar = function OnChar(_ref) { | ||
@@ -294,2 +1215,6 @@ var children = _ref.children; | ||
| function onCharsFromWindup(windup) { | ||
| if (isPlayedWindup(windup)) { | ||
| return []; | ||
| } | ||
| var remaining = windup[1], | ||
@@ -301,3 +1226,3 @@ metadata = windup[2]; | ||
| if (lastPlayed && memberIsWindup(lastPlayed)) { | ||
| if (lastPlayed && playedMemberIsWindup(lastPlayed)) { | ||
| onChars.push.apply(onChars, onCharsFromWindup(lastPlayed)); | ||
@@ -316,3 +1241,28 @@ } | ||
| } | ||
| function onCharsFromSuffixedWindup(windup) { | ||
| if (isPlayedSuffixedWindup(windup)) { | ||
| return []; | ||
| } | ||
| var remaining = windup[1], | ||
| metadata = windup[3]; | ||
| var lastPlayed = lastPlayedSuffixedMember(windup); | ||
| var firstRemaining = remaining[0]; | ||
| var onChars = []; | ||
| if (lastPlayed && isPlayedSuffixedWindup(lastPlayed)) { | ||
| onChars.push.apply(onChars, onCharsFromSuffixedWindup(lastPlayed)); | ||
| } | ||
| if (firstRemaining && isSuffixedWindup(firstRemaining) && !isUnplayed$1(firstRemaining)) { | ||
| onChars.push.apply(onChars, onCharsFromSuffixedWindup(firstRemaining)); | ||
| } | ||
| if (metadata.onChar) { | ||
| onChars.push(metadata.onChar); | ||
| } | ||
| return onChars; | ||
| } | ||
| function initWindupState(windup) { | ||
@@ -331,2 +1281,6 @@ return { | ||
| case "next": | ||
| if (isPlayedWindup(state.windup)) { | ||
| return state; | ||
| } | ||
| return _extends({}, state, { | ||
@@ -343,2 +1297,6 @@ windup: next(state.windup) | ||
| case "fast-forward": | ||
| if (isPlayedWindup(state.windup)) { | ||
| return state; | ||
| } | ||
| return _extends({}, state, { | ||
@@ -420,3 +1378,3 @@ windup: fastForward(state.windup) | ||
| onChars.forEach(function (onChar) { | ||
| onChar(lastEl); | ||
| onChar(lastEl, false); | ||
| }); | ||
@@ -470,3 +1428,3 @@ } | ||
| function renderStringWindup(windup) { | ||
| var played = isPlayedWindup(windup) ? windup[0] : playedElements(windup); | ||
| var played = playedElements(windup); | ||
| var inner = played.reduce(function (acc, playedEl) { | ||
@@ -484,3 +1442,3 @@ if (typeof playedEl === "string") { | ||
| var metadata = isPlayedWindup(windup) ? windup[1] : windup[2]; | ||
| var played = isPlayedWindup(windup) ? windup[0] : playedElements(windup); | ||
| var played = playedElements(windup); | ||
| var Outer = metadata.element || React.Fragment; | ||
@@ -575,3 +1533,2 @@ | ||
| } | ||
| function reduceWindupArgs(prevArgs, children) { | ||
@@ -594,11 +1551,3 @@ if (typeof children === "string") { | ||
| var paceMetaData = isPaceElement(children) ? { | ||
| pace: function pace(_char) { | ||
| if (isMsProp(children.props)) { | ||
| return children.props.ms; | ||
| } | ||
| return children.props.getPace(_char); | ||
| } | ||
| } : {}; | ||
| var paceMetaData = isPaceElement(children) ? paceMetadataFromProps(children.props) : {}; | ||
| var onCharMetaData = isOnCharElement(children) ? { | ||
@@ -902,2 +1851,331 @@ onChar: children.props.fn | ||
| function renderSuffixedStringWindup(windup) { | ||
| var played = playedElementsWithSuffix(windup); | ||
| var inner = played.reduce(function (acc, playedEl) { | ||
| if (typeof playedEl === "string") { | ||
| return acc + playedEl; | ||
| } | ||
| return acc + renderSuffixedStringWindup(playedEl); | ||
| }, ""); | ||
| var suffix = isPlayedSuffixedWindup(windup) ? [] : windup[2]; | ||
| var innerSuffixed = suffix.reduce(function (acc, suffixEl) { | ||
| if (typeof suffixEl === "string") { | ||
| return acc + suffixEl; | ||
| } | ||
| return acc + renderStringWindup(suffixEl); | ||
| }, ""); | ||
| return inner + innerSuffixed; | ||
| } | ||
| function renderSuffixedChildrenWindup(windup) { | ||
| var metadata = isPlayedSuffixedWindup(windup) ? windup[2] : windup[3]; | ||
| var played = playedElementsWithSuffix(windup); | ||
| var Outer = metadata.element || React.Fragment; | ||
| if (metadata.props && Object.keys(metadata.props).includes("children")) { | ||
| return React.createElement(Outer, Object.assign({ | ||
| key: metadata.key | ||
| }, metadata.props)); | ||
| } | ||
| var inner = played.reduce(function (acc, playedEl) { | ||
| if (typeof playedEl === "string") { | ||
| return [].concat(acc, [playedEl]); | ||
| } | ||
| return [].concat(acc, [renderSuffixedChildrenWindup(playedEl)]); | ||
| }, []); | ||
| if (typeof metadata.element === "string" && VOID_TAGS.includes(metadata.element)) { | ||
| return React.createElement(Outer, Object.assign({ | ||
| key: metadata.key | ||
| }, metadata.props)); | ||
| } | ||
| return React.createElement(Outer, Object.assign({ | ||
| key: metadata.key | ||
| }, metadata.props), inner); | ||
| } | ||
| function usePrevious(value) { | ||
| var ref = React.useRef(); | ||
| React.useEffect(function () { | ||
| ref.current = value; | ||
| }, [value]); | ||
| return ref.current; | ||
| } | ||
| function isRewindupState(state) { | ||
| if ("rewindUntil" in state) { | ||
| return true; | ||
| } | ||
| return false; | ||
| } | ||
| function isRewinding(state) { | ||
| return isRewindupState(state) ? !isEqual$1(state.rewindUntil, playedElements$1(state.toRewind)) : false; | ||
| } | ||
| function getActiveWindup(state) { | ||
| return isRewindupState(state) ? isRewinding(state) ? state.toRewind : state.toResume : state.toPlay; | ||
| } | ||
| function getNextBaseWindup(state) { | ||
| if (!isRewindupState(state)) { | ||
| return isPlayedSuffixedWindup(state.toPlay) ? unsuffixPlayedWindup(state.toPlay) : unsuffixWindup(state.toPlay); | ||
| } | ||
| if (isRewinding(state)) { | ||
| return isPlayedSuffixedWindup(state.toRewind) ? unsuffixPlayedWindup(state.toRewind) : unsuffixWindup(state.toRewind); | ||
| } | ||
| return isPlayedSuffixedWindup(state.toResume) ? unsuffixPlayedWindup(state.toResume) : unsuffixWindup(state.toResume); | ||
| } | ||
| function rewindupReducer(state, action) { | ||
| switch (action.type) { | ||
| case "start-rewindup": | ||
| { | ||
| var toRewind = mergeWindupsToSuffixedWindup(action.baseWindup, action.againstWindup); | ||
| var toResume = mergeWindupsToSuffixedWindup(action.againstWindup, action.baseWindup); | ||
| var rewindUntil = commonPrefix(action.baseWindup, action.againstWindup); | ||
| return { | ||
| toRewind: toRewind, | ||
| rewindUntil: rewindUntil, | ||
| toResume: toResume | ||
| }; | ||
| } | ||
| case "proceed": | ||
| { | ||
| if (!isRewindupState(state)) { | ||
| if (isPlayedSuffixedWindup(state.toPlay)) { | ||
| return state; | ||
| } | ||
| return { | ||
| toPlay: next$1(state.toPlay) | ||
| }; | ||
| } | ||
| if (isEqual$1(state.rewindUntil, playedElements$1(state.toRewind))) { | ||
| var nextToResume = next$1(state.toResume); | ||
| return _extends({}, state, { | ||
| toResume: nextToResume | ||
| }); | ||
| } | ||
| var nextToRewind = prev(state.toRewind); | ||
| return _extends({}, state, { | ||
| toRewind: nextToRewind | ||
| }); | ||
| } | ||
| case "fast-forward": | ||
| { | ||
| return { | ||
| toPlay: fastForward$1(getActiveWindup(state)) | ||
| }; | ||
| } | ||
| default: | ||
| return state; | ||
| } | ||
| } | ||
| function useRewindup(windupInit, options) { | ||
| var _React$useReducer = React.useReducer(rewindupReducer, { | ||
| toPlay: isPlayedWindup(windupInit) ? playedWindupToSuffixed(windupInit) : windupToSuffixed(windupInit) | ||
| }), | ||
| state = _React$useReducer[0], | ||
| dispatch = _React$useReducer[1]; // When the windup changes, onChar should fire | ||
| React.useEffect(function () { | ||
| if (!state) { | ||
| return; | ||
| } | ||
| var windupToGetOnCharFrom = getActiveWindup(state); | ||
| var onChars = onCharsFromSuffixedWindup(windupToGetOnCharFrom); | ||
| var lastEl = lastPlayedSuffixedElement(windupToGetOnCharFrom); | ||
| if (onChars.length > 0 && lastEl) { | ||
| onChars.forEach(function (onChar) { | ||
| onChar(lastEl, isRewindupState(state)); | ||
| }); | ||
| } | ||
| }, [state]); | ||
| var timeoutRef = React.useRef(null); // Respect skipped | ||
| React.useEffect(function () { | ||
| if (timeoutRef.current) { | ||
| clearTimeout(timeoutRef.current); | ||
| } | ||
| if (options.skipped) { | ||
| dispatch({ | ||
| type: "fast-forward" | ||
| }); | ||
| } | ||
| if (options.skipped === false) { | ||
| dispatch({ | ||
| type: "start-rewindup", | ||
| baseWindup: getNextBaseWindup(state), | ||
| againstWindup: windupInit | ||
| }); | ||
| } | ||
| }, [options.skipped]); // If windup finishes, the onFinished should fire | ||
| var windupIsFinished = isPlayedSuffixedWindup(getActiveWindup(state)); | ||
| var prevWindupIsFinished = usePrevious(windupIsFinished); | ||
| React.useEffect(function () { | ||
| // Put this in a new context so that the windup finishes visually before firing this | ||
| if (prevWindupIsFinished === false && windupIsFinished) { | ||
| var timeout = setTimeout(function () { | ||
| if (options.onFinished) { | ||
| options.onFinished(); | ||
| } | ||
| }, 0); | ||
| return function () { | ||
| clearTimeout(timeout); | ||
| }; | ||
| } | ||
| }, [prevWindupIsFinished, windupIsFinished, options.onFinished]); // Proceed the windup | ||
| React.useEffect(function () { | ||
| var isPlayed = isPlayedSuffixedWindup(isRewindupState(state) ? state.toResume : state.toPlay); | ||
| var isRewindDone = isRewindupState(state) ? isEqual$1(playedElements$1(state.toRewind), state.rewindUntil) : true; | ||
| if (!state || isPlayed && isRewindDone) { | ||
| return; | ||
| } | ||
| var windupToGetPaceFrom = getActiveWindup(state); | ||
| var getPace = paceFromSuffixedWindup(windupToGetPaceFrom, isRewindupState(state)) || defaultGetPace; | ||
| var lastEl = lastPlayedSuffixedElement(windupToGetPaceFrom); | ||
| var nextEl = nextSuffixedElement(windupToGetPaceFrom); | ||
| var timeout = lastEl ? getPace(lastEl, nextEl) : 0; | ||
| timeoutRef.current = setTimeout(function () { | ||
| dispatch({ | ||
| type: "proceed" | ||
| }); | ||
| }, timeout); | ||
| return function () { | ||
| if (timeoutRef.current) { | ||
| clearTimeout(timeoutRef.current); | ||
| } | ||
| }; | ||
| }, [state]); | ||
| var prevWindupInit = usePrevious(windupInit); | ||
| React.useEffect(function () { | ||
| if (prevWindupInit === undefined) { | ||
| return; | ||
| } | ||
| if (prevWindupInit === windupInit) { | ||
| return; | ||
| } | ||
| if (options.onRewindStart) { | ||
| options.onRewindStart(); | ||
| } | ||
| dispatch({ | ||
| type: "start-rewindup", | ||
| baseWindup: getNextBaseWindup(state), | ||
| againstWindup: windupInit | ||
| }); | ||
| }, [windupInit, prevWindupInit]); | ||
| var skip = React.useCallback(function () { | ||
| dispatch({ | ||
| type: "fast-forward" | ||
| }); | ||
| }, []); | ||
| var rewind = React.useCallback(function () { | ||
| dispatch({ | ||
| type: "start-rewindup", | ||
| baseWindup: newWindup([], {}), | ||
| againstWindup: windupInit | ||
| }); | ||
| }, []); | ||
| return { | ||
| windup: getActiveWindup(state), | ||
| skip: skip, | ||
| rewind: rewind, | ||
| isFinished: windupIsFinished | ||
| }; | ||
| } | ||
| function useRewindupString(text, options) { | ||
| if (options === void 0) { | ||
| options = {}; | ||
| } | ||
| var windupInit = React.useMemo(function () { | ||
| return windupFromString(text, options); // We can omit options as this is used as an initialisation value and options will not change it | ||
| // eslint-disable-next-line react-hooks/exhaustive-deps | ||
| }, [text]); | ||
| var _useRewindup = useRewindup(windupInit, options), | ||
| windup = _useRewindup.windup, | ||
| skip = _useRewindup.skip, | ||
| rewind = _useRewindup.rewind, | ||
| isFinished = _useRewindup.isFinished; | ||
| var rendered = renderSuffixedStringWindup(windup); | ||
| React.useDebugValue(rendered); | ||
| return [rendered, { | ||
| skip: skip, | ||
| rewind: rewind, | ||
| isFinished: isFinished | ||
| }]; | ||
| } | ||
| function RewindupChildren(_ref) { | ||
| var children = _ref.children, | ||
| onFinished = _ref.onFinished, | ||
| onRewindStart = _ref.onRewindStart, | ||
| skipped = _ref.skipped; | ||
| var windupInit = useChildrenMemo(function () { | ||
| if (children === undefined) { | ||
| return newWindup([], { | ||
| element: undefined | ||
| }); | ||
| } | ||
| return newWindup(React.Children.toArray(children).reduce(reduceWindupArgs, []), { | ||
| element: undefined | ||
| }); | ||
| }, children); | ||
| var maybeSkippedWindupInit = React.useMemo(function () { | ||
| if (skipped) { | ||
| return fastForward(windupInit); | ||
| } | ||
| return windupInit; | ||
| }, [windupInit, skipped]); | ||
| var _useRewindup = useRewindup(maybeSkippedWindupInit, { | ||
| onFinished: onFinished, | ||
| onRewindStart: onRewindStart, | ||
| skipped: skipped | ||
| }), | ||
| windup = _useRewindup.windup, | ||
| skip = _useRewindup.skip, | ||
| rewind = _useRewindup.rewind, | ||
| isFinished = _useRewindup.isFinished; | ||
| return React.createElement(WindupContext.Provider, { | ||
| value: { | ||
| skip: skip, | ||
| rewind: rewind, | ||
| isFinished: isFinished | ||
| } | ||
| }, renderSuffixedChildrenWindup(windup)); | ||
| } | ||
| exports.CharWrapper = CharWrapper; | ||
@@ -909,2 +2187,3 @@ exports.Effect = Effect; | ||
| exports.Pause = Pause; | ||
| exports.RewindupChildren = RewindupChildren; | ||
| exports.StyledText = StyledText; | ||
@@ -916,4 +2195,5 @@ exports.WindupChildren = WindupChildren; | ||
| exports.useRewind = useRewind; | ||
| exports.useRewindupString = useRewindupString; | ||
| exports.useSkip = useSkip; | ||
| exports.useWindupString = useWindupString; | ||
| //# sourceMappingURL=windups.cjs.development.js.map |
@@ -1,2 +0,2 @@ | ||
| "use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e,n=require("react"),r=(e=require("break-styled-lines"))&&"object"==typeof e&&"default"in e?e.default:e;function t(e){return 2===e.length}function i(e){return!!Array.isArray(e)&&3===e.length&&!(!Array.isArray(e[0])||!Array.isArray(e[1]))}function u(e,n){return[[],e.split(""),n]}function c(e,n){return[[],e,n]}function o(e){return!(e[0].length>0)&&e[1].reduce((function(n,r){return i(r)&&i(e)&&n?o(r):n}),!0)}function s(e){return 0===e[1].length}function a(e){var n=h(e);return s(n)?n:a(n)}function p(e){if(o(e))return e;var n=e[1],r=e[2],t=function(e){return i(e)?p(e):e};return[[],[].concat(e[0].map(t),n.map(t)),r]}function f(e){var n=e[0];return e[1].reduce((function(e,n){return i(n)&&!o(n)?l(n):e}),void 0)||n[n.length-1]}function l(e){var n=f(e);return i(n)?l(n):n}function d(e){var n=e[1],r=e[0].map((function(e){if(i(e)){var n=e[2];return[d(e),n]}return e})),t=n[0];if(i(t)&&!o(t)){var u=t[2];return[].concat(r,[[d(t),u]])}return r}function h(e){if(s(e))return e;var n=e[0],r=e[1],t=e[2],u=r[0],c=r.slice(1);if(i(u)){var o=h(u);return s(o)?[[].concat(n,[o]),c,t]:[n,[o].concat(c),t]}return[[].concat(n,[u]),c,t]}function y(){return(y=Object.assign||function(e){for(var n=1;n<arguments.length;n++){var r=arguments[n];for(var t in r)Object.prototype.hasOwnProperty.call(r,t)&&(e[t]=r[t])}return e}).apply(this,arguments)}function m(e,n){switch(e){case"—":case"…":return 200;case".":case",":return 150;case"?":case"!":return"!"!==n&&"?"!==n?150:20;case"-":case" ":case"\n":return 0;default:return 20}}var v=function(e){return n.createElement(n.Fragment,null,e.children)},g=function(e){return n.createElement(n.Fragment,null,e.children)};function k(e){return{windup:e,didFinishOnce:!1}}function w(e,n){switch(n.type){case"replace":return k(n.windup);case"next":return y({},e,{windup:h(e.windup)});case"rewind":return{windup:p(e.windup),didFinishOnce:!1};case"fast-forward":return y({},e,{windup:a(e.windup)});case"finish":return y({},e,{didFinishOnce:!0});default:return e}}function E(e,r){var t=n.useReducer(w,e,k),u=t[0],c=u.windup,a=u.didFinishOnce,p=t[1],d=n.useRef(null),h=s(c),y=n.useCallback((function(){h||(d.current&&clearTimeout(d.current),p({type:"fast-forward"}))}),[h]),v=n.useCallback((function(){d.current&&clearTimeout(d.current),p({type:"rewind"})}),[]);return n.useEffect((function(){p({type:"replace",windup:e})}),[e]),n.useEffect((function(){d.current&&clearTimeout(d.current),r.skipped&&p({type:"fast-forward"}),!1===r.skipped&&p({type:"rewind"})}),[r.skipped]),n.useEffect((function(){var e=function e(n){var r=n[1],t=n[2],u=f(n),c=r[0],s=[];return u&&i(u)&&s.push.apply(s,e(u)),c&&i(c)&&!o(c)&&s.push.apply(s,e(c)),t.onChar&&s.push(t.onChar),s}(c),n=l(c);e.length>0&&n&&e.forEach((function(e){e(n)}))}),[c]),n.useEffect((function(){if(!1===a&&h){var e=setTimeout((function(){r.onFinished&&r.onFinished(),p({type:"finish"})}),0);return function(){clearTimeout(e)}}}),[a,h,r]),n.useEffect((function(){if(!h){var e=function e(n,r){if(!s(n)){var t=n[2],u=n[1][0];return u&&i(u)?e(u,t.pace||r):t.pace||r}}(c)||m,n=l(c),r=function e(n){var r=n[1][0];return i(r)?e(r):r}(c);return d.current=setTimeout((function(){p({type:"next"})}),n?e(n,r):0),function(){d.current&&clearTimeout(d.current)}}}),[c,h]),{windup:c,skip:y,rewind:v,isFinished:h}}var x=["area","base","br","col","command","embed","hr","img","input","keygen","link","meta","param","source","track","wbr"],b=function(){return null},F=n.createContext({skip:function(){console.warn("Tried to use the useSkip hook outside of a WindupChildren component!!")},rewind:function(){console.warn("Tried to use the useRewind hook outside of a WindupChildren component!")},isFinished:!1});function C(e,r){if("string"==typeof r)return[].concat(e,r.split(""));if("number"==typeof r)return[].concat(e,r.toString().split(""));if(!n.isValidElement(r))return e;var t=r.props,o=t.children,s=function(e,n){if(null==e)return{};var r,t,i={},u=Object.keys(e);for(t=0;t<u.length;t++)n.indexOf(r=u[t])>=0||(i[r]=e[r]);return i}(t,["children"]),a=r.type===v?{pace:function(e){return"ms"in r.props?r.props.ms:r.props.getPace(e)}}:{},p=function(e){return e.type===g}(r)?{onChar:r.props.fn}:{},f=r.key?{key:r.key}:{};if(function(e){return e.type===b}(r))return[].concat(e,[u(" ",y({element:n.Fragment},f,{props:{children:void 0},pace:function(){return r.props.ms}}))]);if(void 0===o)return[].concat(e,[u(" ",y({element:r.type,props:y({},s,{children:void 0})},f,a,p))]);if("string"==typeof o)return[].concat(e,[u(o,y({element:r.type,props:s},f,a,p))]);if(o instanceof Function)return[].concat(e,[u(" ",y({element:r.type,props:y({children:o},s)},f,a,p))]);var l=n.Children.toArray(o).reduce(C,[]).map((function(e){return i(e)?[e[0],e[1],y({},a,p,e[2])]:e}));return[].concat(e,[c(l,y({element:r.type,props:s},f,a,p))])}function O(e){if(null==e)return"";var r=n.Children.map(e,(function(e){return"string"==typeof e?e:"number"==typeof e?e.toString():n.isValidElement(e)?"#"+(e.key||"")+"<"+O(e.props.children)+">":""}));return r?r.join(","):""}function j(e,r){var t=e[0],i=e[1];if("string"==typeof r||"number"==typeof r){var u=i[0],c=i.slice(1);return[[].concat(t,[u]),c]}if(!n.isValidElement(r))return[t,i];var o=n.Children.toArray(r.props.children).reduce(j,[[],i]),s=o[1];return[[].concat(t,[n.cloneElement(r,{children:o[0]})]),s]}function S(e){return e.type===A}function A(e){return n.createElement(n.Fragment,null,e.children)}exports.CharWrapper=function(e){var r=e.element;return n.createElement(n.Fragment,null,n.Children.map(e.children,(function(e){return function e(r,t){if("string"==typeof r)return r.split("").map((function(e,r){return"\n"===e?e:n.createElement(t,{key:e+"-"+r},e)}));if("number"==typeof r)return r.toString().split("").map((function(e){return n.createElement(t,null,e)}));if(!n.isValidElement(r))return n.createElement(n.Fragment,null);if(r.props.children){var i=r.type;return r.props.children instanceof Function?n.createElement(i,Object.assign({key:r.key},r.props)):n.createElement(i,Object.assign({key:r.key},r.props),n.Children.map(r.props.children,(function(n){return e(n,t)})))}return r}(e,r)})))},exports.Effect=function(e){var r=e.fn;return n.useEffect((function(){r()}),[]),null},exports.Linebreaker=function(e){var t=e.fontStyle,i=e.width,u=n.Children.toArray(e.children),c=u.reduce(function e(r){return function(t,i){return"string"==typeof i?[].concat(t,[{text:i,font:r}]):"number"==typeof i?[].concat(t,[{text:i.toString(),font:r}]):n.isValidElement(i)?S(i)&&"string"==typeof i.props.children?[].concat(t,[{text:i.props.children,font:i.props.fontStyle}]):S(i)?[].concat(t,n.Children.toArray(i.props.children).reduce(e(i.props.fontStyle),[])):[].concat(t,n.Children.toArray(i.props.children).reduce(e(r),[])):t}}(t),[]),o=r(c,i,t),s=u.reduce(j,[[],o]);return n.createElement("div",{style:{whiteSpace:"pre"}},s[0])},exports.OnChar=g,exports.Pace=v,exports.Pause=b,exports.StyledText=A,exports.WindupChildren=function(e){var r=e.children,i=e.onFinished,u=e.skipped,o=E(function(e,r){return n.useMemo(e,[O(r)])}((function(){return c(n.Children.toArray(r).reduce(C,[]),{element:void 0})}),r),{onFinished:i,skipped:u});return n.createElement(F.Provider,{value:{skip:o.skip,rewind:o.rewind,isFinished:o.isFinished}},function e(r){var i=t(r)?r[1]:r[2],u=t(r)?r[0]:d(r),c=i.element||n.Fragment;if(i.props&&Object.keys(i.props).includes("children"))return n.createElement(c,Object.assign({key:i.key},i.props));var o=u.reduce((function(n,r){if("string"==typeof r){var t=n.slice(0,n.length-1),i=n[n.length-1];return i&&"string"==typeof i?[].concat(t,[i+r]):[].concat(n,[r])}return[].concat(n,[e(r)])}),[]);return"string"==typeof i.element&&x.includes(i.element)?n.createElement(c,Object.assign({key:i.key},i.props)):n.createElement(c,Object.assign({key:i.key},i.props),o)}(o.windup))},exports.defaultGetPace=m,exports.textFromChildren=function e(r){var t=n.Children.map(r,(function(r){return"string"==typeof r?r:"number"==typeof r?r.toString():n.isValidElement(r)&&r.props.children?e(r.props.children):""}));return t?t.join(""):""},exports.useIsFinished=function(){return n.useContext(F).isFinished},exports.useRewind=function(){return n.useContext(F).rewind},exports.useSkip=function(){return n.useContext(F).skip},exports.useWindupString=function(e,r){void 0===r&&(r={});var i=E(n.useMemo((function(){return u(e,r)}),[e]),r),c=i.skip,o=i.rewind,s=i.isFinished,a=function e(n){return(t(n)?n[0]:d(n)).reduce((function(n,r){return"string"==typeof r?n+r:n+e(r)}),"")}(i.windup);return n.useDebugValue(a),[a,{skip:c,rewind:o,isFinished:s}]}; | ||
| "use strict";function e(e){return e&&"object"==typeof e&&"default"in e?e.default:e}Object.defineProperty(exports,"__esModule",{value:!0});var n,r=require("react"),t=e(require("fast-deep-equal")),i=e(require("break-styled-lines")),u=e(require("fast-deep-equal/es6/react"));function c(e){return!!Array.isArray(e)&&2===e.length&&!!Array.isArray(e[0])}function a(e){return!!Array.isArray(e)&&3===e.length&&!(!Array.isArray(e[0])||!Array.isArray(e[1]))}function o(e){return!!Array.isArray(e)&&2===e.length&&!!Array.isArray(e[0])}function s(e,n){return[[],e.split(""),n]}function f(e,n){return[[],e,n]}function p(e){return!c(e)&&!(e[0].length>0)&&e[1].reduce((function(n,r){return a(r)&&a(e)&&n?p(r):n}),!0)}function d(e){if(c(e))return e;var n=v(e);return c(n)?n:d(n)}function l(e){if(!c(e)&&p(e))return e;var n=e[0],r=c(e)?e[1]:e[2],t=function(e){return o(e)?l(e):e};if(c(e))return[[],n.map(t),r];var i=e[1];return[[],[].concat(n.map(t),i.map((function(e){return a(e)?l(e):e}))),r]}function m(e){if(c(e)){var n=e[0];return n[n.length-1]}var r=e[0];return e[1].reduce((function(e,n){return a(n)&&!p(n)?h(n):e}),void 0)||r[r.length-1]}function h(e){var n=m(e);return o(n)?h(n):n}function y(e){if(c(e))return e[0];var n=e[0],r=e[1][0];if(a(r)&&!p(r)){var t=r[2];return[].concat(n,[[y(r),t]])}return n}function v(e){if(c(e))return e;var n=e[0],r=e[1],t=e[2],i=r[0],u=r.slice(1);if(!i)return[n,t];if(a(i)){var o=v(i);return c(o)?0===u.length?[[].concat(n,[o]),t]:[[].concat(n,[o]),u,t]:[n,[o].concat(u),t]}return 0===u.length?[[].concat(n,[i]),t]:[[].concat(n,[i]),u,t]}function g(){return(g=Object.assign||function(e){for(var n=1;n<arguments.length;n++){var r=arguments[n];for(var t in r)Object.prototype.hasOwnProperty.call(r,t)&&(e[t]=r[t])}return e}).apply(this,arguments)}function b(e){return!!Array.isArray(e)&&4===e.length&&!(!Array.isArray(e[0])||!Array.isArray(e[1]))}function w(e){return!!Array.isArray(e)&&3===e.length&&!(!Array.isArray(e[0])||!Array.isArray(e[1]))}function k(e){var n=e[0],r=e[1];return!w(e)&&!(n.length>0)&&r.reduce((function(n,r){return b(r)&&b(e)&&n?k(r):n}),!0)}function P(e){if(w(e))return e[0];var n=e[0],r=e[1].reduce((function(e,n){if(w(n))return[].concat(e,W(n));if(b(n)){var r=n[3];return 0===W(n).length?e:[].concat(e,[[W(n),[],r]])}return e}),[]);return[].concat(n,r)}function W(e){if(w(e))return[].concat(e[0],e[1].map((function(e){return o(e)?C(e):e})));var n=P(e),r=e[2].map((function(e){return o(e)?C(e):e}));return[].concat(n,r)}function E(e){if(w(e)){var n=e[0],r=e[1],t=e[2],i=n.slice(0,-1),u=n[n.length-1];return u?w(u)?[i,[E(u)],r,t]:[i,[u],r,t]:[n,[],r,t]}var c=e[0],a=e[1],o=e[2],s=e[3],f=a[0],p=a.slice(1);if(!f){var d=c.slice(0,-1),l=c[c.length-1];return l?w(l)?[d,[E(l)],o,s]:[d,[l],o,s]:[c,[],o,s]}if(b(f)&&!k(f))return[c,[E(f)].concat(p),o,s];var m=c.slice(0,-1),h=c[c.length-1];return w(h)?[m,[E(h)].concat(a),o,s]:[m,[h].concat(a),o,s]}function F(e){if(w(e))return e;var n=e[0],r=e[1],t=e[2],i=e[3],u=r[0],c=r.slice(1);if(!u)return[n,t,i];if(b(u)){var a=F(u);return w(a)?0===c.length?[[].concat(n,[a]),t,i]:[[].concat(n,[a]),c,t,i]:[n,[a].concat(c),t,i]}return 0===c.length?[[].concat(n,[u]),t,i]:[[].concat(n,[u]),c,t,i]}function R(e){var n=F(e);return w(n)?n:R(n)}function A(e){var n=e[1],r=e[2];return[e[0].map((function(e){return o(e)?C(e):e})),n.map((function(e){return a(e)?A(e):e})),[],r]}function C(e){var n=e[1];return[e[0].map((function(e){return o(e)?C(e):e})),[],n]}function x(e){var r=(c(e),e[0]),t=c(e)?[]:e[1];return[].concat(r.map((function(e){return o(e)?{member:e,kind:n.Played,isWindup:!0}:{member:e,kind:n.Played,isWindup:!1}})),t.map((function(e){return a(e)?{member:e,kind:n.InProgress,isWindup:!0}:{member:e,kind:n.InProgress,isWindup:!1}})))}function O(e,n){if(!e.isWindup&&n.isWindup||e.isWindup&&!n.isWindup)return!1;if(e.isWindup&&n.isWindup){var r=G(e.member),i=G(n.member);if(!t(r,i))return!1;var u=x(e.member),c=x(n.member);return u.length===c.length&&T(u,c).every((function(e){var n=e[1];return!!n&&O(e[0],n)}))}return t(e.member,n.member)}function S(e){return e.reduce((function(e,n){var r=n[0],t=n[1];return t&&O(r,t)&&0===e.unmatched.length?g({},e,{matched:[].concat(e.matched,[r])}):g({},e,{unmatched:[].concat(e.unmatched,[[r,t]])})}),{matched:[],unmatched:[]})}function j(e){return e.reduce((function(e,n){var r=n[0],t=n[1];return t&&O(r,t)&&0===e.unmatched.length?g({},e,{matched:[r].concat(e.matched)}):g({},e,{unmatched:[[r,t]].concat(e.unmatched)})}),{matched:[],unmatched:[]})}function T(e,n){return e.map((function(e,r){return[e,n[r]]}))}function I(e,n){for(var r=[],t=0;t<=e.length-1;t++)r.push([e[e.length-1-t],n[n.length-1-t]]);return r}function M(e){var r=e[0],t=e[1];if(r.isWindup&&null!=t&&t.isWindup){var i=G(r.member),u=S(T(x(r.member),x(t.member))),c=u.unmatched,a=u.matched.map((function(e){return e.kind===n.InProgress&&e.isWindup?C(d(e.member)):e.kind===n.Played&&e.isWindup?C(e.member):e.member})),o=M(c[0]),s=c.map((function(e){return e[0]})).map(q);if(o){var f=s.slice(1,0);return[a,[o].concat(f),[],i]}return[a,s,[],i]}}function V(e){var n=e[0],r=e[1];if(n.isWindup&&null!=r&&r.isWindup){var t=G(n.member),i=x(n.member),u=j(I(i,x(r.member))),c=u.matched,a=u.unmatched,o=M(a[a.length-1]),s=c.map(U);if(o){var f=i.slice(0,a.length-1).map(q);return[[],[].concat(f,[o]),s,t]}return[[],[].concat(a).map((function(e){return e[0]})).map(q),s,t]}}function q(e){return e.isWindup&&e.kind===n.Played?E(C(e.member)):e.isWindup?A(e.member):e.member}function U(e){return e.isWindup&&e.kind===n.InProgress?d(e.member):e.member}function D(e,r){var t=G(e),i=x(e),u=x(r),c=S(T(i,u)),a=c.unmatched,o=c.matched.map((function(e){return e.kind===n.InProgress&&e.isWindup?C(d(e.member)):e.kind===n.Played&&e.isWindup?C(e.member):e.member})),s=i.length-o.length,f=j(I(i,u).slice(0,s)),p=f.matched,l=f.unmatched,m=function(e,r){if(0===e.length||0===r.length)return{played:[],remaining:[]};var t=e[0],i=t[0],u=t[1],c=r[r.length-1],a=c[0],o=c[1];if(1===e.length&&1===r.length&&i.isWindup&&null!=u&&u.isWindup){var s=D(i.member,u.member);return w(s)?{played:[s],remaining:[]}:{played:[],remaining:[s]}}var f=e.filter((function(e){return e[0].kind===n.Played})),p=f.map((function(e){return e[0]})).map((function(e){return e.isWindup&&e.kind===n.InProgress?R(A(e.member)):e.isWindup?C(e.member):e.member})),d=e.slice(p.length);if(0===d.length&&0===f.length)return{played:p,remaining:[]};if(0===d.length){var l=r.slice(0,f.length),m=l[l.length-1],h=V([m[0],m[1]]);if(h){var y=p.slice(0,-1);return{played:[].concat(y,[R(h)]),remaining:[]}}return{played:p,remaining:[]}}var v=d[0],g=M([v[0],v[1]]),b=V([a,o]),k=d.map((function(e){return e[0]})).map(q);if(g&&b){var P=k.slice(1,-1);return{played:p,remaining:[g].concat(P,[b])}}if(!g&&b){var W=k.slice(0,-1);return{played:p,remaining:[].concat(W,[b])}}if(g&&!b){var E=k.slice(1);return{played:p,remaining:[g].concat(E)}}return{played:p,remaining:k}}(a.slice(0,l.length),l),h=m.played,y=m.remaining,v=p.map((function(e){return e.kind===n.InProgress&&e.isWindup?d(e.member):e.member}));return 0===y.length?[[].concat(o,h),v,t]:[[].concat(o,h),y,v,t]}function G(e){return c(e)?e[1]:e[2]}function _(e){if(w(e)){var n=e[0];return n[n.length-1]}var r=e[0];return e[1].reduce((function(e,n){return b(n)&&!k(n)?L(n):e}),void 0)||r[r.length-1]}function L(e){var n=_(e);return w(n)?L(n):n}function z(e){var n=e[1],r=e[2],t=e[3],i=e[0].map((function(e){return w(e)?B(e):e})),u=n.map((function(e){return b(e)?z(e):e})),c=r.map((function(e){return o(e)?l(e):e}));return[i,[].concat(u,c),t]}function B(e){var n=e[1],r=e[2],t=e[0].map((function(e){return w(e)?B(e):e}));return[[].concat(t,n),r]}function H(e,n){switch(e){case"—":case"…":return 200;case".":case",":return 150;case"?":case"!":return"!"!==n&&"?"!==n?150:20;case"-":case" ":case"\n":return 0;default:return 20}}!function(e){e[e.Played=0]="Played",e[e.InProgress=1]="InProgress"}(n||(n={}));var J=function(e){return r.createElement(r.Fragment,null,e.children)},K=function(e){return r.createElement(r.Fragment,null,e.children)};function N(e){return{windup:e,didFinishOnce:!1}}function Q(e,n){switch(n.type){case"replace":return N(n.windup);case"next":return c(e.windup)?e:g({},e,{windup:v(e.windup)});case"rewind":return{windup:l(e.windup),didFinishOnce:!1};case"fast-forward":return c(e.windup)?e:g({},e,{windup:d(e.windup)});case"finish":return g({},e,{didFinishOnce:!0});default:return e}}function X(e,n){var t=r.useReducer(Q,e,N),i=t[0],u=i.windup,s=i.didFinishOnce,f=t[1],d=r.useRef(null),l=function(e){return!!c(e)||0===e[1].length}(u),y=r.useCallback((function(){l||(d.current&&clearTimeout(d.current),f({type:"fast-forward"}))}),[l]),v=r.useCallback((function(){d.current&&clearTimeout(d.current),f({type:"rewind"})}),[]);return r.useEffect((function(){f({type:"replace",windup:e})}),[e]),r.useEffect((function(){d.current&&clearTimeout(d.current),n.skipped&&f({type:"fast-forward"}),!1===n.skipped&&f({type:"rewind"})}),[n.skipped]),r.useEffect((function(){var e=function e(n){if(c(n))return[];var r=n[1],t=n[2],i=m(n),u=r[0],s=[];return i&&o(i)&&s.push.apply(s,e(i)),u&&a(u)&&!p(u)&&s.push.apply(s,e(u)),t.onChar&&s.push(t.onChar),s}(u),n=h(u);e.length>0&&n&&e.forEach((function(e){e(n,!1)}))}),[u]),r.useEffect((function(){if(!1===s&&l){var e=setTimeout((function(){n.onFinished&&n.onFinished(),f({type:"finish"})}),0);return function(){clearTimeout(e)}}}),[s,l,n]),r.useEffect((function(){if(!l){var e=function e(n,r){if(!c(n)){var t=n[2],i=n[1][0];return i&&a(i)?e(i,t.pace||r):t.pace||r}}(u)||H,n=h(u),r=function e(n){if(!c(n)){var r=n[1][0];return a(r)?e(r):r}}(u);return d.current=setTimeout((function(){f({type:"next"})}),n?e(n,r):0),function(){d.current&&clearTimeout(d.current)}}}),[u,l]),{windup:u,skip:y,rewind:v,isFinished:l}}function Y(e){return y(e).reduce((function(e,n){return"string"==typeof n?e+n:e+Y(n)}),"")}var Z=["area","base","br","col","command","embed","hr","img","input","keygen","link","meta","param","source","track","wbr"],$=function(){return null},ee=r.createContext({skip:function(){console.warn("Tried to use the useSkip hook outside of a WindupChildren component!!")},rewind:function(){console.warn("Tried to use the useRewind hook outside of a WindupChildren component!")},isFinished:!1});function ne(e,n){if("string"==typeof n)return[].concat(e,n.split(""));if("number"==typeof n)return[].concat(e,n.toString().split(""));if(!r.isValidElement(n))return e;var t=n.props,i=t.children,u=function(e,n){if(null==e)return{};var r,t,i={},u=Object.keys(e);for(t=0;t<u.length;t++)n.indexOf(r=u[t])>=0||(i[r]=e[r]);return i}(t,["children"]),c=n.type===J?function(e){if(function(e){return"ms"in e}(e)){var n=e.ms,r=e.reverseMs;return g({pace:function(){return n}},r?{reversePace:function(){return r}}:{})}if(function(e){return"reverseMs"in e}(e)){var t=e.ms,i=e.reverseMs;return g({reversePace:function(){return i}},t?{pace:function(){return t}}:{})}return function(e){return"reverseGetPace"in e}(e)?g({reversePace:e.getReversePace},e.getPace?{pace:e.getPace}:{}):g({pace:e.getPace},e.getReversePace?{reversePace:e.getReversePace}:{})}(n.props):{},o=function(e){return e.type===K}(n)?{onChar:n.props.fn}:{},p=n.key?{key:n.key}:{};if(function(e){return e.type===$}(n))return[].concat(e,[s(" ",g({element:r.Fragment},p,{props:{children:void 0},pace:function(){return n.props.ms}}))]);if(void 0===i)return[].concat(e,[s(" ",g({element:n.type,props:g({},u,{children:void 0})},p,c,o))]);if("string"==typeof i)return[].concat(e,[s(i,g({element:n.type,props:u},p,c,o))]);if(i instanceof Function)return[].concat(e,[s(" ",g({element:n.type,props:g({children:i},u)},p,c,o))]);var d=r.Children.toArray(i).reduce(ne,[]).map((function(e){return a(e)?[e[0],e[1],g({},c,o,e[2])]:e}));return[].concat(e,[f(d,g({element:n.type,props:u},p,c,o))])}function re(e){if(null==e)return"";var n=r.Children.map(e,(function(e){return"string"==typeof e?e:"number"==typeof e?e.toString():r.isValidElement(e)?"#"+(e.key||"")+"<"+re(e.props.children)+">":""}));return n?n.join(","):""}function te(e,n){return r.useMemo(e,[re(n)])}function ie(e,n){var t=e[0],i=e[1];if("string"==typeof n||"number"==typeof n){var u=i[0],c=i.slice(1);return[[].concat(t,[u]),c]}if(!r.isValidElement(n))return[t,i];var a=r.Children.toArray(n.props.children).reduce(ie,[[],i]),o=a[1];return[[].concat(t,[r.cloneElement(n,{children:a[0]})]),o]}function ue(e){return e.type===ce}function ce(e){return r.createElement(r.Fragment,null,e.children)}function ae(e){var n=r.useRef();return r.useEffect((function(){n.current=e}),[e]),n.current}function oe(e){return"rewindUntil"in e}function se(e){return!!oe(e)&&!u(e.rewindUntil,P(e.toRewind))}function fe(e){return oe(e)?se(e)?e.toRewind:e.toResume:e.toPlay}function pe(e){return oe(e)?se(e)?w(e.toRewind)?B(e.toRewind):z(e.toRewind):w(e.toResume)?B(e.toResume):z(e.toResume):w(e.toPlay)?B(e.toPlay):z(e.toPlay)}function de(e,n){switch(n.type){case"start-rewindup":var r=D(n.baseWindup,n.againstWindup),t=D(n.againstWindup,n.baseWindup);return{toRewind:r,rewindUntil:(i=n.againstWindup,S(T(x(n.baseWindup),x(i))).matched.map((function(e){return e.isWindup?c(e.member)?C(e.member):C(d(e.member)):e.member}))),toResume:t};case"proceed":return oe(e)?u(e.rewindUntil,P(e.toRewind))?g({},e,{toResume:F(e.toResume)}):g({},e,{toRewind:E(e.toRewind)}):w(e.toPlay)?e:{toPlay:F(e.toPlay)};case"fast-forward":return{toPlay:R(fe(e))};default:return e}var i}function le(e,n){var t=r.useReducer(de,{toPlay:c(e)?C(e):A(e)}),i=t[0],a=t[1];r.useEffect((function(){if(i){var e=fe(i),n=function e(n){if(w(n))return[];var r=n[1],t=n[3],i=_(n),u=r[0],c=[];return i&&w(i)&&c.push.apply(c,e(i)),u&&b(u)&&!k(u)&&c.push.apply(c,e(u)),t.onChar&&c.push(t.onChar),c}(e),r=L(e);n.length>0&&r&&n.forEach((function(e){e(r,oe(i))}))}}),[i]);var o=r.useRef(null);r.useEffect((function(){o.current&&clearTimeout(o.current),n.skipped&&a({type:"fast-forward"}),!1===n.skipped&&a({type:"start-rewindup",baseWindup:pe(i),againstWindup:e})}),[n.skipped]);var s=w(fe(i)),p=ae(s);r.useEffect((function(){if(!1===p&&s){var e=setTimeout((function(){n.onFinished&&n.onFinished()}),0);return function(){clearTimeout(e)}}}),[p,s,n.onFinished]),r.useEffect((function(){var e=w(oe(i)?i.toResume:i.toPlay),n=!oe(i)||u(P(i.toRewind),i.rewindUntil);if(!(!i||e&&n)){var r=fe(i),t=function e(n,r,t){if(!w(n)){var i=n[3],u=n[1][0],c=r?i.reversePace:i.pace;return u&&b(u)?e(u,r,c||t):c||t}}(r,oe(i))||H,c=L(r),s=function e(n){if(!w(n)){var r=n[1][0];return b(r)?e(r):r}}(r),f=c?t(c,s):0;return o.current=setTimeout((function(){a({type:"proceed"})}),f),function(){o.current&&clearTimeout(o.current)}}}),[i]);var d=ae(e);r.useEffect((function(){void 0!==d&&d!==e&&(n.onRewindStart&&n.onRewindStart(),a({type:"start-rewindup",baseWindup:pe(i),againstWindup:e}))}),[e,d]);var l=r.useCallback((function(){a({type:"fast-forward"})}),[]),m=r.useCallback((function(){a({type:"start-rewindup",baseWindup:f([],{}),againstWindup:e})}),[]);return{windup:fe(i),skip:l,rewind:m,isFinished:s}}exports.CharWrapper=function(e){var n=e.element;return r.createElement(r.Fragment,null,r.Children.map(e.children,(function(e){return function e(n,t){if("string"==typeof n)return n.split("").map((function(e,n){return"\n"===e?e:r.createElement(t,{key:e+"-"+n},e)}));if("number"==typeof n)return n.toString().split("").map((function(e){return r.createElement(t,null,e)}));if(!r.isValidElement(n))return r.createElement(r.Fragment,null);if(n.props.children){var i=n.type;return n.props.children instanceof Function?r.createElement(i,Object.assign({key:n.key},n.props)):r.createElement(i,Object.assign({key:n.key},n.props),r.Children.map(n.props.children,(function(n){return e(n,t)})))}return n}(e,n)})))},exports.Effect=function(e){var n=e.fn;return r.useEffect((function(){n()}),[]),null},exports.Linebreaker=function(e){var n=e.fontStyle,t=e.width,u=r.Children.toArray(e.children),c=u.reduce(function e(n){return function(t,i){return"string"==typeof i?[].concat(t,[{text:i,font:n}]):"number"==typeof i?[].concat(t,[{text:i.toString(),font:n}]):r.isValidElement(i)?ue(i)&&"string"==typeof i.props.children?[].concat(t,[{text:i.props.children,font:i.props.fontStyle}]):ue(i)?[].concat(t,r.Children.toArray(i.props.children).reduce(e(i.props.fontStyle),[])):[].concat(t,r.Children.toArray(i.props.children).reduce(e(n),[])):t}}(n),[]),a=i(c,t,n),o=u.reduce(ie,[[],a]);return r.createElement("div",{style:{whiteSpace:"pre"}},o[0])},exports.OnChar=K,exports.Pace=J,exports.Pause=$,exports.RewindupChildren=function(e){var n=e.children,t=e.onFinished,i=e.onRewindStart,u=e.skipped,c=te((function(){return f(void 0===n?[]:r.Children.toArray(n).reduce(ne,[]),{element:void 0})}),n),a=le(r.useMemo((function(){return u?d(c):c}),[c,u]),{onFinished:t,onRewindStart:i,skipped:u});return r.createElement(ee.Provider,{value:{skip:a.skip,rewind:a.rewind,isFinished:a.isFinished}},function e(n){var t=w(n)?n[2]:n[3],i=W(n),u=t.element||r.Fragment;if(t.props&&Object.keys(t.props).includes("children"))return r.createElement(u,Object.assign({key:t.key},t.props));var c=i.reduce((function(n,r){return[].concat(n,"string"==typeof r?[r]:[e(r)])}),[]);return"string"==typeof t.element&&Z.includes(t.element)?r.createElement(u,Object.assign({key:t.key},t.props)):r.createElement(u,Object.assign({key:t.key},t.props),c)}(a.windup))},exports.StyledText=ce,exports.WindupChildren=function(e){var n=e.children,t=e.onFinished,i=e.skipped,u=X(te((function(){return f(r.Children.toArray(n).reduce(ne,[]),{element:void 0})}),n),{onFinished:t,skipped:i});return r.createElement(ee.Provider,{value:{skip:u.skip,rewind:u.rewind,isFinished:u.isFinished}},function e(n){var t=c(n)?n[1]:n[2],i=y(n),u=t.element||r.Fragment;if(t.props&&Object.keys(t.props).includes("children"))return r.createElement(u,Object.assign({key:t.key},t.props));var a=i.reduce((function(n,r){if("string"==typeof r){var t=n.slice(0,n.length-1),i=n[n.length-1];return i&&"string"==typeof i?[].concat(t,[i+r]):[].concat(n,[r])}return[].concat(n,[e(r)])}),[]);return"string"==typeof t.element&&Z.includes(t.element)?r.createElement(u,Object.assign({key:t.key},t.props)):r.createElement(u,Object.assign({key:t.key},t.props),a)}(u.windup))},exports.defaultGetPace=H,exports.textFromChildren=function e(n){var t=r.Children.map(n,(function(n){return"string"==typeof n?n:"number"==typeof n?n.toString():r.isValidElement(n)&&n.props.children?e(n.props.children):""}));return t?t.join(""):""},exports.useIsFinished=function(){return r.useContext(ee).isFinished},exports.useRewind=function(){return r.useContext(ee).rewind},exports.useRewindupString=function(e,n){void 0===n&&(n={});var t=le(r.useMemo((function(){return s(e,n)}),[e]),n),i=t.skip,u=t.rewind,c=t.isFinished,a=function e(n){return W(n).reduce((function(n,r){return"string"==typeof r?n+r:n+e(r)}),"")+(w(n)?[]:n[2]).reduce((function(e,n){return"string"==typeof n?e+n:e+Y(n)}),"")}(t.windup);return r.useDebugValue(a),[a,{skip:i,rewind:u,isFinished:c}]},exports.useSkip=function(){return r.useContext(ee).skip},exports.useWindupString=function(e,n){void 0===n&&(n={});var t=X(r.useMemo((function(){return s(e,n)}),[e]),n),i=t.skip,u=t.rewind,c=t.isFinished,a=Y(t.windup);return r.useDebugValue(a),[a,{skip:i,rewind:u,isFinished:c}]}; | ||
| //# sourceMappingURL=windups.cjs.production.min.js.map |
@@ -1,7 +0,26 @@ | ||
| import { createElement, Fragment, useReducer, useRef, useCallback, useEffect, useMemo, useDebugValue, useContext, createContext, Children, isValidElement, cloneElement } from 'react'; | ||
| import { createElement, Fragment, useReducer, useRef, useCallback, useEffect, useMemo, useDebugValue, createContext, useContext, Children, isValidElement, cloneElement } from 'react'; | ||
| import isEqual from 'fast-deep-equal'; | ||
| import breakLines from 'break-styled-lines'; | ||
| import isEqual$1 from 'fast-deep-equal/es6/react'; | ||
| // Is the windup of type PlayedWindup? | ||
| function isPlayedWindup(windup) { | ||
| return windup.length === 2; | ||
| } | ||
| // If it's not an array it can't be a windup | ||
| if (!Array.isArray(windup)) { | ||
| return false; | ||
| } // If it has less or more than three members it's not a windup | ||
| if (windup.length !== 2) { | ||
| return false; | ||
| } // If its first member is not anarrays it's not a windup | ||
| if (!Array.isArray(windup[0])) { | ||
| return false; | ||
| } | ||
| return true; | ||
| } // Is the member a windup, or just a member type? | ||
| function memberIsWindup(member) { | ||
@@ -25,3 +44,25 @@ // If it's not an array it can't be a windup | ||
| return true; | ||
| } | ||
| } // Is the member a windup, or just a member type? | ||
| function playedMemberIsWindup(member) { | ||
| // If it's not an array it can't be a windup | ||
| if (!Array.isArray(member)) { | ||
| return false; | ||
| } // If it has less or more than three members it's not a windup | ||
| if (member.length !== 2) { | ||
| return false; | ||
| } // If its first member is not an array it's not a windup | ||
| if (!Array.isArray(member[0])) { | ||
| return false; | ||
| } // Past here we just have to hope ElementType isn't a windup. | ||
| return true; | ||
| } // Create a windup from a given string | ||
| // "Hello", metadata -> [[], ["H", "e", "l", "l", "o"], metadata] | ||
| function windupFromString(str, metadata) { | ||
@@ -32,4 +73,10 @@ return [[], str.split(""), metadata]; | ||
| return [[], arg, metadata]; | ||
| } | ||
| } // Checks if the windup is unplayed | ||
| // INCLUDING any nested windups in the remaining part of the windup | ||
| function isUnplayed(windup) { | ||
| if (isPlayedWindup(windup)) { | ||
| return false; | ||
| } | ||
| var played = windup[0], | ||
@@ -48,11 +95,21 @@ remaining = windup[1]; | ||
| }, true); | ||
| } | ||
| function isFinished(_ref) { | ||
| var remaining = _ref[1]; | ||
| } // Checks if a windup has any remaining parts | ||
| function isFinished(windup) { | ||
| if (isPlayedWindup(windup)) { | ||
| return true; | ||
| } | ||
| var remaining = windup[1]; | ||
| return remaining.length === 0; | ||
| } | ||
| } // Turn a Windup into a PlayedWindup | ||
| function fastForward(windup) { | ||
| if (isPlayedWindup(windup)) { | ||
| return windup; | ||
| } | ||
| var forwardedWindup = next(windup); | ||
| if (isFinished(forwardedWindup)) { | ||
| if (isPlayedWindup(forwardedWindup)) { | ||
| return forwardedWindup; | ||
@@ -62,11 +119,11 @@ } | ||
| return fastForward(forwardedWindup); | ||
| } | ||
| } // Turn an in-progress Windup or PlayedWindup into an unplayed Windup | ||
| function rewind(windup) { | ||
| if (isUnplayed(windup)) { | ||
| if (!isPlayedWindup(windup) && isUnplayed(windup)) { | ||
| return windup; | ||
| } | ||
| var played = windup[0], | ||
| remaining = windup[1], | ||
| metadata = windup[2]; | ||
| var played = windup[0]; | ||
| var metadata = isPlayedWindup(windup) ? windup[1] : windup[2]; | ||
@@ -81,7 +138,26 @@ var mapRewind = function mapRewind(member) { | ||
| return [[], [].concat(played.map(mapRewind), remaining.map(mapRewind)), metadata]; | ||
| var playedMapRewind = function playedMapRewind(member) { | ||
| if (playedMemberIsWindup(member)) { | ||
| return rewind(member); | ||
| } | ||
| return member; | ||
| }; | ||
| if (isPlayedWindup(windup)) { | ||
| return [[], played.map(playedMapRewind), metadata]; | ||
| } | ||
| var remaining = windup[1]; | ||
| return [[], [].concat(played.map(playedMapRewind), remaining.map(mapRewind)), metadata]; | ||
| } | ||
| function lastPlayedMember(_ref2) { | ||
| var played = _ref2[0], | ||
| remaining = _ref2[1]; | ||
| function lastPlayedMember(windup) { | ||
| if (isPlayedWindup(windup)) { | ||
| var _played = windup[0]; | ||
| var _last = _played[_played.length - 1]; | ||
| return _last; | ||
| } | ||
| var played = windup[0], | ||
| remaining = windup[1]; | ||
| var playedFromRemaining = remaining.reduce(function (playedEl, member) { | ||
@@ -107,3 +183,3 @@ if (memberIsWindup(member)) { | ||
| if (memberIsWindup(lastPlayed)) { | ||
| if (playedMemberIsWindup(lastPlayed)) { | ||
| return lastPlayedElement(lastPlayed); | ||
@@ -113,25 +189,28 @@ } | ||
| return lastPlayed; | ||
| } | ||
| function playedElements(_ref3) { | ||
| var played = _ref3[0], | ||
| remaining = _ref3[1]; | ||
| var playedTransformed = played.map(function (member) { | ||
| if (memberIsWindup(member)) { | ||
| var metadata = member[2]; | ||
| return [playedElements(member), metadata]; | ||
| } | ||
| } // Return the played elements of a windup | ||
| // INCLUDING any played elements from nested windups in the remaining part of the windup | ||
| return member; | ||
| }); | ||
| var firstRemaning = remaining[0]; | ||
| function playedElements(windup) { | ||
| if (isPlayedWindup(windup)) { | ||
| var _played2 = windup[0]; | ||
| return _played2; | ||
| } | ||
| if (memberIsWindup(firstRemaning) && !isUnplayed(firstRemaning)) { | ||
| var metadata = firstRemaning[2]; | ||
| return [].concat(playedTransformed, [[playedElements(firstRemaning), metadata]]); | ||
| var played = windup[0], | ||
| remaining = windup[1]; | ||
| var firstRemaining = remaining[0]; | ||
| if (memberIsWindup(firstRemaining) && !isUnplayed(firstRemaining)) { | ||
| var firstRemainingMetadata = firstRemaining[2]; | ||
| return [].concat(played, [[playedElements(firstRemaining), firstRemainingMetadata]]); | ||
| } | ||
| return playedTransformed; | ||
| return played; | ||
| } | ||
| function nextElement(_ref4) { | ||
| var remaining = _ref4[1]; | ||
| function nextElement(windup) { | ||
| if (isPlayedWindup(windup)) { | ||
| return undefined; | ||
| } | ||
| var remaining = windup[1]; | ||
| var nextVal = remaining[0]; | ||
@@ -154,3 +233,3 @@ | ||
| // [["h", "i"] ["n", "o"]], []] | ||
| if (isFinished(windup)) { | ||
| if (isPlayedWindup(windup)) { | ||
| return windup; | ||
@@ -165,6 +244,14 @@ } | ||
| if (!firstRemaining) { | ||
| return [played, metadata]; | ||
| } | ||
| if (memberIsWindup(firstRemaining)) { | ||
| var nextFirstRemaining = next(firstRemaining); | ||
| if (isFinished(nextFirstRemaining)) { | ||
| if (isPlayedWindup(nextFirstRemaining)) { | ||
| if (restRemaining.length === 0) { | ||
| return [[].concat(played, [nextFirstRemaining]), metadata]; | ||
| } | ||
| return [[].concat(played, [nextFirstRemaining]), restRemaining, metadata]; | ||
@@ -176,2 +263,6 @@ } | ||
| if (restRemaining.length === 0) { | ||
| return [[].concat(played, [firstRemaining]), metadata]; | ||
| } | ||
| return [[].concat(played, [firstRemaining]), restRemaining, metadata]; | ||
@@ -213,2 +304,759 @@ } | ||
| function isSuffixedWindup(windup) { | ||
| // If it's not an array it can't be a windup | ||
| if (!Array.isArray(windup)) { | ||
| return false; | ||
| } // If it has less or more than three members it's not a windup | ||
| if (windup.length !== 4) { | ||
| return false; | ||
| } // If its first or second members are not arrays it's not a windup | ||
| if (!Array.isArray(windup[0]) || !Array.isArray(windup[1])) { | ||
| return false; | ||
| } // Past here we just have to hope ElementType isn't a windup. | ||
| return true; | ||
| } | ||
| function isPlayedSuffixedWindup(windup) { | ||
| // If it's not an array it can't be a windup | ||
| if (!Array.isArray(windup)) { | ||
| return false; | ||
| } // If it has less or more than three members it's not a windup | ||
| if (windup.length !== 3) { | ||
| return false; | ||
| } // If its first or second members are not arrays it's not a windup | ||
| if (!Array.isArray(windup[0]) || !Array.isArray(windup[1])) { | ||
| return false; | ||
| } // Past here we just have to hope ElementType isn't a windup. | ||
| return true; | ||
| } | ||
| function isUnplayed$1(windup) { | ||
| var played = windup[0], | ||
| remaining = windup[1]; | ||
| if (isPlayedSuffixedWindup(windup)) { | ||
| return false; | ||
| } | ||
| if (played.length > 0) { | ||
| return false; | ||
| } | ||
| return remaining.reduce(function (unplayed, member) { | ||
| if (isSuffixedWindup(member)) if (isSuffixedWindup(windup) && unplayed) { | ||
| return isUnplayed$1(member); | ||
| } | ||
| return unplayed; | ||
| }, true); | ||
| } | ||
| function playedElements$1(suffixedWindup) { | ||
| if (isPlayedSuffixedWindup(suffixedWindup)) { | ||
| return suffixedWindup[0]; | ||
| } | ||
| var suffixedPlayed = suffixedWindup[0], | ||
| remaining = suffixedWindup[1]; | ||
| var remainingMembers = remaining.reduce(function (acc, member) { | ||
| if (isPlayedSuffixedWindup(member)) { | ||
| return [].concat(acc, playedElementsWithSuffix(member)); | ||
| } | ||
| if (isSuffixedWindup(member)) { | ||
| var metadata = member[3]; | ||
| var els = playedElementsWithSuffix(member); | ||
| if (els.length === 0) { | ||
| return acc; | ||
| } | ||
| return [].concat(acc, [[playedElementsWithSuffix(member), [], metadata]]); | ||
| } | ||
| return acc; | ||
| }, []); | ||
| return [].concat(suffixedPlayed, remainingMembers); | ||
| } | ||
| function playedElementsWithSuffix(windup) { | ||
| if (isPlayedSuffixedWindup(windup)) { | ||
| var _played = windup[0], | ||
| _suffix = windup[1]; | ||
| return [].concat(_played, _suffix.map(function (member) { | ||
| if (playedMemberIsWindup(member)) { | ||
| return playedWindupToSuffixed(member); | ||
| } | ||
| return member; | ||
| })); | ||
| } | ||
| var played = playedElements$1(windup); | ||
| var suffix = windup[2]; | ||
| var suffixAsSuffixPlayedMembers = suffix.map(function (member) { | ||
| if (playedMemberIsWindup(member)) { | ||
| return playedWindupToSuffixed(member); | ||
| } | ||
| return member; | ||
| }); | ||
| return [].concat(played, suffixAsSuffixPlayedMembers); | ||
| } | ||
| function prev(suffixedWindup) { | ||
| if (isPlayedSuffixedWindup(suffixedWindup)) { | ||
| var _played2 = suffixedWindup[0], | ||
| _suffix2 = suffixedWindup[1], | ||
| _metadata = suffixedWindup[2]; | ||
| var _restPlayed = _played2.slice(0, -1); | ||
| var _lastPlayed = _played2[_played2.length - 1]; | ||
| if (!_lastPlayed) { | ||
| return [_played2, [], _suffix2, _metadata]; | ||
| } | ||
| if (isPlayedSuffixedWindup(_lastPlayed)) { | ||
| return [_restPlayed, [prev(_lastPlayed)], _suffix2, _metadata]; | ||
| } | ||
| return [_restPlayed, [_lastPlayed], _suffix2, _metadata]; | ||
| } | ||
| var played = suffixedWindup[0], | ||
| remaining = suffixedWindup[1], | ||
| suffix = suffixedWindup[2], | ||
| metadata = suffixedWindup[3]; | ||
| var firstRemaining = remaining[0], | ||
| restRemaining = remaining.slice(1); | ||
| if (!firstRemaining) { | ||
| var _restPlayed2 = played.slice(0, -1); | ||
| var _lastPlayed2 = played[played.length - 1]; | ||
| if (!_lastPlayed2) { | ||
| return [played, [], suffix, metadata]; | ||
| } | ||
| if (isPlayedSuffixedWindup(_lastPlayed2)) { | ||
| return [_restPlayed2, [prev(_lastPlayed2)], suffix, metadata]; | ||
| } | ||
| return [_restPlayed2, [_lastPlayed2], suffix, metadata]; | ||
| } // check if first remaining is an inprogress windup | ||
| if (isSuffixedWindup(firstRemaining) && !isUnplayed$1(firstRemaining)) { | ||
| return [played, [prev(firstRemaining)].concat(restRemaining), suffix, metadata]; | ||
| } // if it's not (element or unplayed) | ||
| // take the last element of the played value | ||
| var restPlayed = played.slice(0, -1); | ||
| var lastPlayed = played[played.length - 1]; | ||
| if (isPlayedSuffixedWindup(lastPlayed)) { | ||
| return [restPlayed, [prev(lastPlayed)].concat(remaining), suffix, metadata]; | ||
| } // if it's an element, just take it | ||
| return [restPlayed, [lastPlayed].concat(remaining), suffix, metadata]; | ||
| } | ||
| function next$1(suffixedWindup) { | ||
| if (isPlayedSuffixedWindup(suffixedWindup)) { | ||
| return suffixedWindup; | ||
| } | ||
| var played = suffixedWindup[0], | ||
| remaining = suffixedWindup[1], | ||
| suffix = suffixedWindup[2], | ||
| metadata = suffixedWindup[3]; | ||
| var firstRemaining = remaining[0], | ||
| restRemaining = remaining.slice(1); | ||
| if (!firstRemaining) { | ||
| return [played, suffix, metadata]; | ||
| } | ||
| if (isSuffixedWindup(firstRemaining)) { | ||
| var nextFirstRemaining = next$1(firstRemaining); | ||
| if (isPlayedSuffixedWindup(nextFirstRemaining)) { | ||
| if (restRemaining.length === 0) { | ||
| return [[].concat(played, [nextFirstRemaining]), suffix, metadata]; | ||
| } | ||
| return [[].concat(played, [nextFirstRemaining]), restRemaining, suffix, metadata]; | ||
| } | ||
| return [played, [nextFirstRemaining].concat(restRemaining), suffix, metadata]; | ||
| } | ||
| if (restRemaining.length === 0) { | ||
| return [[].concat(played, [firstRemaining]), suffix, metadata]; | ||
| } | ||
| return [[].concat(played, [firstRemaining]), restRemaining, suffix, metadata]; | ||
| } | ||
| function fastForward$1(windup) { | ||
| var forwardedWindup = next$1(windup); | ||
| if (isPlayedSuffixedWindup(forwardedWindup)) { | ||
| return forwardedWindup; | ||
| } | ||
| return fastForward$1(forwardedWindup); | ||
| } | ||
| function windupToSuffixed(windup) { | ||
| var played = windup[0], | ||
| remainder = windup[1], | ||
| metadata = windup[2]; | ||
| return [played.map(function (member) { | ||
| if (!playedMemberIsWindup(member)) { | ||
| return member; | ||
| } | ||
| return playedWindupToSuffixed(member); | ||
| }), remainder.map(function (member) { | ||
| if (!memberIsWindup(member)) { | ||
| return member; | ||
| } | ||
| return windupToSuffixed(member); | ||
| }), [], metadata]; | ||
| } | ||
| function playedWindupToSuffixed(windup) { | ||
| var played = windup[0], | ||
| metadata = windup[1]; | ||
| return [played.map(function (member) { | ||
| if (!playedMemberIsWindup(member)) { | ||
| return member; | ||
| } | ||
| return playedWindupToSuffixed(member); | ||
| }), [], metadata]; | ||
| } | ||
| var MemberKind; | ||
| (function (MemberKind) { | ||
| MemberKind[MemberKind["Played"] = 0] = "Played"; | ||
| MemberKind[MemberKind["InProgress"] = 1] = "InProgress"; | ||
| })(MemberKind || (MemberKind = {})); | ||
| function allMembers(windup) { | ||
| var played = isPlayedWindup(windup) ? windup[0] : windup[0]; | ||
| var remainder = !isPlayedWindup(windup) ? windup[1] : []; | ||
| return [].concat(played.map(function (member) { | ||
| return playedMemberIsWindup(member) ? { | ||
| member: member, | ||
| kind: MemberKind.Played, | ||
| isWindup: true | ||
| } : { | ||
| member: member, | ||
| kind: MemberKind.Played, | ||
| isWindup: false | ||
| }; | ||
| }), remainder.map(function (member) { | ||
| return memberIsWindup(member) ? { | ||
| member: member, | ||
| kind: MemberKind.InProgress, | ||
| isWindup: true | ||
| } : { | ||
| member: member, | ||
| kind: MemberKind.InProgress, | ||
| isWindup: false | ||
| }; | ||
| })); | ||
| } // Check if members are equivalent | ||
| function isMemberEquivalent(memberA, memberB) { | ||
| if (!memberA.isWindup && memberB.isWindup || memberA.isWindup && !memberB.isWindup) { | ||
| return false; | ||
| } | ||
| if (memberA.isWindup && memberB.isWindup) { | ||
| // TODO: look at metadata here | ||
| var aMetadata = getMetadata(memberA.member); | ||
| var bMetadata = getMetadata(memberB.member); | ||
| if (!isEqual(aMetadata, bMetadata)) { | ||
| return false; | ||
| } | ||
| var aMembers = allMembers(memberA.member); | ||
| var bMembers = allMembers(memberB.member); | ||
| if (aMembers.length !== bMembers.length) { | ||
| return false; | ||
| } | ||
| var zipped = zipMembersFromLeft(aMembers, bMembers); | ||
| return zipped.every(function (_ref) { | ||
| var a = _ref[0], | ||
| b = _ref[1]; | ||
| return b ? isMemberEquivalent(a, b) : false; | ||
| }); | ||
| } | ||
| return isEqual(memberA.member, memberB.member); | ||
| } | ||
| function matchesFromLeft(zipped) { | ||
| return zipped.reduce(function (matches, _ref2) { | ||
| var aMember = _ref2[0], | ||
| bMember = _ref2[1]; | ||
| if (bMember && isMemberEquivalent(aMember, bMember) && matches.unmatched.length === 0) { | ||
| return _extends({}, matches, { | ||
| matched: [].concat(matches.matched, [aMember]) | ||
| }); | ||
| } | ||
| return _extends({}, matches, { | ||
| unmatched: [].concat(matches.unmatched, [[aMember, bMember]]) | ||
| }); | ||
| }, { | ||
| matched: [], | ||
| unmatched: [] | ||
| }); | ||
| } | ||
| function matchesFromRight(zipped) { | ||
| return zipped.reduce(function (matches, _ref3) { | ||
| var aMember = _ref3[0], | ||
| bMember = _ref3[1]; | ||
| if (bMember && isMemberEquivalent(aMember, bMember) && matches.unmatched.length === 0) { | ||
| return _extends({}, matches, { | ||
| matched: [aMember].concat(matches.matched) | ||
| }); | ||
| } | ||
| return _extends({}, matches, { | ||
| unmatched: [[aMember, bMember]].concat(matches.unmatched) | ||
| }); | ||
| }, { | ||
| matched: [], | ||
| unmatched: [] | ||
| }); | ||
| } | ||
| function zipMembersFromLeft(baseMembers, againstMembers) { | ||
| return baseMembers.map(function (member, i) { | ||
| return [member, againstMembers[i]]; | ||
| }); | ||
| } | ||
| function zipMembersFromRight(baseMembers, againstMembers) { | ||
| var zippedFromEnd = []; | ||
| for (var i = 0; i <= baseMembers.length - 1; i++) { | ||
| zippedFromEnd.push([baseMembers[baseMembers.length - 1 - i], againstMembers[againstMembers.length - 1 - i]]); | ||
| } | ||
| return zippedFromEnd; | ||
| } | ||
| function prefixFromPair(pair) { | ||
| var baseMember = pair[0], | ||
| againstMember = pair[1]; | ||
| if (!baseMember.isWindup) { | ||
| return undefined; | ||
| } | ||
| if (!(againstMember != null && againstMember.isWindup)) { | ||
| return undefined; | ||
| } | ||
| var metadata = getMetadata(baseMember.member); | ||
| var baseMembers = allMembers(baseMember.member); | ||
| var againstMembers = allMembers(againstMember.member); | ||
| var zipped = zipMembersFromLeft(baseMembers, againstMembers); | ||
| var _matchesFromLeft = matchesFromLeft(zipped), | ||
| matched = _matchesFromLeft.matched, | ||
| unmatchedFromLeft = _matchesFromLeft.unmatched; | ||
| var played = matched.map(function (member) { | ||
| if (member.kind === MemberKind.InProgress && member.isWindup) { | ||
| return playedWindupToSuffixed(fastForward(member.member)); | ||
| } | ||
| if (member.kind === MemberKind.Played && member.isWindup) { | ||
| return playedWindupToSuffixed(member.member); | ||
| } | ||
| return member.member; | ||
| }); | ||
| var firstUnmatchedFromLeft = unmatchedFromLeft[0]; | ||
| var maybePrefix = prefixFromPair(firstUnmatchedFromLeft); | ||
| var fromLeftBaseMembers = unmatchedFromLeft.map(function (_ref4) { | ||
| var baseAnnotated = _ref4[0]; | ||
| return baseAnnotated; | ||
| }).map(annotatedMemberToRemaining); | ||
| if (maybePrefix) { | ||
| var remaining = fromLeftBaseMembers.slice(1, 0); | ||
| return [played, [maybePrefix].concat(remaining), [], metadata]; | ||
| } | ||
| return [played, fromLeftBaseMembers, [], metadata]; | ||
| } | ||
| function suffixFromPair(pair) { | ||
| var baseMember = pair[0], | ||
| againstMember = pair[1]; | ||
| if (!baseMember.isWindup) { | ||
| return undefined; | ||
| } | ||
| if (!(againstMember != null && againstMember.isWindup)) { | ||
| return undefined; | ||
| } | ||
| var metadata = getMetadata(baseMember.member); | ||
| var baseMembers = allMembers(baseMember.member); | ||
| var againstMembers = allMembers(againstMember.member); | ||
| var zipped = zipMembersFromRight(baseMembers, againstMembers); | ||
| var _matchesFromRight = matchesFromRight(zipped), | ||
| matched = _matchesFromRight.matched, | ||
| unmatchedFromRight = _matchesFromRight.unmatched; | ||
| var lastUnmatchedFromRight = unmatchedFromRight[unmatchedFromRight.length - 1]; | ||
| var maybeSuffix = prefixFromPair(lastUnmatchedFromRight); | ||
| var suffix = matched.map(annotatedMemberToPlayed); | ||
| if (maybeSuffix) { | ||
| var _remaining = baseMembers.slice(0, unmatchedFromRight.length - 1).map(annotatedMemberToRemaining); | ||
| return [[], [].concat(_remaining, [maybeSuffix]), suffix, metadata]; | ||
| } | ||
| var remaining = [].concat(unmatchedFromRight).map(function (_ref5) { | ||
| var baseAnnotated = _ref5[0]; | ||
| return baseAnnotated; | ||
| }).map(annotatedMemberToRemaining); | ||
| return [[], remaining, suffix, metadata]; | ||
| } | ||
| function annotatedMemberToRemaining(annotated) { | ||
| if (annotated.isWindup && annotated.kind === MemberKind.Played) { | ||
| // This shouldn't happen when this is used... | ||
| return prev(playedWindupToSuffixed(annotated.member)); | ||
| } | ||
| if (annotated.isWindup) { | ||
| return windupToSuffixed(annotated.member); | ||
| } | ||
| return annotated.member; | ||
| } | ||
| function annotatedMemberToPlayed(annotated) { | ||
| if (annotated.isWindup && annotated.kind === MemberKind.InProgress) { | ||
| // This shouldn't happen when this is used... | ||
| return fastForward(annotated.member); | ||
| } | ||
| return annotated.member; | ||
| } | ||
| function playedAndRemainingFromUnmatched(fromLeft, fromRight) { | ||
| if (fromLeft.length === 0 || fromRight.length === 0) { | ||
| return { | ||
| played: [], | ||
| remaining: [] | ||
| }; | ||
| } | ||
| var _fromLeft$ = fromLeft[0], | ||
| firstBaseFromLeft = _fromLeft$[0], | ||
| firstAgainstFromLeft = _fromLeft$[1]; | ||
| var _fromRight = fromRight[fromRight.length - 1], | ||
| firstBaseFromRight = _fromRight[0], | ||
| firstAgainstFromRight = _fromRight[1]; | ||
| if (fromLeft.length === 1 && fromRight.length === 1 && firstBaseFromLeft.isWindup && firstAgainstFromLeft != null && firstAgainstFromLeft.isWindup) { | ||
| var merged = mergeWindupsToSuffixedWindup(firstBaseFromLeft.member, firstAgainstFromLeft.member); | ||
| if (isPlayedSuffixedWindup(merged)) { | ||
| return { | ||
| played: [merged], | ||
| remaining: [] | ||
| }; | ||
| } | ||
| return { | ||
| played: [], | ||
| remaining: [merged] | ||
| }; | ||
| } | ||
| var playedEls = fromLeft.filter(function (_ref6) { | ||
| var baseAnnotated = _ref6[0]; | ||
| return baseAnnotated.kind === MemberKind.Played; | ||
| }); | ||
| var played = playedEls.map(function (_ref7) { | ||
| var baseAnnotated = _ref7[0]; | ||
| return baseAnnotated; | ||
| }).map(function (baseAnnotated) { | ||
| if (baseAnnotated.isWindup && baseAnnotated.kind === MemberKind.InProgress) { | ||
| return fastForward$1(windupToSuffixed(baseAnnotated.member)); | ||
| } | ||
| if (baseAnnotated.isWindup) { | ||
| return playedWindupToSuffixed(baseAnnotated.member); | ||
| } | ||
| return baseAnnotated.member; | ||
| }); | ||
| var shiftedLeft = fromLeft.slice(played.length); | ||
| if (shiftedLeft.length === 0 && playedEls.length === 0) { | ||
| return { | ||
| played: played, | ||
| remaining: [] | ||
| }; | ||
| } | ||
| if (shiftedLeft.length === 0) { | ||
| var shiftedFromRight = fromRight.slice(0, playedEls.length); | ||
| var _shiftedFromRight = shiftedFromRight[shiftedFromRight.length - 1], | ||
| baseFromRight = _shiftedFromRight[0], | ||
| againstFromRight = _shiftedFromRight[1]; | ||
| var _maybeWindupSuffix = suffixFromPair([baseFromRight, againstFromRight]); | ||
| if (_maybeWindupSuffix) { | ||
| var playedWithoutSuffix = played.slice(0, -1); | ||
| return { | ||
| played: [].concat(playedWithoutSuffix, [fastForward$1(_maybeWindupSuffix)]), | ||
| remaining: [] | ||
| }; | ||
| } | ||
| return { | ||
| played: played, | ||
| remaining: [] | ||
| }; | ||
| } | ||
| var _shiftedLeft$ = shiftedLeft[0], | ||
| firstBaseFromShiftedLeft = _shiftedLeft$[0], | ||
| firstAgainstFromShiftedLeft = _shiftedLeft$[1]; | ||
| var maybeWindupPrefix = prefixFromPair([firstBaseFromShiftedLeft, firstAgainstFromShiftedLeft]); | ||
| var maybeWindupSuffix = suffixFromPair([firstBaseFromRight, firstAgainstFromRight]); | ||
| var shiftedLeftBaseMembers = shiftedLeft.map(function (_ref8) { | ||
| var baseAnnotated = _ref8[0]; | ||
| return baseAnnotated; | ||
| }).map(annotatedMemberToRemaining); | ||
| if (maybeWindupPrefix && maybeWindupSuffix) { | ||
| var remaining = shiftedLeftBaseMembers.slice(1, -1); | ||
| return { | ||
| played: played, | ||
| remaining: [maybeWindupPrefix].concat(remaining, [maybeWindupSuffix]) | ||
| }; | ||
| } | ||
| if (!maybeWindupPrefix && maybeWindupSuffix) { | ||
| var _remaining2 = shiftedLeftBaseMembers.slice(0, -1); | ||
| return { | ||
| played: played, | ||
| remaining: [].concat(_remaining2, [maybeWindupSuffix]) | ||
| }; | ||
| } | ||
| if (maybeWindupPrefix && !maybeWindupSuffix) { | ||
| var _remaining3 = shiftedLeftBaseMembers.slice(1); | ||
| return { | ||
| played: played, | ||
| remaining: [maybeWindupPrefix].concat(_remaining3) | ||
| }; | ||
| } | ||
| return { | ||
| played: played, | ||
| remaining: shiftedLeftBaseMembers | ||
| }; | ||
| } | ||
| function mergeWindupsToSuffixedWindup(baseWindup, againstWindup) { | ||
| var metadata = getMetadata(baseWindup); // Get all the members and zip them up. | ||
| var baseMembers = allMembers(baseWindup); | ||
| var againstMembers = allMembers(againstWindup); | ||
| var zipped = zipMembersFromLeft(baseMembers, againstMembers); | ||
| var _matchesFromLeft2 = matchesFromLeft(zipped), | ||
| matched = _matchesFromLeft2.matched, | ||
| unmatchedFromLeft = _matchesFromLeft2.unmatched; | ||
| var played = matched.map(function (member) { | ||
| if (member.kind === MemberKind.InProgress && member.isWindup) { | ||
| return playedWindupToSuffixed(fastForward(member.member)); | ||
| } | ||
| if (member.kind === MemberKind.Played && member.isWindup) { | ||
| return playedWindupToSuffixed(member.member); | ||
| } | ||
| return member.member; | ||
| }); | ||
| var lengthToZipRight = baseMembers.length - played.length; | ||
| var zippedRight = zipMembersFromRight(baseMembers, againstMembers).slice(0, lengthToZipRight); | ||
| var _matchesFromRight2 = matchesFromRight(zippedRight), | ||
| matchedFromRight = _matchesFromRight2.matched, | ||
| unmatchedZippedFromRight = _matchesFromRight2.unmatched; | ||
| var unmatchedZippedFromLeft = unmatchedFromLeft.slice(0, unmatchedZippedFromRight.length); | ||
| var _playedAndRemainingFr = playedAndRemainingFromUnmatched(unmatchedZippedFromLeft, unmatchedZippedFromRight), | ||
| playedFromUnmatched = _playedAndRemainingFr.played, | ||
| remaining = _playedAndRemainingFr.remaining; | ||
| var suffix = matchedFromRight.map(function (member) { | ||
| if (member.kind === MemberKind.InProgress && member.isWindup) { | ||
| return fastForward(member.member); | ||
| } | ||
| if (member.kind === MemberKind.Played && member.isWindup) { | ||
| return member.member; | ||
| } | ||
| return member.member; | ||
| }); | ||
| if (remaining.length === 0) { | ||
| return [[].concat(played, playedFromUnmatched), suffix, metadata]; | ||
| } | ||
| return [[].concat(played, playedFromUnmatched), remaining, suffix, metadata]; | ||
| } | ||
| function getMetadata(windup) { | ||
| return isPlayedWindup(windup) ? windup[1] : windup[2]; | ||
| } | ||
| function lastPlayedSuffixedMember(windup) { | ||
| if (isPlayedSuffixedWindup(windup)) { | ||
| var _played3 = windup[0]; | ||
| var _last = _played3[_played3.length - 1]; | ||
| return _last; | ||
| } | ||
| var played = windup[0], | ||
| remaining = windup[1]; | ||
| var playedFromRemaining = remaining.reduce(function (playedEl, member) { | ||
| if (isSuffixedWindup(member)) { | ||
| if (!isUnplayed$1(member)) { | ||
| return lastPlayedSuffixedElement(member); | ||
| } | ||
| } | ||
| return playedEl; | ||
| }, undefined); | ||
| if (playedFromRemaining) { | ||
| return playedFromRemaining; | ||
| } | ||
| var last = played[played.length - 1]; | ||
| return last; | ||
| } | ||
| function lastPlayedSuffixedElement(windup) { | ||
| var lastPlayed = lastPlayedSuffixedMember(windup); | ||
| if (isPlayedSuffixedWindup(lastPlayed)) { | ||
| return lastPlayedSuffixedElement(lastPlayed); | ||
| } | ||
| return lastPlayed; | ||
| } | ||
| function nextSuffixedElement(windup) { | ||
| if (isPlayedSuffixedWindup(windup)) { | ||
| return undefined; | ||
| } | ||
| var remaining = windup[1]; | ||
| var nextVal = remaining[0]; | ||
| if (isSuffixedWindup(nextVal)) { | ||
| return nextSuffixedElement(nextVal); | ||
| } | ||
| return nextVal; | ||
| } | ||
| function unsuffixWindup(suffixed) { | ||
| var played = suffixed[0], | ||
| remaining = suffixed[1], | ||
| suffix = suffixed[2], | ||
| metadata = suffixed[3]; | ||
| var nextPlayed = played.map(function (member) { | ||
| if (isPlayedSuffixedWindup(member)) { | ||
| return unsuffixPlayedWindup(member); | ||
| } | ||
| return member; | ||
| }); | ||
| var nextRemaining = remaining.map(function (member) { | ||
| if (isSuffixedWindup(member)) { | ||
| return unsuffixWindup(member); | ||
| } | ||
| return member; | ||
| }); | ||
| var suffixAsMoreRemaining = suffix.map(function (member) { | ||
| if (playedMemberIsWindup(member)) { | ||
| return rewind(member); | ||
| } | ||
| return member; | ||
| }); | ||
| return [nextPlayed, [].concat(nextRemaining, suffixAsMoreRemaining), metadata]; | ||
| } | ||
| function unsuffixPlayedWindup(suffixed) { | ||
| var played = suffixed[0], | ||
| suffix = suffixed[1], | ||
| metadata = suffixed[2]; | ||
| var nextPlayed = played.map(function (member) { | ||
| if (isPlayedSuffixedWindup(member)) { | ||
| return unsuffixPlayedWindup(member); | ||
| } | ||
| return member; | ||
| }); | ||
| return [[].concat(nextPlayed, suffix), metadata]; | ||
| } | ||
| function commonPrefix(base, against) { | ||
| var baseMembers = allMembers(base); | ||
| var againstMembers = allMembers(against); | ||
| var zipped = zipMembersFromLeft(baseMembers, againstMembers); | ||
| var _matchesFromLeft3 = matchesFromLeft(zipped), | ||
| matched = _matchesFromLeft3.matched; | ||
| return matched.map(function (annotated) { | ||
| if (annotated.isWindup) { | ||
| return isPlayedWindup(annotated.member) ? playedWindupToSuffixed(annotated.member) : playedWindupToSuffixed(fastForward(annotated.member)); | ||
| } | ||
| return annotated.member; | ||
| }); | ||
| } | ||
| function defaultGetPace(lastChar, nextChar) { | ||
@@ -257,4 +1105,61 @@ switch (lastChar) { | ||
| } | ||
| function isReverseMsProp(props) { | ||
| if ("reverseMs" in props) { | ||
| return true; | ||
| } | ||
| return false; | ||
| } | ||
| function isReverseGetPaceProp(props) { | ||
| if ("reverseGetPace" in props) { | ||
| return true; | ||
| } | ||
| return false; | ||
| } | ||
| function paceMetadataFromProps(props) { | ||
| if (isMsProp(props)) { | ||
| var ms = props.ms, | ||
| reverseMs = props.reverseMs; | ||
| return _extends({ | ||
| pace: function pace() { | ||
| return ms; | ||
| } | ||
| }, reverseMs ? { | ||
| reversePace: function reversePace() { | ||
| return reverseMs; | ||
| } | ||
| } : {}); | ||
| } | ||
| if (isReverseMsProp(props)) { | ||
| var _ms = props.ms, | ||
| _reverseMs = props.reverseMs; | ||
| return _extends({ | ||
| reversePace: function reversePace() { | ||
| return _reverseMs; | ||
| } | ||
| }, _ms ? { | ||
| pace: function pace() { | ||
| return _ms; | ||
| } | ||
| } : {}); | ||
| } | ||
| if (isReverseGetPaceProp(props)) { | ||
| return _extends({ | ||
| reversePace: props.getReversePace | ||
| }, props.getPace ? { | ||
| pace: props.getPace | ||
| } : {}); | ||
| } | ||
| return _extends({ | ||
| pace: props.getPace | ||
| }, props.getReversePace ? { | ||
| reversePace: props.getReversePace | ||
| } : {}); | ||
| } | ||
| function paceFromWindup(windup, parentPace) { | ||
| if (isFinished(windup)) { | ||
| if (isPlayedWindup(windup)) { | ||
| return undefined; | ||
@@ -273,3 +1178,19 @@ } | ||
| } | ||
| function paceFromSuffixedWindup(windup, rewinding, parentPace) { | ||
| if (isPlayedSuffixedWindup(windup)) { | ||
| return undefined; | ||
| } | ||
| var remaining = windup[1], | ||
| metadata = windup[3]; | ||
| var firstRemaining = remaining[0]; | ||
| var paceToUse = rewinding ? metadata.reversePace : metadata.pace; | ||
| if (firstRemaining && isSuffixedWindup(firstRemaining)) { | ||
| return paceFromSuffixedWindup(firstRemaining, rewinding, paceToUse || parentPace); | ||
| } | ||
| return paceToUse || parentPace; | ||
| } | ||
| var OnChar = function OnChar(_ref) { | ||
@@ -287,2 +1208,6 @@ var children = _ref.children; | ||
| function onCharsFromWindup(windup) { | ||
| if (isPlayedWindup(windup)) { | ||
| return []; | ||
| } | ||
| var remaining = windup[1], | ||
@@ -294,3 +1219,3 @@ metadata = windup[2]; | ||
| if (lastPlayed && memberIsWindup(lastPlayed)) { | ||
| if (lastPlayed && playedMemberIsWindup(lastPlayed)) { | ||
| onChars.push.apply(onChars, onCharsFromWindup(lastPlayed)); | ||
@@ -309,3 +1234,28 @@ } | ||
| } | ||
| function onCharsFromSuffixedWindup(windup) { | ||
| if (isPlayedSuffixedWindup(windup)) { | ||
| return []; | ||
| } | ||
| var remaining = windup[1], | ||
| metadata = windup[3]; | ||
| var lastPlayed = lastPlayedSuffixedMember(windup); | ||
| var firstRemaining = remaining[0]; | ||
| var onChars = []; | ||
| if (lastPlayed && isPlayedSuffixedWindup(lastPlayed)) { | ||
| onChars.push.apply(onChars, onCharsFromSuffixedWindup(lastPlayed)); | ||
| } | ||
| if (firstRemaining && isSuffixedWindup(firstRemaining) && !isUnplayed$1(firstRemaining)) { | ||
| onChars.push.apply(onChars, onCharsFromSuffixedWindup(firstRemaining)); | ||
| } | ||
| if (metadata.onChar) { | ||
| onChars.push(metadata.onChar); | ||
| } | ||
| return onChars; | ||
| } | ||
| function initWindupState(windup) { | ||
@@ -324,2 +1274,6 @@ return { | ||
| case "next": | ||
| if (isPlayedWindup(state.windup)) { | ||
| return state; | ||
| } | ||
| return _extends({}, state, { | ||
@@ -336,2 +1290,6 @@ windup: next(state.windup) | ||
| case "fast-forward": | ||
| if (isPlayedWindup(state.windup)) { | ||
| return state; | ||
| } | ||
| return _extends({}, state, { | ||
@@ -413,3 +1371,3 @@ windup: fastForward(state.windup) | ||
| onChars.forEach(function (onChar) { | ||
| onChar(lastEl); | ||
| onChar(lastEl, false); | ||
| }); | ||
@@ -463,3 +1421,3 @@ } | ||
| function renderStringWindup(windup) { | ||
| var played = isPlayedWindup(windup) ? windup[0] : playedElements(windup); | ||
| var played = playedElements(windup); | ||
| var inner = played.reduce(function (acc, playedEl) { | ||
@@ -477,3 +1435,3 @@ if (typeof playedEl === "string") { | ||
| var metadata = isPlayedWindup(windup) ? windup[1] : windup[2]; | ||
| var played = isPlayedWindup(windup) ? windup[0] : playedElements(windup); | ||
| var played = playedElements(windup); | ||
| var Outer = metadata.element || Fragment; | ||
@@ -568,3 +1526,2 @@ | ||
| } | ||
| function reduceWindupArgs(prevArgs, children) { | ||
@@ -587,11 +1544,3 @@ if (typeof children === "string") { | ||
| var paceMetaData = isPaceElement(children) ? { | ||
| pace: function pace(_char) { | ||
| if (isMsProp(children.props)) { | ||
| return children.props.ms; | ||
| } | ||
| return children.props.getPace(_char); | ||
| } | ||
| } : {}; | ||
| var paceMetaData = isPaceElement(children) ? paceMetadataFromProps(children.props) : {}; | ||
| var onCharMetaData = isOnCharElement(children) ? { | ||
@@ -895,3 +1844,332 @@ onChar: children.props.fn | ||
| export { CharWrapper, Effect, Linebreaker, OnChar, Pace, Pause, StyledText, WindupChildren, defaultGetPace, textFromChildren, useIsFinished, useRewind, useSkip, useWindupString }; | ||
| function renderSuffixedStringWindup(windup) { | ||
| var played = playedElementsWithSuffix(windup); | ||
| var inner = played.reduce(function (acc, playedEl) { | ||
| if (typeof playedEl === "string") { | ||
| return acc + playedEl; | ||
| } | ||
| return acc + renderSuffixedStringWindup(playedEl); | ||
| }, ""); | ||
| var suffix = isPlayedSuffixedWindup(windup) ? [] : windup[2]; | ||
| var innerSuffixed = suffix.reduce(function (acc, suffixEl) { | ||
| if (typeof suffixEl === "string") { | ||
| return acc + suffixEl; | ||
| } | ||
| return acc + renderStringWindup(suffixEl); | ||
| }, ""); | ||
| return inner + innerSuffixed; | ||
| } | ||
| function renderSuffixedChildrenWindup(windup) { | ||
| var metadata = isPlayedSuffixedWindup(windup) ? windup[2] : windup[3]; | ||
| var played = playedElementsWithSuffix(windup); | ||
| var Outer = metadata.element || Fragment; | ||
| if (metadata.props && Object.keys(metadata.props).includes("children")) { | ||
| return createElement(Outer, Object.assign({ | ||
| key: metadata.key | ||
| }, metadata.props)); | ||
| } | ||
| var inner = played.reduce(function (acc, playedEl) { | ||
| if (typeof playedEl === "string") { | ||
| return [].concat(acc, [playedEl]); | ||
| } | ||
| return [].concat(acc, [renderSuffixedChildrenWindup(playedEl)]); | ||
| }, []); | ||
| if (typeof metadata.element === "string" && VOID_TAGS.includes(metadata.element)) { | ||
| return createElement(Outer, Object.assign({ | ||
| key: metadata.key | ||
| }, metadata.props)); | ||
| } | ||
| return createElement(Outer, Object.assign({ | ||
| key: metadata.key | ||
| }, metadata.props), inner); | ||
| } | ||
| function usePrevious(value) { | ||
| var ref = useRef(); | ||
| useEffect(function () { | ||
| ref.current = value; | ||
| }, [value]); | ||
| return ref.current; | ||
| } | ||
| function isRewindupState(state) { | ||
| if ("rewindUntil" in state) { | ||
| return true; | ||
| } | ||
| return false; | ||
| } | ||
| function isRewinding(state) { | ||
| return isRewindupState(state) ? !isEqual$1(state.rewindUntil, playedElements$1(state.toRewind)) : false; | ||
| } | ||
| function getActiveWindup(state) { | ||
| return isRewindupState(state) ? isRewinding(state) ? state.toRewind : state.toResume : state.toPlay; | ||
| } | ||
| function getNextBaseWindup(state) { | ||
| if (!isRewindupState(state)) { | ||
| return isPlayedSuffixedWindup(state.toPlay) ? unsuffixPlayedWindup(state.toPlay) : unsuffixWindup(state.toPlay); | ||
| } | ||
| if (isRewinding(state)) { | ||
| return isPlayedSuffixedWindup(state.toRewind) ? unsuffixPlayedWindup(state.toRewind) : unsuffixWindup(state.toRewind); | ||
| } | ||
| return isPlayedSuffixedWindup(state.toResume) ? unsuffixPlayedWindup(state.toResume) : unsuffixWindup(state.toResume); | ||
| } | ||
| function rewindupReducer(state, action) { | ||
| switch (action.type) { | ||
| case "start-rewindup": | ||
| { | ||
| var toRewind = mergeWindupsToSuffixedWindup(action.baseWindup, action.againstWindup); | ||
| var toResume = mergeWindupsToSuffixedWindup(action.againstWindup, action.baseWindup); | ||
| var rewindUntil = commonPrefix(action.baseWindup, action.againstWindup); | ||
| return { | ||
| toRewind: toRewind, | ||
| rewindUntil: rewindUntil, | ||
| toResume: toResume | ||
| }; | ||
| } | ||
| case "proceed": | ||
| { | ||
| if (!isRewindupState(state)) { | ||
| if (isPlayedSuffixedWindup(state.toPlay)) { | ||
| return state; | ||
| } | ||
| return { | ||
| toPlay: next$1(state.toPlay) | ||
| }; | ||
| } | ||
| if (isEqual$1(state.rewindUntil, playedElements$1(state.toRewind))) { | ||
| var nextToResume = next$1(state.toResume); | ||
| return _extends({}, state, { | ||
| toResume: nextToResume | ||
| }); | ||
| } | ||
| var nextToRewind = prev(state.toRewind); | ||
| return _extends({}, state, { | ||
| toRewind: nextToRewind | ||
| }); | ||
| } | ||
| case "fast-forward": | ||
| { | ||
| return { | ||
| toPlay: fastForward$1(getActiveWindup(state)) | ||
| }; | ||
| } | ||
| default: | ||
| return state; | ||
| } | ||
| } | ||
| function useRewindup(windupInit, options) { | ||
| var _React$useReducer = useReducer(rewindupReducer, { | ||
| toPlay: isPlayedWindup(windupInit) ? playedWindupToSuffixed(windupInit) : windupToSuffixed(windupInit) | ||
| }), | ||
| state = _React$useReducer[0], | ||
| dispatch = _React$useReducer[1]; // When the windup changes, onChar should fire | ||
| useEffect(function () { | ||
| if (!state) { | ||
| return; | ||
| } | ||
| var windupToGetOnCharFrom = getActiveWindup(state); | ||
| var onChars = onCharsFromSuffixedWindup(windupToGetOnCharFrom); | ||
| var lastEl = lastPlayedSuffixedElement(windupToGetOnCharFrom); | ||
| if (onChars.length > 0 && lastEl) { | ||
| onChars.forEach(function (onChar) { | ||
| onChar(lastEl, isRewindupState(state)); | ||
| }); | ||
| } | ||
| }, [state]); | ||
| var timeoutRef = useRef(null); // Respect skipped | ||
| useEffect(function () { | ||
| if (timeoutRef.current) { | ||
| clearTimeout(timeoutRef.current); | ||
| } | ||
| if (options.skipped) { | ||
| dispatch({ | ||
| type: "fast-forward" | ||
| }); | ||
| } | ||
| if (options.skipped === false) { | ||
| dispatch({ | ||
| type: "start-rewindup", | ||
| baseWindup: getNextBaseWindup(state), | ||
| againstWindup: windupInit | ||
| }); | ||
| } | ||
| }, [options.skipped]); // If windup finishes, the onFinished should fire | ||
| var windupIsFinished = isPlayedSuffixedWindup(getActiveWindup(state)); | ||
| var prevWindupIsFinished = usePrevious(windupIsFinished); | ||
| useEffect(function () { | ||
| // Put this in a new context so that the windup finishes visually before firing this | ||
| if (prevWindupIsFinished === false && windupIsFinished) { | ||
| var timeout = setTimeout(function () { | ||
| if (options.onFinished) { | ||
| options.onFinished(); | ||
| } | ||
| }, 0); | ||
| return function () { | ||
| clearTimeout(timeout); | ||
| }; | ||
| } | ||
| }, [prevWindupIsFinished, windupIsFinished, options.onFinished]); // Proceed the windup | ||
| useEffect(function () { | ||
| var isPlayed = isPlayedSuffixedWindup(isRewindupState(state) ? state.toResume : state.toPlay); | ||
| var isRewindDone = isRewindupState(state) ? isEqual$1(playedElements$1(state.toRewind), state.rewindUntil) : true; | ||
| if (!state || isPlayed && isRewindDone) { | ||
| return; | ||
| } | ||
| var windupToGetPaceFrom = getActiveWindup(state); | ||
| var getPace = paceFromSuffixedWindup(windupToGetPaceFrom, isRewindupState(state)) || defaultGetPace; | ||
| var lastEl = lastPlayedSuffixedElement(windupToGetPaceFrom); | ||
| var nextEl = nextSuffixedElement(windupToGetPaceFrom); | ||
| var timeout = lastEl ? getPace(lastEl, nextEl) : 0; | ||
| timeoutRef.current = setTimeout(function () { | ||
| dispatch({ | ||
| type: "proceed" | ||
| }); | ||
| }, timeout); | ||
| return function () { | ||
| if (timeoutRef.current) { | ||
| clearTimeout(timeoutRef.current); | ||
| } | ||
| }; | ||
| }, [state]); | ||
| var prevWindupInit = usePrevious(windupInit); | ||
| useEffect(function () { | ||
| if (prevWindupInit === undefined) { | ||
| return; | ||
| } | ||
| if (prevWindupInit === windupInit) { | ||
| return; | ||
| } | ||
| if (options.onRewindStart) { | ||
| options.onRewindStart(); | ||
| } | ||
| dispatch({ | ||
| type: "start-rewindup", | ||
| baseWindup: getNextBaseWindup(state), | ||
| againstWindup: windupInit | ||
| }); | ||
| }, [windupInit, prevWindupInit]); | ||
| var skip = useCallback(function () { | ||
| dispatch({ | ||
| type: "fast-forward" | ||
| }); | ||
| }, []); | ||
| var rewind = useCallback(function () { | ||
| dispatch({ | ||
| type: "start-rewindup", | ||
| baseWindup: newWindup([], {}), | ||
| againstWindup: windupInit | ||
| }); | ||
| }, []); | ||
| return { | ||
| windup: getActiveWindup(state), | ||
| skip: skip, | ||
| rewind: rewind, | ||
| isFinished: windupIsFinished | ||
| }; | ||
| } | ||
| function useRewindupString(text, options) { | ||
| if (options === void 0) { | ||
| options = {}; | ||
| } | ||
| var windupInit = useMemo(function () { | ||
| return windupFromString(text, options); // We can omit options as this is used as an initialisation value and options will not change it | ||
| // eslint-disable-next-line react-hooks/exhaustive-deps | ||
| }, [text]); | ||
| var _useRewindup = useRewindup(windupInit, options), | ||
| windup = _useRewindup.windup, | ||
| skip = _useRewindup.skip, | ||
| rewind = _useRewindup.rewind, | ||
| isFinished = _useRewindup.isFinished; | ||
| var rendered = renderSuffixedStringWindup(windup); | ||
| useDebugValue(rendered); | ||
| return [rendered, { | ||
| skip: skip, | ||
| rewind: rewind, | ||
| isFinished: isFinished | ||
| }]; | ||
| } | ||
| function RewindupChildren(_ref) { | ||
| var children = _ref.children, | ||
| onFinished = _ref.onFinished, | ||
| onRewindStart = _ref.onRewindStart, | ||
| skipped = _ref.skipped; | ||
| var windupInit = useChildrenMemo(function () { | ||
| if (children === undefined) { | ||
| return newWindup([], { | ||
| element: undefined | ||
| }); | ||
| } | ||
| return newWindup(Children.toArray(children).reduce(reduceWindupArgs, []), { | ||
| element: undefined | ||
| }); | ||
| }, children); | ||
| var maybeSkippedWindupInit = useMemo(function () { | ||
| if (skipped) { | ||
| return fastForward(windupInit); | ||
| } | ||
| return windupInit; | ||
| }, [windupInit, skipped]); | ||
| var _useRewindup = useRewindup(maybeSkippedWindupInit, { | ||
| onFinished: onFinished, | ||
| onRewindStart: onRewindStart, | ||
| skipped: skipped | ||
| }), | ||
| windup = _useRewindup.windup, | ||
| skip = _useRewindup.skip, | ||
| rewind = _useRewindup.rewind, | ||
| isFinished = _useRewindup.isFinished; | ||
| return createElement(WindupContext.Provider, { | ||
| value: { | ||
| skip: skip, | ||
| rewind: rewind, | ||
| isFinished: isFinished | ||
| } | ||
| }, renderSuffixedChildrenWindup(windup)); | ||
| } | ||
| export { CharWrapper, Effect, Linebreaker, OnChar, Pace, Pause, RewindupChildren, StyledText, WindupChildren, defaultGetPace, textFromChildren, useIsFinished, useRewind, useRewindupString, useSkip, useWindupString }; | ||
| //# sourceMappingURL=windups.esm.js.map |
| { | ||
| "name": "windups", | ||
| "version": "1.1.9", | ||
| "version": "1.2.0-alpha.0", | ||
| "description": "A unique typewriter effect library for React.", | ||
@@ -37,3 +37,4 @@ "author": "Sam Gwilym <gwilym@me.com>", | ||
| "dependencies": { | ||
| "break-styled-lines": "^1.2.2" | ||
| "break-styled-lines": "^1.2.2", | ||
| "fast-deep-equal": "^3.1.3" | ||
| }, | ||
@@ -52,3 +53,2 @@ "devDependencies": { | ||
| "husky": "^4.3.7", | ||
| "jest": "^24.9.0", | ||
| "react": "17.0.1", | ||
@@ -79,7 +79,2 @@ "react-dom": "17.0.1", | ||
| }, | ||
| "husky": { | ||
| "hooks": { | ||
| "pre-commit": "tsdx lint" | ||
| } | ||
| }, | ||
| "keywords": [ | ||
@@ -86,0 +81,0 @@ "windup", |
@@ -6,3 +6,3 @@ export { default as useWindupString } from "./react/useWindupString"; | ||
| useRewind, | ||
| useSkip | ||
| useSkip, | ||
| } from "./react/WindupChildren"; | ||
@@ -16,1 +16,4 @@ export { default as OnChar } from "./react/OnChar"; | ||
| export { default as textFromChildren } from "./react/textFromChildren"; | ||
| export { default as useRewindupString } from "./react/useRewindupString"; | ||
| export { default as RewindupChildren } from './react/RewindupChildren' |
@@ -14,1 +14,4 @@ export { default as useWindupString } from "./useWindupString"; | ||
| export { default as Effect } from "./Effect"; | ||
| export { default as useRewindupString } from "./useRewindupString"; | ||
| export { default as RewindupChildren } from './RewindupChildren' |
@@ -10,15 +10,17 @@ import * as React from "react"; | ||
| Windup, | ||
| nextElement | ||
| nextElement, | ||
| PlayedWindup, | ||
| isPlayedWindup | ||
| } from "../Windup"; | ||
| import { onCharsFromWindup } from "./OnChar"; | ||
| type WindupReducerState<M> = { | ||
| windup: Windup<string, M>; | ||
| type WindupReducerState<MetadataType> = { | ||
| windup: Windup<string, MetadataType> | PlayedWindup<string, MetadataType>; | ||
| didFinishOnce: boolean; | ||
| }; | ||
| type WindupReducerAction<M> = | ||
| type WindupReducerAction<MetadataType> = | ||
| | { | ||
| type: "replace"; | ||
| windup: Windup<string, M>; | ||
| windup: Windup<string, MetadataType>; | ||
| } | ||
@@ -55,2 +57,6 @@ | { | ||
| case "next": | ||
| if (isPlayedWindup(state.windup)) { | ||
| return state; | ||
| } | ||
| return { ...state, windup: next(state.windup) }; | ||
@@ -60,2 +66,6 @@ case "rewind": | ||
| case "fast-forward": | ||
| if (isPlayedWindup(state.windup)) { | ||
| return state; | ||
| } | ||
| return { ...state, windup: fastForward(state.windup) }; | ||
@@ -70,8 +80,8 @@ case "finish": | ||
| export interface HookMetadata { | ||
| onChar?: (char: string) => void; | ||
| onChar?: (char: string, reversing?: boolean) => void; | ||
| pace?: (char: string, nextChar: string | undefined) => number; | ||
| } | ||
| export default function useWindup<M extends HookMetadata>( | ||
| windupInit: Windup<string, M>, | ||
| export default function useWindup<MetadataType extends HookMetadata>( | ||
| windupInit: Windup<string, MetadataType>, | ||
| options: { | ||
@@ -82,3 +92,3 @@ onFinished?: () => void; | ||
| ): { | ||
| windup: Windup<string, M>; | ||
| windup: Windup<string, MetadataType> | PlayedWindup<string, MetadataType>; | ||
| skip: () => void; | ||
@@ -89,4 +99,4 @@ rewind: () => void; | ||
| const [{ windup, didFinishOnce }, dispatch] = React.useReducer< | ||
| ReducerType<M>, | ||
| Windup<string, M> | ||
| ReducerType<MetadataType>, | ||
| Windup<string, MetadataType> | ||
| >(windupReducer, windupInit, initWindupState); | ||
@@ -144,3 +154,3 @@ | ||
| onChars.forEach(onChar => { | ||
| onChar(lastEl); | ||
| onChar(lastEl, false); | ||
| }); | ||
@@ -147,0 +157,0 @@ } |
@@ -7,3 +7,3 @@ import * as React from "react"; | ||
| export type WindupOptions = { | ||
| onChar?: (char: string) => void; | ||
| onChar?: (char: string, reversing?: boolean) => void; | ||
| onFinished?: () => void; | ||
@@ -10,0 +10,0 @@ pace?: (char: string) => number; |
@@ -0,10 +1,25 @@ | ||
| // Possible member of a windup, e.g. a character or another windup. | ||
| export type WindupMember<ElementType, MetadataType> = | ||
| | ElementType | ||
| | Windup<ElementType, MetadataType>; | ||
| // A windup that has not yet been exhausted | ||
| export type Windup<ElementType, MetadataType> = [ | ||
| Array<PlayedWindupMember<ElementType, MetadataType>>, | ||
| Array<WindupMember<ElementType, MetadataType>>, | ||
| Array<WindupMember<ElementType, MetadataType>>, | ||
| MetadataType | ||
| ]; | ||
| // Possible member of a windup, e.g. a character or another windup. | ||
| export type PlayedWindupMember<ElementType, MetadataType> = | ||
| | ElementType | ||
| | PlayedWindup<ElementType, MetadataType>; | ||
| // A windup that has exhausted all elements | ||
| export type PlayedWindup<ElementType, MetadataType> = [ | ||
| Array<PlayedWindupMember<ElementType, MetadataType>>, | ||
| MetadataType | ||
| ]; | ||
| // Is the windup of type PlayedWindup? | ||
| export function isPlayedWindup<ElementType, MetadataType>( | ||
@@ -15,5 +30,21 @@ windup: | ||
| ): windup is PlayedWindup<ElementType, MetadataType> { | ||
| return windup.length === 2; | ||
| // If it's not an array it can't be a windup | ||
| if (!Array.isArray(windup)) { | ||
| return false; | ||
| } | ||
| // If it has less or more than three members it's not a windup | ||
| if (windup.length !== 2) { | ||
| return false; | ||
| } | ||
| // If its first member is not anarrays it's not a windup | ||
| if (!Array.isArray(windup[0])) { | ||
| return false; | ||
| } | ||
| return true; | ||
| } | ||
| // Is the member a windup, or just a member type? | ||
| export function memberIsWindup<ElementType, MetadataType>( | ||
@@ -41,2 +72,27 @@ member: WindupMember<ElementType, MetadataType> | ||
| // Is the member a windup, or just a member type? | ||
| export function playedMemberIsWindup<ElementType, MetadataType>( | ||
| member: PlayedWindupMember<ElementType, MetadataType> | ||
| ): member is PlayedWindup<ElementType, MetadataType> { | ||
| // If it's not an array it can't be a windup | ||
| if (!Array.isArray(member)) { | ||
| return false; | ||
| } | ||
| // If it has less or more than three members it's not a windup | ||
| if (member.length !== 2) { | ||
| return false; | ||
| } | ||
| // If its first member is not an array it's not a windup | ||
| if (!Array.isArray(member[0])) { | ||
| return false; | ||
| } | ||
| // Past here we just have to hope ElementType isn't a windup. | ||
| return true; | ||
| } | ||
| // Create a windup from a given string | ||
| // "Hello", metadata -> [[], ["H", "e", "l", "l", "o"], metadata] | ||
| export function windupFromString<MetadataType>( | ||
@@ -56,5 +112,13 @@ str: string, | ||
| // Checks if the windup is unplayed | ||
| // INCLUDING any nested windups in the remaining part of the windup | ||
| export function isUnplayed<ElementType, MetadataType>( | ||
| windup: Windup<ElementType, MetadataType> | ||
| windup: | ||
| | Windup<ElementType, MetadataType> | ||
| | PlayedWindup<ElementType, MetadataType> | ||
| ): boolean { | ||
| if (isPlayedWindup(windup)) { | ||
| return false; | ||
| } | ||
| const [played, remaining] = windup; | ||
@@ -75,14 +139,27 @@ | ||
| export function isFinished<ElementType, MetadataType>([ | ||
| _played, | ||
| remaining | ||
| ]: Windup<ElementType, MetadataType>): boolean { | ||
| // Checks if a windup has any remaining parts | ||
| export function isFinished<ElementType, MetadataType>( | ||
| windup: | ||
| | Windup<ElementType, MetadataType> | ||
| | PlayedWindup<ElementType, MetadataType> | ||
| ): boolean { | ||
| if (isPlayedWindup(windup)) { | ||
| return true; | ||
| } | ||
| const [, remaining] = windup; | ||
| return remaining.length === 0; | ||
| } | ||
| // Turn a Windup into a PlayedWindup | ||
| export function fastForward<ElementType, MetadataType>( | ||
| windup: Windup<ElementType, MetadataType> | ||
| ): Windup<ElementType, MetadataType> { | ||
| windup: Windup<ElementType, MetadataType> | PlayedWindup<ElementType, MetadataType> | ||
| ): PlayedWindup<ElementType, MetadataType> { | ||
| if (isPlayedWindup(windup)) { | ||
| return windup | ||
| } | ||
| const forwardedWindup = next(windup); | ||
| if (isFinished(forwardedWindup)) { | ||
| if (isPlayedWindup(forwardedWindup)) { | ||
| return forwardedWindup; | ||
@@ -93,24 +170,45 @@ } | ||
| // Turn an in-progress Windup or PlayedWindup into an unplayed Windup | ||
| export function rewind<ElementType, MetadataType>( | ||
| windup: Windup<ElementType, MetadataType> | ||
| windup: | ||
| | Windup<ElementType, MetadataType> | ||
| | PlayedWindup<ElementType, MetadataType> | ||
| ): Windup<ElementType, MetadataType> { | ||
| if (isUnplayed(windup)) { | ||
| if (!isPlayedWindup(windup) && isUnplayed(windup)) { | ||
| return windup; | ||
| } | ||
| const [played, remaining, metadata] = windup; | ||
| const played = windup[0]; | ||
| const metadata = isPlayedWindup(windup) ? windup[1] : windup[2]; | ||
| type MemberType = WindupMember<ElementType, MetadataType>; | ||
| const mapRewind = (member: MemberType): MemberType => { | ||
| const mapRewind = ( | ||
| member: WindupMember<ElementType, MetadataType> | ||
| ): WindupMember<ElementType, MetadataType> => { | ||
| if (memberIsWindup(member)) { | ||
| return rewind(member); | ||
| } | ||
| return member; | ||
| }; | ||
| const playedMapRewind = ( | ||
| member: PlayedWindupMember<ElementType, MetadataType> | ||
| ) => { | ||
| if (playedMemberIsWindup(member)) { | ||
| return rewind(member); | ||
| } | ||
| return member; | ||
| }; | ||
| if (isPlayedWindup(windup)) { | ||
| return [[], played.map(playedMapRewind), metadata]; | ||
| } | ||
| const remaining = windup[1]; | ||
| return [ | ||
| [], | ||
| [...played.map(mapRewind), ...remaining.map(mapRewind)], | ||
| metadata | ||
| [...played.map(playedMapRewind), ...remaining.map(mapRewind)], | ||
| metadata, | ||
| ]; | ||
@@ -120,5 +218,6 @@ } | ||
| export function windupAsString<MetadataType>( | ||
| windup: Windup<string, MetadataType> | ||
| windup: Windup<string, MetadataType> | PlayedWindup<string, MetadataType> | ||
| ): string { | ||
| const [played, remaining] = windup; | ||
| const played = windup[0]; | ||
| const remaining = isPlayedWindup(windup) ? [] : windup[1]; | ||
@@ -132,16 +231,31 @@ type MemberType = WindupMember<string, MetadataType>; | ||
| }; | ||
| type PlayedMemberType = PlayedWindupMember<string, MetadataType>; | ||
| const stringifyPlayed = (member: PlayedMemberType): PlayedMemberType => { | ||
| if (playedMemberIsWindup(member)) { | ||
| return windupAsString(member); | ||
| } | ||
| return member; | ||
| }; | ||
| return [ | ||
| played.map(stringify).join(""), | ||
| remaining.map(stringify).join("") | ||
| played.map(stringifyPlayed).join(""), | ||
| remaining.map(stringify).join(""), | ||
| ].join(""); | ||
| } | ||
| export function lastPlayedMember<ElementType, MetadataType>([ | ||
| played, | ||
| remaining | ||
| ]: Windup<ElementType, MetadataType>): | ||
| | WindupMember<ElementType, MetadataType> | ||
| | undefined { | ||
| export function lastPlayedMember<ElementType, MetadataType>( | ||
| windup: | ||
| | Windup<ElementType, MetadataType> | ||
| | PlayedWindup<ElementType, MetadataType> | ||
| ): PlayedWindupMember<ElementType, MetadataType> | undefined { | ||
| if (isPlayedWindup(windup)) { | ||
| const [played] = windup; | ||
| const last = played[played.length - 1]; | ||
| return last; | ||
| } | ||
| const [played, remaining] = windup; | ||
| const playedFromRemaining = remaining.reduce( | ||
| (playedEl: WindupMember<ElementType, MetadataType> | undefined, member) => { | ||
| (playedEl: ElementType | undefined, member) => { | ||
| if (memberIsWindup(member)) { | ||
@@ -166,7 +280,9 @@ if (!isUnplayed(member)) { | ||
| export function lastPlayedElement<ElementType, MetadataType>( | ||
| windup: Windup<ElementType, MetadataType> | ||
| windup: | ||
| | Windup<ElementType, MetadataType> | ||
| | PlayedWindup<ElementType, MetadataType> | ||
| ): ElementType | undefined { | ||
| const lastPlayed = lastPlayedMember(windup); | ||
| if (memberIsWindup(lastPlayed)) { | ||
| if (playedMemberIsWindup(lastPlayed)) { | ||
| return lastPlayedElement(lastPlayed); | ||
@@ -178,44 +294,42 @@ } | ||
| export type PlayedWindup<ElementType, MetadataType> = [ | ||
| Array<ElementType>, | ||
| MetadataType | ||
| ]; | ||
| // Return the played elements of a windup | ||
| // INCLUDING any played elements from nested windups in the remaining part of the windup | ||
| export function playedElements<ElementType, MetadataType>( | ||
| windup: | ||
| | Windup<ElementType, MetadataType> | ||
| | PlayedWindup<ElementType, MetadataType> | ||
| ): Array<PlayedWindupMember<ElementType, MetadataType>> { | ||
| if (isPlayedWindup(windup)) { | ||
| const [played] = windup; | ||
| export function playedElements<ElementType, MetadataType>([ | ||
| played, | ||
| remaining | ||
| ]: Windup<ElementType, MetadataType>): Array< | ||
| ElementType | PlayedWindup<ElementType, MetadataType> | ||
| > { | ||
| const playedTransformed = played.map(member => { | ||
| if (memberIsWindup(member)) { | ||
| const [, , metadata] = member; | ||
| return [playedElements(member), metadata] as PlayedWindup< | ||
| ElementType, | ||
| MetadataType | ||
| >; | ||
| } | ||
| return member; | ||
| }); | ||
| return played; | ||
| } | ||
| const [firstRemaning] = remaining; | ||
| if (memberIsWindup(firstRemaning) && !isUnplayed(firstRemaning)) { | ||
| const [, , metadata] = firstRemaning; | ||
| const [played, remaining] = windup; | ||
| const [firstRemaining] = remaining; | ||
| if (memberIsWindup(firstRemaining) && !isUnplayed(firstRemaining)) { | ||
| const [, , firstRemainingMetadata] = firstRemaining; | ||
| return [ | ||
| ...playedTransformed, | ||
| [playedElements(firstRemaning), metadata] as PlayedWindup< | ||
| ElementType, | ||
| MetadataType | ||
| > | ||
| ]; | ||
| ...played, | ||
| [playedElements(firstRemaining), firstRemainingMetadata], | ||
| ] as Array<PlayedWindupMember<ElementType, MetadataType>>; | ||
| } | ||
| return playedTransformed; | ||
| return played; | ||
| } | ||
| export function nextElement<ElementType, MetadataType>([ | ||
| _played, | ||
| remaining | ||
| ]: Windup<ElementType, MetadataType>): ElementType | undefined { | ||
| export function nextElement<ElementType, MetadataType>( | ||
| windup: | ||
| | Windup<ElementType, MetadataType> | ||
| | PlayedWindup<ElementType, MetadataType> | ||
| ): ElementType | undefined { | ||
| if (isPlayedWindup(windup)) { | ||
| return undefined; | ||
| } | ||
| const [, remaining] = windup; | ||
| const [nextVal] = remaining; | ||
@@ -230,5 +344,36 @@ | ||
| export function prev<ElementType, MetadataType>( | ||
| windup: | ||
| | Windup<ElementType, MetadataType> | ||
| | PlayedWindup<ElementType, MetadataType> | ||
| ): Windup<ElementType, MetadataType> { | ||
| const [played] = windup; | ||
| const metadata = isPlayedWindup(windup) ? windup[1] : windup[2]; | ||
| const remaining = isPlayedWindup(windup) ? [] : windup[1]; | ||
| if (!isPlayedWindup(windup)) { | ||
| const [firstRemaining, ...restRemaining] = remaining; | ||
| if (memberIsWindup(firstRemaining)) { | ||
| return [played, [prev(firstRemaining), ...restRemaining], metadata]; | ||
| } | ||
| } | ||
| // if it's not (element or unplayed) | ||
| // take the last element of the played value | ||
| const restPlayed = played.slice(0, -2); | ||
| const lastPlayed = played[played.length - 1]; | ||
| if (playedMemberIsWindup(lastPlayed)) { | ||
| return [restPlayed, [prev(lastPlayed), ...remaining], metadata]; | ||
| } | ||
| return [restPlayed, [lastPlayed, ...remaining], metadata]; | ||
| } | ||
| export function next<ElementType, MetadataType>( | ||
| windup: Windup<ElementType, MetadataType> | ||
| ): Windup<ElementType, MetadataType> { | ||
| ): Windup<ElementType, MetadataType> | PlayedWindup<ElementType, MetadataType> { | ||
| // start | ||
@@ -246,3 +391,3 @@ // [[], [[[], ["h", "i"]], [[], ["n", "o"]]]] | ||
| if (isFinished(windup)) { | ||
| if (isPlayedWindup(windup)) { | ||
| return windup; | ||
@@ -253,2 +398,6 @@ } | ||
| const [firstRemaining, ...restRemaining] = remaining; | ||
| if (!firstRemaining) { | ||
| return [played, metadata] | ||
| } | ||
@@ -258,4 +407,15 @@ if (memberIsWindup(firstRemaining)) { | ||
| if (isFinished(nextFirstRemaining)) { | ||
| return [[...played, nextFirstRemaining], restRemaining, metadata]; | ||
| if (isPlayedWindup(nextFirstRemaining)) { | ||
| if (restRemaining.length === 0) { | ||
| return [[...played, nextFirstRemaining], metadata] as PlayedWindup< | ||
| ElementType, | ||
| MetadataType | ||
| >; | ||
| } | ||
| return [ | ||
| [...played, nextFirstRemaining], | ||
| restRemaining, | ||
| metadata, | ||
| ] as Windup<ElementType, MetadataType>; | ||
| } | ||
@@ -266,3 +426,7 @@ | ||
| if (restRemaining.length === 0) { | ||
| return [[...played, firstRemaining], metadata]; | ||
| } | ||
| return [[...played, firstRemaining], restRemaining, metadata]; | ||
| } |
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
New alerts
Major refactor
Supply chain riskPackage has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.
Found 1 instance in 1 package
No v1
QualityPackage is not semver >=1. This means it is not stable and does not support ^ ranges.
Found 1 instance in 1 package
Improved metrics
- Total package byte prevSize
- increased by160.24%
638495
- Dev dependency count
- decreased by-5%
19
- Number of package files
- increased by37.5%
55
- Lines of code
- increased by143.82%
7039
Worsened metrics
- Dependency count
- increased by50%
3
- Number of low quality alerts
- increased by100%
2
- Number of medium supply chain risk alerts
- increased byInfinity%
1
Dependency changes
+ Addedfast-deep-equal@^3.1.3
+ Addedfast-deep-equal@3.1.3(transitive)