cubing 0.24.0-pre2 → 0.24.0

package/dist/types/kpuzzle/KPuzzle.d.ts

@@ -15,11 +15,16 @@ export declare class KPuzzle {
     identityTransformation(): KTransformation;
     moveToTransformation(move: Move | string): KTransformation;
     algToTransformation(alg: Alg | string): KTransformation;
+    /** @deprecated */
     toTransformation(source: KTransformationSource): KTransformation;
     startState(): KState;
     canConvertStateToUniqueTransformation(): boolean;
+    /** @deprecated */
     get state(): never;
+    /** @deprecated */
     reset(): never;
+    /** @deprecated */
     applyMove(_move: Move): never;
+    /** @deprecated */
     applyAlg(_alg: Alg): never;
 }

package/dist/types/kpuzzle/KPuzzleDefinition.d.ts

@@ -10,7 +10,7 @@ export interface KStateOrbitData {
 }
 export interface KOrbitDefinition {
     numPieces: number;
-    orientations: number;
+    numOrientations: number;
 }
 export interface KPuzzleDefinition {
     name: string;

package/dist/types/kpuzzle/KState.d.ts

@@ -8,9 +8,11 @@ export declare class KState {
     readonly stateData: KStateData;
     constructor(kpuzzle: KPuzzle, stateData: KStateData);
     static fromTransformation(transformation: KTransformation): KState;
+    /** @deprecated */
     apply(source: KTransformationSource): KState;
     applyTransformation(transformation: KTransformation): KState;
     applyMove(move: Move | string): KState;
     applyAlg(alg: Alg | string): KState;
+    /** @deprecated */
     experimentalToTransformation(): KTransformation | null;
 }

package/dist/types/kpuzzle/KTransformation.d.ts

@@ -9,7 +9,10 @@ export declare class KTransformation {
     constructor(kpuzzle: KPuzzle, transformationData: KTransformationData);
     invert(): KTransformation;
     isIdentityTransformation(): boolean;
+    /** @deprecated */
+    static experimentalConstructIdentity(kpuzzle: KPuzzle): KTransformation;
     isIdentical(t2: KTransformation): boolean;
+    /** @deprecated */
     apply(source: KTransformationSource): KTransformation;
     applyTransformation(t2: KTransformation): KTransformation;
     applyMove(move: Move | string): KTransformation;

package/dist/types/kpuzzle/calculate.d.ts

@@ -13,4 +13,4 @@ export declare function invertTransformation(kpuzzle: KPuzzle, transformationDat
 export declare function repeatTransformationUncached(kpuzzle: KPuzzle, transformationData: KTransformationData, amount: number): KTransformationData;
 export declare const algToTransformation: (alg: Alg, kpuzzle: KPuzzle) => KTransformation;
 export declare function canConvertStateToUniqueTransformationUncached(definition: KPuzzleDefinition): boolean;
-export declare function transformationRepetitionOrder(def: KPuzzleDefinition, t: KTransformation): number;
+export declare function transformationRepetitionOrder(definition: KPuzzleDefinition, transformation: KTransformation): number;

package/dist/types/kpuzzle/index.d.ts

@@ -1,6 +1,6 @@
 export { KPuzzle } from "./KPuzzle";
-export type { KTransformation } from "./KTransformation";
-export { KPuzzleDefinition, KTransformationData, KStateData, } from "./KPuzzleDefinition";
+export type { KPuzzleDefinition, KStateData, KTransformationData, } from "./KPuzzleDefinition";
 export { KState } from "./KState";
+export { KTransformation } from "./KTransformation";
 import { KPuzzle } from "./KPuzzle";
 export declare const experimental3x3x3KPuzzle: KPuzzle;

package/dist/types/notation/CountMoves.d.ts

@@ -1,2 +1,3 @@
 import { Alg } from "../alg";
 export declare const countMoves: (alg: Alg) => number;
+export declare const countQuantumMoves: (alg: Alg) => number;

package/dist/types/notation/index.d.ts

@@ -1,2 +1,2 @@
-export { countMoves } from "./CountMoves";
-export { countAnimatedLeaves } from "./CountAnimatedLeaves";
+export { countMoves as experimentalCountMoves, countQuantumMoves as experimentalCountQuantumMoves, } from "./CountMoves";
+export { countAnimatedLeaves as experimentalCountAnimatedLeaves } from "./CountAnimatedLeaves";

package/dist/types/puzzles/PuzzleLoader.d.ts

@@ -7,6 +7,7 @@ export interface PuzzleLoader {
     fullName: string;
     inventedBy?: string[];
     inventionYear?: number;
+    /** @deprecated */
     def?: never;
     kpuzzle: () => Promise<KPuzzle>;
     svg: () => Promise<string>;

package/dist/types/puzzles/async/async-pg3d.d.ts

@@ -1,14 +1,31 @@
 import { KPuzzle } from "../../kpuzzle";
 import type { PuzzleGeometry } from "../../puzzle-geometry";
+import type { ExperimentalStickering } from "../../twisty";
 import type { PuzzleLoader } from "../PuzzleLoader";
+import type { PuzzleAppearance } from "../stickerings/appearance";
+import { cubeStickerings } from "../stickerings/cube-stickerings";
 export declare function asyncGetPuzzleGeometry(puzzleName: string): Promise<PuzzleGeometry>;
-export declare function asyncGetKPuzzle(puzzleName: string): Promise<KPuzzle>;
-export declare function asyncLazyKPuzzleGetter(puzzleName: string): () => Promise<KPuzzle>;
-export declare function genericPGPuzzleLoader(id: string, fullName: string, info?: {
+export declare function asyncGetKPuzzle(pgPromise: Promise<PuzzleGeometry>, puzzleName: string): Promise<KPuzzle>;
+export declare function asyncLazyKPuzzleGetter(pgPromise: Promise<PuzzleGeometry>, puzzleName: string): () => Promise<KPuzzle>;
+declare type PuzzleLoaderConstructorArgs = {
+    id: string;
+    fullName: string;
     inventedBy?: string[];
     inventionYear?: number;
-}): PuzzleLoader;
-export declare function cubePGPuzzleLoader(id: string, fullName: string, info?: {
+};
+export declare class PGPuzzleLoader implements PuzzleLoader {
+    #private;
+    id: string;
+    fullName: string;
     inventedBy?: string[];
     inventionYear?: number;
-}): PuzzleLoader;
+    constructor(info: PuzzleLoaderConstructorArgs);
+    pg(): Promise<PuzzleGeometry>;
+    kpuzzle(): Promise<KPuzzle>;
+    svg(): Promise<string>;
+}
+export declare class CubePGPuzzleLoader extends PGPuzzleLoader {
+    appearance(stickering: ExperimentalStickering): Promise<PuzzleAppearance>;
+    stickerings: typeof cubeStickerings;
+}
+export {};

package/dist/types/puzzles/async/lazy-cached.d.ts

@@ -0,0 +1 @@
+export declare function getCached<T>(getValue: () => Promise<T>): () => Promise<T>;

package/dist/types/puzzles/implementations/fto/index.d.ts

@@ -1,2 +1,11 @@
-import type { PuzzleLoader } from "../..";
-export declare const fto: PuzzleLoader;
+import type { ExperimentalStickering } from "../../../twisty";
+import { PGPuzzleLoader } from "../../async/async-pg3d";
+import type { PuzzleAppearance } from "../../stickerings/appearance";
+import { ftoStickerings } from "../../stickerings/fto-stickerings";
+declare class FTOPuzzleLoader extends PGPuzzleLoader {
+    constructor();
+    appearance(stickering: ExperimentalStickering): Promise<PuzzleAppearance>;
+    stickerings: typeof ftoStickerings;
+}
+export declare const fto: FTOPuzzleLoader;
+export {};

package/dist/types/puzzles/implementations/megaminx/index.d.ts

@@ -1,2 +1,11 @@
-declare const megaminx: import("../..").PuzzleLoader;
-export { megaminx };
+import type { ExperimentalStickering } from "../../../twisty";
+import { PGPuzzleLoader } from "../../async/async-pg3d";
+import type { PuzzleAppearance } from "../../stickerings/appearance";
+import { megaminxStickerings } from "../../stickerings/megaminx-stickerings";
+declare class MegaminxPuzzleLoader extends PGPuzzleLoader {
+    constructor();
+    appearance(stickering: ExperimentalStickering): Promise<PuzzleAppearance>;
+    stickerings: typeof megaminxStickerings;
+}
+export declare const megaminx: MegaminxPuzzleLoader;
+export {};

package/dist/types/puzzles/implementations/pyraminx/index.d.ts

@@ -1,2 +1,7 @@
-import type { PuzzleLoader } from "../../PuzzleLoader";
-export declare const pyraminx: PuzzleLoader;
+import { PGPuzzleLoader } from "../../async/async-pg3d";
+declare class PyraminxPuzzleLoader extends PGPuzzleLoader {
+    constructor();
+    svg: () => Promise<string>;
+}
+export declare const pyraminx: PyraminxPuzzleLoader;
+export {};