shop-components 0.3.0 → 0.3.1

package/dist/dev/libs/gltf-progressive/src/extension.d.ts

@@ -0,0 +1,50 @@
+import { BufferGeometry, Material, Mesh, Texture } from "three";
+import { type GLTF, type GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader.js";
+import { NEEDLE_ext_progressive_mesh, NEEDLE_ext_progressive_texture } from "./extension.model.js";
+export declare const EXTENSION_NAME = "NEEDLE_progressive";
+type ProgressiveMaterialTextureLoadingResult = {
+    material: Material;
+    slot: string;
+    texture: Texture | null;
+    level: number;
+};
+type TextureLODsMinMaxInfo = {
+    min_count: number;
+    max_count: number;
+    lods: Array<{
+        min_height: number;
+        max_height: number;
+    }>;
+};
+export declare class NEEDLE_progressive implements GLTFLoaderPlugin {
+    get name(): string;
+    static getMeshLODExtension(geo: BufferGeometry): NEEDLE_ext_progressive_mesh | null;
+    static getPrimitiveIndex(geo: BufferGeometry): number;
+    static getMaterialMinMaxLODsCount(material: Material | Material[], minmax?: TextureLODsMinMaxInfo): TextureLODsMinMaxInfo;
+    static hasLODLevelAvailable(obj: Mesh | BufferGeometry | Texture | Material | Material[], level?: number): boolean;
+    static assignMeshLOD(mesh: Mesh, level: number): Promise<BufferGeometry | null>;
+    static assignTextureLOD(materialOrTexture: Material, level: number): Promise<Array<ProgressiveMaterialTextureLoadingResult> | null>;
+    static assignTextureLOD(materialOrTexture: Mesh, level: number): Promise<Array<ProgressiveMaterialTextureLoadingResult> | null>;
+    static assignTextureLOD(materialOrTexture: Texture, level: number): Promise<Texture | null>;
+    private static assignTextureLODForSlot;
+    private readonly parser;
+    private readonly url;
+    constructor(parser: GLTFParser);
+    private _isLoadingMesh;
+    loadMesh: (meshIndex: number) => Promise<any> | null;
+    afterRoot(gltf: GLTF): null;
+    static registerTexture: (url: string, tex: Texture, level: number, index: number, ext: NEEDLE_ext_progressive_texture) => void;
+    static registerMesh: (url: string, key: string, mesh: Mesh, level: number, index: number, ext: NEEDLE_ext_progressive_mesh) => void;
+    private static readonly lodInfos;
+    private static readonly previouslyLoaded;
+    private static readonly lowresCache;
+    private static readonly workers;
+    private static _workersIndex;
+    private static getOrLoadLOD;
+    private static maxConcurrent;
+    private static queue;
+    private static assignLODInformation;
+    private static getAssignedLODInformation;
+    private static copySettings;
+}
+export {};

package/dist/dev/libs/gltf-progressive/src/extension.model.d.ts

@@ -0,0 +1,24 @@
+type NEEDLE_progressive_model_LOD = {
+    path: string;
+    hash?: string;
+};
+export type NEEDLE_progressive_ext = {
+    guid: string;
+    lods: Array<NEEDLE_progressive_model_LOD>;
+};
+export type NEEDLE_ext_progressive_texture = NEEDLE_progressive_ext & {
+    lods: Array<NEEDLE_progressive_model_LOD & {
+        width: number;
+        height: number;
+    }>;
+};
+export type NEEDLE_ext_progressive_mesh = NEEDLE_progressive_ext & {
+    lods: Array<NEEDLE_progressive_model_LOD & {
+        indexCount: number;
+        vertexCount: number;
+        densities: number[] | undefined;
+        density: number;
+    }>;
+    density: number;
+};
+export {};

package/dist/dev/libs/gltf-progressive/src/index.d.ts

@@ -0,0 +1,15 @@
+export { version as VERSION } from "./version.js";
+export * from "./extension.js";
+export * from "./plugins/index.js";
+export { LODsManager, type LOD_Results } from "./lods.manager.js";
+export { setDracoDecoderLocation, setKTX2TranscoderLocation, createLoaders, addDracoAndKTX2Loaders, configureLoader } from "./loaders.js";
+export { getRaycastMesh, registerRaycastMesh, useRaycastMeshes } from "./utils.js";
+import { WebGLRenderer } from "three";
+import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
+import { SmartLoadingHints } from "./loaders.js";
+declare type UseNeedleGLTFProgressiveOptions = {
+    enableLODsManager?: boolean;
+    hints?: Omit<SmartLoadingHints, "progressive">;
+};
+export declare function useNeedleProgressive(url: string, renderer: WebGLRenderer, loader: GLTFLoader, opts?: UseNeedleGLTFProgressiveOptions): any;
+export declare function useNeedleProgressive(loader: GLTFLoader, renderer: WebGLRenderer, opts?: UseNeedleGLTFProgressiveOptions): any;

package/dist/dev/libs/gltf-progressive/src/loaders.d.ts

@@ -0,0 +1,28 @@
+import { WebGLRenderer } from 'three';
+import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader.js';
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+export declare const GET_LOADER_LOCATION_CONFIG: () => {
+    dracoDecoderPath: string;
+    ktx2TranscoderPath: string;
+};
+export declare function setDracoDecoderLocation(location: string): void;
+export declare function setKTX2TranscoderLocation(location: string): void;
+export declare function createLoaders(renderer: WebGLRenderer | null): {
+    dracoLoader: DRACOLoader;
+    meshoptDecoder: {
+        supported: boolean;
+        ready: Promise<void>;
+        decodeVertexBuffer: (target: Uint8Array, count: number, size: number, source: Uint8Array, filter?: string | undefined) => void;
+        decodeIndexBuffer: (target: Uint8Array, count: number, size: number, source: Uint8Array) => void;
+        decodeIndexSequence: (target: Uint8Array, count: number, size: number, source: Uint8Array) => void;
+        decodeGltfBuffer: (target: Uint8Array, count: number, size: number, source: Uint8Array, mode: string, filter?: string | undefined) => void;
+        useWorkers: (count: number) => void;
+        decodeGltfBufferAsync: (count: number, size: number, source: Uint8Array, mode: string, filter?: string | undefined) => Promise<Uint8Array>;
+    };
+};
+export declare function addDracoAndKTX2Loaders(loader: GLTFLoader): void;
+export type SmartLoadingHints = {
+    progressive?: boolean;
+    usecase?: "product";
+};
+export declare function configureLoader(loader: GLTFLoader, opts: SmartLoadingHints): void;

package/dist/dev/libs/gltf-progressive/src/lods.debug.d.ts

@@ -0,0 +1,4 @@
+import { Material } from "three";
+export declare const debug: string | boolean;
+export declare let debug_OverrideLodLevel: number;
+export declare function applyDebugSettings(material: Material | Array<Material>): void;

package/dist/dev/libs/gltf-progressive/src/lods.manager.d.ts

@@ -0,0 +1,79 @@
+import { Camera, Material, Object3D, Scene, Texture, Vector3, WebGLRenderer } from "three";
+import { NEEDLE_progressive_plugin } from "./plugins/plugin.js";
+import { PromiseGroupOptions } from "./lods.promise.js";
+export type LODManagerContext = {
+    engine: "three" | "needle-engine" | "model-viewer" | "react-three-fiber" | "unknown";
+};
+export declare type LOD_Results = {
+    mesh_lod: number;
+    texture_lod: number;
+};
+declare type LODChangedEventListener = (args: {
+    type: "mesh" | "texture";
+    level: number;
+    object: Object3D | Material | Texture;
+}) => void;
+export declare class LODsManager {
+    #private;
+    static debugDrawLine?: (a: Vector3, b: Vector3, color: number) => void;
+    static getObjectLODState(object: Object3D): LOD_state | undefined;
+    static addPlugin(plugin: NEEDLE_progressive_plugin): void;
+    static removePlugin(plugin: NEEDLE_progressive_plugin): void;
+    static get(renderer: WebGLRenderer, context?: LODManagerContext): LODsManager;
+    readonly renderer: WebGLRenderer;
+    private readonly context;
+    private readonly projectionScreenMatrix;
+    get plugins(): NEEDLE_progressive_plugin[];
+    overrideLodLevel: undefined | number;
+    targetTriangleDensity: number;
+    skinnedMeshAutoUpdateBoundsInterval: number;
+    updateInterval: "auto" | number;
+    pause: boolean;
+    manual: boolean;
+    private readonly _newPromiseGroups;
+    private _promiseGroupIds;
+    awaitLoading(opts?: PromiseGroupOptions): Promise<{
+        cancelled: boolean;
+        awaited_count: number;
+        resolved_count: number;
+    }>;
+    private _postprocessPromiseGroups;
+    private readonly _lodchangedlisteners;
+    addEventListener(evt: "changed", listener: LODChangedEventListener): void;
+    removeEventListener(evt: "changed", listener: LODChangedEventListener): void;
+    private constructor();
+    private _fpsBuffer;
+    enable(): void;
+    disable(): void;
+    update(scene: Scene, camera: Camera): void;
+    private onAfterRender;
+    private internalUpdate;
+    private updateLODs;
+    private loadProgressiveTextures;
+    private loadProgressiveMeshes;
+    private readonly _sphere;
+    private readonly _tempBox;
+    private readonly _tempBox2;
+    private readonly tempMatrix;
+    private readonly _tempWorldPosition;
+    private readonly _tempBoxSize;
+    private readonly _tempBox2Size;
+    private static corner0;
+    private static corner1;
+    private static corner2;
+    private static corner3;
+    private static readonly _tempPtInside;
+    private static isInside;
+    private static skinnedMeshBoundsFrameOffsetCounter;
+    private static $skinnedMeshBoundsOffset;
+    private calculateLodLevel;
+}
+declare class LOD_state {
+    frames: number;
+    lastLodLevel_Mesh: number;
+    lastLodLevel_Texture: number;
+    lastScreenCoverage: number;
+    readonly lastScreenspaceVolume: Vector3;
+    lastCentrality: number;
+}
+export {};

package/dist/dev/libs/gltf-progressive/src/lods.promise.d.ts

@@ -0,0 +1,36 @@
+type PromiseType = "texture" | "mesh";
+export type PromiseGroupOptions = {
+    name?: string;
+    frames?: number;
+    waitForFirstCapture?: boolean;
+    signal?: AbortSignal;
+    maxPromisesPerObject?: number;
+};
+type PromiseGroupResolveResult = {
+    cancelled: boolean;
+    awaited_count: number;
+    resolved_count: number;
+};
+export declare class PromiseGroup {
+    static readonly addPromise: (type: PromiseType, object: object, promise: Promise<any>, groups: PromiseGroup[]) => void;
+    readonly ready: Promise<PromiseGroupResolveResult>;
+    get awaitedCount(): number;
+    get resolvedCount(): number;
+    get currentlyAwaiting(): number;
+    private _resolve;
+    private readonly _signal?;
+    private _frame_start;
+    private _frames_to_capture;
+    private _resolved;
+    private _addedCount;
+    private _resolvedCount;
+    private readonly _awaiting;
+    private _maxPromisesPerObject;
+    constructor(frame: number, options: PromiseGroupOptions);
+    private _currentFrame;
+    update(frame: number): void;
+    private readonly _seen;
+    private add;
+    private resolveNow;
+}
+export {};

package/dist/dev/libs/gltf-progressive/src/plugins/index.d.ts

@@ -0,0 +1,2 @@
+export { patchModelViewer } from "./modelviewer.js";
+export { type NEEDLE_progressive_plugin } from "./plugin.js";

package/dist/dev/libs/gltf-progressive/src/plugins/modelviewer.d.ts

@@ -0,0 +1 @@
+export declare function patchModelViewer(): void;

package/dist/dev/libs/gltf-progressive/src/plugins/plugin.d.ts

@@ -0,0 +1,12 @@
+import { WebGLRenderer, Scene, Camera, Mesh } from 'three';
+import { NEEDLE_ext_progressive_mesh } from '../extension.model.js';
+export interface NEEDLE_progressive_plugin {
+    onBeforeUpdateLOD?(renderer: WebGLRenderer, scene: Scene, camera: Camera, object: Mesh): void;
+    onAfterUpdatedLOD?(renderer: WebGLRenderer, scene: Scene, camera: Camera, object: Mesh, level: {
+        mesh_lod: number;
+        texture_lod: number;
+    }): void;
+    onRegisteredNewMesh?(mesh: Mesh, ext: NEEDLE_ext_progressive_mesh): void;
+    onBeforeGetLODMesh?(mesh: Mesh, level: number): void;
+}
+export declare const plugins: NEEDLE_progressive_plugin[];

package/dist/dev/libs/gltf-progressive/src/utils.d.ts

@@ -0,0 +1,5 @@
+import { BufferGeometry, Object3D } from "three";
+export declare const isSSR: boolean;
+export declare function getRaycastMesh(obj: Object3D): BufferGeometry<any, any> | null;
+export declare function registerRaycastMesh(obj: Object3D, geom: BufferGeometry): void;
+export declare function useRaycastMeshes(enabled?: boolean): void;

package/dist/dev/libs/gltf-progressive/src/utils.internal.d.ts

@@ -0,0 +1,21 @@
+export declare function isDebugMode(): string | boolean;
+export declare function getParam(name: string): boolean | string;
+export declare function resolveUrl(source: string | undefined, uri: string): string;
+export declare function isMobileDevice(): boolean;
+export declare function isDevelopmentServer(): boolean;
+export type SlotReturnValue<T = any> = {
+    use?: ((promise: Promise<T>) => void);
+};
+export declare class PromiseQueue<T = any> {
+    readonly maxConcurrent: number;
+    private readonly _running;
+    private readonly _queue;
+    debug: boolean;
+    constructor(maxConcurrent?: number, opts?: {
+        debug?: boolean;
+    });
+    private tick;
+    slot(key: string): Promise<SlotReturnValue<T>>;
+    private add;
+    private internalUpdate;
+}

package/dist/dev/libs/gltf-progressive/src/version.d.ts

@@ -0,0 +1 @@
+export declare const version = "";

package/dist/dev/libs/gltf-progressive/src/worker/index.d.ts

@@ -0,0 +1 @@
+export { getWorker as createGLTFLoaderWorker } from './loader.mainthread.js';

package/dist/dev/libs/gltf-progressive/src/worker/loader.mainthread.d.ts

@@ -0,0 +1,44 @@
+import { BufferGeometry, Texture, WebGLRenderer } from "three";
+import type { KTX2LoaderWorkerConfig } from "three/examples/jsm/loaders/KTX2Loader.js";
+type GLTFLoaderWorkerOptions = {
+    debug?: boolean;
+};
+type WorkerLoadResult = {
+    url: string;
+    geometries: Array<{
+        geometry: BufferGeometry;
+        meshIndex: number;
+        primitiveIndex: number;
+        extensions: Record<string, any>;
+    }>;
+    textures: Array<{
+        texture: Texture;
+        textureIndex: number;
+        extensions: Record<string, any>;
+    }>;
+};
+export declare function getWorker(opts?: GLTFLoaderWorkerOptions): Promise<GLTFLoaderWorker>;
+export type { GLTFLoaderWorker, GLTFLoaderWorkerOptions, WorkerLoadResult };
+export type GLTFLoaderWorker_Message = {
+    type: 'init';
+} | {
+    type: 'load';
+    url: string;
+    dracoDecoderPath: string;
+    ktx2TranscoderPath: string;
+    ktx2LoaderConfig: KTX2LoaderWorkerConfig;
+} | {
+    type: "loaded-gltf";
+    result: WorkerLoadResult;
+};
+declare class GLTFLoaderWorker {
+    private readonly worker;
+    static createWorker(opts: GLTFLoaderWorkerOptions): Promise<GLTFLoaderWorker>;
+    private _running;
+    private _webglRenderer;
+    load(url: string | URL, opts?: {
+        renderer?: WebGLRenderer;
+    }): Promise<WorkerLoadResult>;
+    private _debug;
+    private constructor();
+}

package/dist/dev/libs/gltf-progressive/vite.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfig & Promise<import("vite").UserConfig> & import("vite").UserConfigFnObject & import("vite").UserConfigExport;
+export default _default;

package/dist/dev/main.d.ts

@@ -0,0 +1,3 @@
+export * from './src/main';
+export * from './libs/sglb/index';
+export * from './libs/utils/index';

package/dist/{stories/device-viewer → dev/src}/amr.d.ts

@@ -5,10 +5,20 @@ import { ObjectSize } from './utils';
 import { SizeBox } from './dimension/size-box';
 import { AMRAssembly } from './assembly';
 import EventEmitter from 'eventemitter3';
-import type { CropperConfigs } from '../cropper';
 import { GoodsBox } from './goods-box';
 import { Logo } from './logo';
 export declare const textureLoader: TextureLoader;
+export interface CropperConfigs {
+    canvasWidth: number;
+    canvasHeight: number;
+    scaleX: number;
+    scaleY: number;
+    x: number;
+    y: number;
+    ox: number;
+    oy: number;
+    url: string;
+}
 export interface AmrProps {
     url?: string;
     showSizeBox: boolean;
@@ -22,6 +32,12 @@ export declare class Amr extends Object3D {
     private _container;
     lines: Group<import("three").Object3DEventMap>;
     private _app;
+    private _modelRoot;
+    private _mixer;
+    private _clips;
+    private _actionsMap;
+    private _animationClock;
+    private _onTicker;
     sizeBox: SizeBox;
     _goodsSize: ObjectSize;
     _slots: Slot[];
@@ -107,6 +123,10 @@ export declare class Amr extends Object3D {
     generateSlot(m: Object3D, scene: Object3D): Slot | undefined;
     clean(): void;
     destroy(): void;
-    playAction(name: string, reset?: boolean): void;
+    playAction(name: string, reset?: boolean, options?: {
+        timeScale?: number;
+        fadeIn?: number;
+        clampWhenFinished?: boolean;
+    }): Promise<void>;
     pauseAction(name: string): void;
 }

package/dist/{stories/device-viewer → dev/src}/index.stories.d.ts

@@ -1,7 +1,6 @@
-import { DeviceViewer, Props } from './index';
 declare const _default: {
     title: string;
-    render: (args: Props) => DeviceViewer;
+    render: (args: Props) => any;
     argTypes: {
         test: {
             control: string;

package/dist/{stories/device-viewer → dev/src}/scene.d.ts

@@ -11,11 +11,10 @@ import Stats from 'stats-fps.js';
 import { Pane } from 'tweakpane';
 import { Sound } from './sound';
 import { Slot, SLOT_EVENTS } from './slot';
-import { DeviceLines, Line } from './lines';
 import { Amr } from './amr';
 import { Logo } from './logo';
 export declare const font: Font;
-export { Slot, DeviceLines, Line, SLOT_EVENTS, Logo };
+export { Slot, SLOT_EVENTS, Logo };
 export interface LogoProps {
     name: string;
     target: Mesh;
@@ -89,6 +88,7 @@ export declare class Scene3D {
     private _resizeObserver;
     private _container;
     private _fitAnimation;
+    private _focusRestoreView;
     private _raycaster;
     private _selected;
     private _pointerDownTimeout;
@@ -106,9 +106,6 @@ export declare class Scene3D {
     private _ground;
     private light;
     private _amrRender;
-    private _pointCloudMode;
-    get pointCloudMode(): boolean;
-    set pointCloudMode(enabled: boolean);
     get usePathTracing(): boolean;
     private _clearAmrContent;
     private _shadowMode;