@equinor/videx-3d 5.1.0-beta

package/dist/types/components/Wellbores/WellboreRibbon/WellboreRibbonContext.d.ts

@@ -0,0 +1,16 @@
+import { InstancedBufferGeometry } from 'three';
+import { Trajectory, Vec3 } from '../../../sdk';
+/**
+ * WellboreRibbonContext props
+ * @expand
+ */
+export type WellboreRibbonContextProps = {
+    trajectory: Trajectory;
+    geometry: InstancedBufferGeometry;
+    direction: Vec3;
+};
+/**
+ * WellboreRibbon context
+ * @group Contexts
+ */
+export declare const WellboreRibbonContext: import('react').Context<WellboreRibbonContextProps | null>;

package/dist/types/components/Wellbores/WellboreRibbon/index.d.ts

@@ -0,0 +1,4 @@
+export * from './WellboreRibbon';
+export * from './WellboreRibbonContext';
+export * from './stripes/FormationsStripe';
+export * from './stripes/MeasuredDepthStripe';

package/dist/types/components/Wellbores/WellboreRibbon/stripes/FormationsStripe.d.ts

@@ -0,0 +1,30 @@
+import { Formation } from '../../../../sdk';
+/**
+ * FormationsStripe props
+ * @expand
+ */
+export type FormationsStripeProps = {
+    width: number;
+    offset: number;
+    formationData: Formation[] | null;
+    level?: number;
+};
+/**
+ * This is a stripe component used with the WellboreRibbon component for visualizing
+ * formations along a wellbore trajectory.
+ *
+ * @example
+ * <WellboreRibbon>
+ *  <FormationsStripe ... />
+ * </WellboreRibbon>
+ *
+ * @remarks
+ * This is an experimental component and may be changed/removed
+ *
+ * @see [Storybook](/videx-3d/?path=/docs/components-wellbores-wellboreformationcolumn--docs)
+ * @see {@link WellboreRibbon}
+ * @see {@link WellboreRibbonContext}
+ *
+ * @group Components
+ */
+export declare const FormationsStripe: ({ width, offset, formationData, level, }: FormationsStripeProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/Wellbores/WellboreRibbon/stripes/MeasuredDepthStripe.d.ts

@@ -0,0 +1,28 @@
+/**
+ * MeasuredDepthStripe props
+ * @expand
+ */
+export type MeasuredDepthStripeProps = {
+    width: number;
+    offset: number;
+    stepSize?: number;
+};
+/**
+ * This is a stripe component used with the WellboreRibbon component for adding a measured
+ * depth scale along a wellbore trajectory.
+ *
+ * @example
+ * <WellboreRibbon>
+ *  <MeasuredDepthStripe ... />
+ * </WellboreRibbon>
+ *
+ * @remarks
+ * This is an experimental component and may be changed/removed
+ *
+ * @see [Storybook](/videx-3d/?path=/docs/components-wellbores-wellboreformationcolumn--docs)
+ * @see {@link WellboreRibbon}
+ * @see {@link WellboreRibbonContext}
+ *
+ * @group Components
+ */
+export declare const MeasuredDepthStripe: ({ width, offset, stepSize, }: MeasuredDepthStripeProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/Wellbores/WellboreSeismicSection/WellboreSeismicSection.d.ts

@@ -0,0 +1,34 @@
+import { CommonComponentProps, PointerEvents } from '../../../main';
+/**
+ * WellboreSeismicSection props
+ * @expand
+ */
+export type WellboreSeismicSectionProps = CommonComponentProps & PointerEvents & {
+    id: string;
+    opacity?: number;
+    stepSize?: number;
+    minSize?: number;
+    extension?: number;
+    rangeOffset?: number;
+    colorRampIndex?: number;
+    defaultExtensionAngle?: number;
+    priority?: number;
+};
+/**
+ * Renders a seismic fence along the trajectory of a wellbore.
+ *
+ * @example
+ * <WellboreSeismicSection
+ *   id={wellbore.id}
+ *   stepSize={3}
+ *   extension={1000}
+ *   minSize={1000}
+ *   opacity={0.9}
+ * />
+ *
+ * @see [Storybook](/videx-3d/?path=/docs/components-wellbores-seismicsection--docs)
+ * @see {@link Wellbore}
+ *
+ * @group Components
+ */
+export declare const WellboreSeismicSection: ({ id, opacity, stepSize, extension, minSize, rangeOffset, colorRampIndex, defaultExtensionAngle, priority, name, userData, receiveShadow, castShadow, layers, position, renderOrder, visible, onPointerClick, onPointerEnter, onPointerLeave, onPointerMove, }: WellboreSeismicSectionProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Wellbores/WellboreSeismicSection/index.d.ts

@@ -0,0 +1,2 @@
+export * from './wellbore-seismic-section-defs';
+export * from './WellboreSeismicSection';

package/dist/types/components/Wellbores/WellboreSeismicSection/wellbore-seismic-section-defs.d.ts

@@ -0,0 +1,12 @@
+import { PackedBufferGeometry } from '../../../sdk';
+export declare const wellboreSeismicSection = "wellboreSeismicSection";
+export type WellboreSeismicSectionGeneratorResponse = {
+    geometry: PackedBufferGeometry;
+    data: {
+        array: Float32Array;
+        width: number;
+        height: number;
+        min: number;
+        max: number;
+    };
+};

package/dist/types/components/Wellbores/Wells/Wells.d.ts

@@ -0,0 +1,43 @@
+import { ReactNode } from 'react';
+import { WellboreHeader } from '../../../sdk/data/types/WellboreHeader';
+/**
+ * Wells props
+ * @expand
+ */
+export type WellsProps = {
+    wellbores: WellboreHeader[];
+    included?: string[];
+    selected?: string;
+    renderWellbore?: (wellbore: WellboreHeader, startMsl: number, isSelected: boolean, isActiveWell: boolean, sequence: number, index: number) => ReactNode;
+    children?: ReactNode;
+};
+export type WellsRefType = {
+    getHeader: (id: string) => WellboreHeader;
+};
+/**
+ * The `Wells` component is used to group and manage trajectories by the well property. It will
+ * automatically calculate of top depths for each wellbore, depending on order and which wellbores are marked
+ * as being included.
+ *
+ * It simplifies rendering of `Wellbore` components through the `renderWellbore` property, which gives usesful
+ * data that can be passed to the wellbore component.
+ *
+ * @example
+ * <Wells
+ *   wellbores={wellbores}
+ *   included={included}
+ *   selected={selected}
+ *   renderWellbore={(wellbore, fromMsl, isSelected) => {
+ *     return (
+ *       <Wellbore id={wellbore.id} fromMsl={fromMsl} color={isSelected ? 'red' : 'white' }>
+ *        {...}
+ *       </Wellbore>
+ *     )
+ *   }}
+ * />
+ *
+ * @see [Storybook](/videx-3d/?path=/docs/components-wellbores-wells--docs)
+ *
+ * @group Components
+ */
+export declare const Wells: import('react').ForwardRefExoticComponent<WellsProps & import('react').RefAttributes<WellsRefType>>;

package/dist/types/components/Wellbores/Wells/index.d.ts

@@ -0,0 +1 @@
+export * from './Wells';

package/dist/types/contexts/DataContext.d.ts

@@ -0,0 +1,15 @@
+import { Store } from '../sdk';
+/**
+ * DataContext props
+ * @expand
+ */
+export type DataContextProps = {
+    isRemote: boolean;
+    connect: () => Store | null;
+    connectByMessagePort: () => Promise<MessagePort>;
+};
+/**
+ * Data context
+ * @group Contexts
+ */
+export declare const DataContext: import('react').Context<DataContextProps | null>;

package/dist/types/contexts/DataContextProvider.d.ts

@@ -0,0 +1,33 @@
+import { Remote } from 'comlink';
+import { ReactNode } from 'react';
+import { Store } from '../sdk/data/Store';
+/**
+ * DataProvider props
+ * @expand
+ */
+export type DataProviderProps = {
+    store: Store | Remote<Store>;
+    children: ReactNode;
+};
+/**
+ * Provides sub components with the `DataContext`, which allow connecting to the
+ * `Store` implementation. You can create your own provider if needed, but it will need to
+ * provide an implementation of the `DataContext`.
+ *
+ * @example
+ * <DataProvider store={store}>
+ *  { ... }
+ * </DataProvider>
+ *
+ * @remarks
+ * Components should use the `useData` hook to access the store. Generator functions
+ * will have the store injected by the `GeneratorsProvider` provider component.
+ *
+ * @see {@link Store}
+ * @see {@link DataContext}
+ * @see {@link useData}
+ * @see [Data](/videx-3d/docs/documents/data.html)
+ *
+ * @group Components
+ */
+export declare const DataProvider: ({ store, children }: DataProviderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/contexts/GeneratorsContext.d.ts

@@ -0,0 +1,13 @@
+export type GeneratorContextProps = {
+    invoke: <T>(key: string, priority: number, args: any[]) => Promise<T>;
+};
+/**
+ * Generators context
+ *
+ * @see {@link sdk.GeneratorRegistry}
+ * @see {@link GeneratorsProvider}
+ * @see [Generators](/videx-3d/docs/documents/generators.html)
+ *
+ * @group Contexts
+ */
+export declare const GeneratorsContext: import('react').Context<GeneratorContextProps | null>;

package/dist/types/contexts/GeneratorsContextProvider.d.ts

@@ -0,0 +1,34 @@
+import { Remote } from 'comlink';
+import { ReactNode } from 'react';
+import { GeneratorRegistry } from '../sdk/data/GeneratorRegistry';
+/**
+ * GeneratorsProvider props
+ * @expand
+ */
+export type GeneratorsProviderProps = {
+    registry: GeneratorRegistry | Remote<GeneratorRegistry>;
+    concurrency?: number;
+    signal?: AbortSignal;
+    children: ReactNode;
+};
+/**
+ * Provides sub components with the `GeneratorRegistry`, which allow access to the
+ * registered _generator_ functions. You can create your own provider if needed, but it will need to
+ * provide an implementation of the `GeneratorsContext`.
+ *
+ * @example
+ * <GeneratorsProvider registry={registry}>
+ *  { ... }
+ * </GeneratorsProvider>
+ *
+ * @remarks
+ * Components should use the `useGenerator` hook to access generator functions.
+ *
+ * @see {@link GeneratorRegistry}
+ * @see {@link GeneratorsContext}
+ * @see {@link useGenerator}
+ * @see [Generators](/videx-3d/docs/documents/generators.html)
+ *
+ * @group Components
+ */
+export declare const GeneratorsProvider: ({ registry, concurrency, signal, children, }: GeneratorsProviderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/contexts/GlyphsContext.d.ts

@@ -0,0 +1,19 @@
+import { Texture, UniformsGroup } from 'three';
+import { EncodedTextSegment, EncodedTextTexture } from '../sdk/utils/glyphs';
+/**
+ * GlyphsContext props
+ * @expand
+ */
+export type GlyphsContextProps = {
+    glyphAtlas: Texture;
+    glyphsCount: number;
+    glyphData: UniformsGroup;
+    encodeText: (text: string) => EncodedTextSegment;
+    encodeTextTexture: (textSegments: string[] | string) => EncodedTextTexture;
+    dispose: () => void;
+};
+/**
+ * Glyphs context
+ * @group Contexts
+ */
+export declare const GlyphsContext: import('react').Context<GlyphsContextProps | null>;

package/dist/types/contexts/GlyphsContextProvider.d.ts

@@ -0,0 +1,29 @@
+import { PropsWithChildren } from 'react';
+/**
+ * GlyphsProvider props
+ * @expand
+ */
+export type GlyphsProviderProps = {
+    fontAtlasUrl: string;
+    fontConfigUrl: string;
+};
+/**
+ * Provides sub components with a GlyphsContext, which contains data and utilities needed to
+ * add text support to fragment shaders. This includes a reference to a glyph atlas texture
+ * and a supporting uniforms group, which will contain glyph config and metrics.
+ *
+ * It currently relies on a pre-generated font atlas and json config file using [msdf-bmfont-xml](https://github.com/soimy/msdf-bmfont-xml)
+ *
+ * @example
+ * <GlyphsProvider fontAtlasUrl="OpenSans-Regular.png" fontConfigUrl="OpenSans-Regular.json">
+ *  { ... }
+ * </GlyphsProvider>
+ *
+ * @remarks
+ * This component should be considered experimental.
+ *
+ * @see {@link GlyphsContext}
+ *
+ * @group Components
+ */
+export declare const GlyphsProvider: ({ fontAtlasUrl, fontConfigUrl, children, }: PropsWithChildren<GlyphsProviderProps>) => import("react/jsx-runtime").JSX.Element;

package/dist/types/events/camera-events.d.ts

@@ -0,0 +1,34 @@
+import { Vec3 } from '../sdk';
+/**
+ * CameraSetPositionEvent name
+ */
+export declare const cameraSetPositionEventType: "camera-set-position";
+/**
+ * CameraFocusAtPointEvent name
+ */
+export declare const cameraFocusAtPointEventType: "camera-focus-point";
+export interface CameraFocusAtPointEventDetails {
+    point: Vec3;
+    distance?: number;
+    callback?: () => void;
+}
+/**
+ * Set the camera at the specified position
+ * @event
+ */
+export declare class CameraSetPositionEvent extends CustomEvent<Vec3> {
+    constructor(detail: Vec3);
+}
+/**
+ * Focus the camera at the specified point
+ * @event
+ */
+export declare class CameraFocusAtPointEvent extends CustomEvent<CameraFocusAtPointEventDetails> {
+    constructor(detail: CameraFocusAtPointEventDetails);
+}
+declare global {
+    interface WindowEventMap {
+        [cameraSetPositionEventType]: CameraSetPositionEvent;
+        [cameraFocusAtPointEventType]: CameraFocusAtPointEvent;
+    }
+}

package/dist/types/events/depth-events.d.ts

@@ -0,0 +1,22 @@
+import { DepthReferencePoint } from '../sdk';
+/**
+ * DepthChangedEvent name
+ */
+export declare const depthChangedType: "depth-changed";
+export interface DepthChangedEventDetails {
+    depth: number;
+    referencePoint: DepthReferencePoint;
+    source: string;
+}
+/**
+ * Depth changed
+ * @event
+ */
+export declare class DepthChangedEvent extends CustomEvent<DepthChangedEventDetails> {
+    constructor(detail: DepthChangedEventDetails);
+}
+declare global {
+    interface WindowEventMap {
+        [depthChangedType]: DepthChangedEvent;
+    }
+}

package/dist/types/events/interaction-events.d.ts

@@ -0,0 +1,7 @@
+import { EventEmitterCallback } from '../components/EventEmitter/EventEmitterContext';
+export type PointerEvents = {
+    onPointerEnter?: EventEmitterCallback;
+    onPointerLeave?: EventEmitterCallback;
+    onPointerMove?: EventEmitterCallback;
+    onPointerClick?: EventEmitterCallback;
+};

package/dist/types/events/wellbore-events.d.ts

@@ -0,0 +1,46 @@
+import { Object3D } from 'three';
+import { Vec3 } from '../sdk';
+export declare const wellboreSelectedEventType: "wellbore-selected";
+export declare const wellboreAddedEventType: "wellbore-added";
+export declare const wellboreRemovedEventType: "wellbore-removed";
+export interface WellboreAddedEventDetails {
+    id: string;
+    object: Object3D;
+}
+export interface WellboreRemovedEventDetails {
+    id: string;
+}
+export interface WellboreSelectedEventDetails {
+    id: string;
+    position?: Vec3;
+    depth?: number;
+    flyTo?: boolean;
+}
+/**
+ * Wellbore selected event
+ * @event
+ */
+export declare class WellboreSelectedEvent extends CustomEvent<WellboreSelectedEventDetails> {
+    constructor(detail: WellboreSelectedEventDetails);
+}
+/**
+ * Wellbore added event
+ * @event
+ */
+export declare class WellboreAddedEvent extends CustomEvent<WellboreAddedEventDetails> {
+    constructor(detail: WellboreAddedEventDetails);
+}
+/**
+ * Wellbore removed event
+ * @event
+ */
+export declare class WellboreRemovedEvent extends CustomEvent<WellboreRemovedEventDetails> {
+    constructor(detail: WellboreRemovedEventDetails);
+}
+declare global {
+    interface WindowEventMap {
+        [wellboreSelectedEventType]: WellboreSelectedEvent;
+        [wellboreAddedEventType]: WellboreAddedEvent;
+        [wellboreRemovedEventType]: WellboreRemovedEvent;
+    }
+}

package/dist/types/generators/basic-trajectory-generator.d.ts

@@ -0,0 +1,2 @@
+import { ReadonlyStore } from '../sdk';
+export declare function generateBasicTrajectory(this: ReadonlyStore, id: string, segmentsPerMeter: number, simplificationThreshold?: number, fromMsl?: number, includeLengths?: boolean): Promise<import('../sdk').PackedBufferGeometry | null>;

package/dist/types/generators/casing-annotations-generator.d.ts

@@ -0,0 +1,8 @@
+import { ReadonlyStore } from '../sdk';
+export declare function generateCasingAnnotations(this: ReadonlyStore, id: string): Promise<{
+    name: string;
+    data: Record<string, string>;
+    position: import('../sdk').Vec3;
+    direction: import('../sdk').Vec3;
+    priority: number;
+}[] | null>;

package/dist/types/generators/casings-generator.d.ts

@@ -0,0 +1,4 @@
+import { ReadonlyStore } from '../sdk';
+export declare function generateCasings(this: ReadonlyStore, id: string, fromMsl?: number, radialSegments?: number, sizeMultiplier?: number, shoeFactor?: number, segmentsPerMeter?: number, simplificationThreshold?: number): Promise<{
+    geometry: import('../sdk').PackedBufferGeometry;
+} | null>;

package/dist/types/generators/completion-annotations-generator.d.ts

@@ -0,0 +1,7 @@
+import { ReadonlyStore } from '../sdk';
+export declare function generateCompletionToolAnnotations(this: ReadonlyStore, id: string): Promise<{
+    name: any;
+    position: import('../sdk').Vec3;
+    direction: import('../sdk').Vec3;
+    priority: any;
+}[] | null>;

package/dist/types/generators/completion-tools-generator.d.ts

@@ -0,0 +1,2 @@
+import { ReadonlyStore } from '../sdk';
+export declare function generateCompletionTools(this: ReadonlyStore, id: string, fromMsl?: number, radialSegments?: number, sizeMultiplier?: number, segmentsPerMeter?: number, simplificationThreshold?: number): Promise<import('../sdk').PackedBufferGeometry | null>;

package/dist/types/generators/depth-markers-generator.d.ts

@@ -0,0 +1,3 @@
+import { AnnotationProps } from '../components/Annotations';
+import { DepthReferencePoint, ReadonlyStore } from '../sdk';
+export declare function generateDepthMarkers(this: ReadonlyStore, id: string, interval: number, depthReferencePoint?: DepthReferencePoint, fromMsl?: number): Promise<AnnotationProps[] | null>;

package/dist/types/generators/formation-markers-generator.d.ts

@@ -0,0 +1,2 @@
+import { ReadonlyStore, SymbolsType } from '../sdk';
+export declare function generateFormationMarkers(this: ReadonlyStore, wellboreId: string, stratColumnId: string, fromMsl?: number, baseRadius?: number): Promise<SymbolsType | null>;

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

@@ -0,0 +1,20 @@
+/**
+ * @module generators
+ */
+export * from './basic-trajectory-generator';
+export * from './casing-annotations-generator';
+export * from './casings-generator';
+export * from './completion-annotations-generator';
+export * from './completion-tools-generator';
+export * from './depth-markers-generator';
+export * from './formation-markers-generator';
+export * from './perforations-generator';
+export * from './perimieter-generator';
+export * from './position-markers-generator';
+export * from './shoes-generator';
+export * from './surface-generator';
+export * from './tube-trajectory-generator';
+export * from './wellbore-bounds-generator';
+export * from './wellbore-formation-column-generator';
+export * from './wellbore-label-generator';
+export * from './wellbore-seismic-section-generator';

package/dist/types/generators/perforations-generator.d.ts

@@ -0,0 +1,2 @@
+import { ReadonlyStore, SymbolsType } from '../sdk';
+export declare function generatePerforations(this: ReadonlyStore, id: string, fromMsl?: number, sizeMultiplier?: number): Promise<SymbolsType | null>;

package/dist/types/generators/perimieter-generator.d.ts

@@ -0,0 +1,2 @@
+import { ReadonlyStore } from '../sdk';
+export declare function generatePerimeterGeometry(this: ReadonlyStore, id: string, radius: number, segmentsPerMeter?: number, simplificationThreshold?: number): Promise<import('../sdk').PackedBufferGeometry | null>;

package/dist/types/generators/position-markers-generator.d.ts

@@ -0,0 +1,2 @@
+import { ReadonlyStore, SymbolsType } from '../sdk';
+export declare function generatePositionMarkers(this: ReadonlyStore, id: string, radius: number, interval: number, fromMsl?: number): Promise<SymbolsType | null>;

package/dist/types/generators/shoes-generator.d.ts

@@ -0,0 +1,2 @@
+import { ReadonlyStore, SymbolsType } from '../sdk';
+export declare function generateShoes(this: ReadonlyStore, id: string, fromMsl?: number, sizeMultiplier?: number): Promise<SymbolsType | null>;

package/dist/types/generators/surface-generator.d.ts

@@ -0,0 +1,4 @@
+import { SurfaceTexturesResponse } from '../main';
+import { PackedBufferGeometry, ReadonlyStore } from '../sdk';
+export declare function generateSurfaceTexturesData(this: ReadonlyStore, id: string): Promise<SurfaceTexturesResponse | null>;
+export declare function generateSurfaceGeometry(this: ReadonlyStore, id: string, maxError?: number): Promise<PackedBufferGeometry | null>;

package/dist/types/generators/tube-trajectory-generator.d.ts

@@ -0,0 +1,2 @@
+import { ReadonlyStore } from '../sdk';
+export declare function generateTubeTrajectory(this: ReadonlyStore, id: string, segmentsPerMeter: number, simplificationThreshold?: number, fromMsl?: number, radius?: number, radialSegments?: number, includeLengths?: boolean): Promise<import('../sdk').PackedBufferGeometry | null>;

package/dist/types/generators/wellbore-bounds-generator.d.ts

@@ -0,0 +1,2 @@
+import { ReadonlyStore } from '../sdk';
+export declare function calculateWellboreBounds(this: ReadonlyStore, id: string, fromMsl?: number, sampleSize?: number): Promise<Float32Array<ArrayBuffer>>;

package/dist/types/generators/wellbore-formation-column-generator.d.ts

@@ -0,0 +1,2 @@
+import { PackedBufferGeometry, ReadonlyStore } from '../sdk';
+export declare function generateWellboreFormationColumnGeometries(this: ReadonlyStore, wellboreId: string, stratColumnId: string, segmentsPerMeter: number, fromMsl?: number, units?: string[], unitTypes?: string[], startRadius?: number, formationWidth?: number, caps?: boolean, radialSegments?: number, simplificationThreshold?: number): Promise<PackedBufferGeometry | null>;

package/dist/types/generators/wellbore-label-generator.d.ts

@@ -0,0 +1,7 @@
+import { ReadonlyStore } from '../sdk';
+export declare function generateWellboreLabel(this: ReadonlyStore, id: string, position: 'top' | 'center' | 'bottom', fromMsl?: number): Promise<{
+    id: string;
+    name: string;
+    position: import('../sdk').Vec3;
+    direction: import('../sdk').Vec3;
+}[] | null>;

package/dist/types/generators/wellbore-seismic-section-generator.d.ts

@@ -0,0 +1,3 @@
+import { WellboreSeismicSectionGeneratorResponse } from '../components/Wellbores/WellboreSeismicSection/wellbore-seismic-section-defs';
+import { ReadonlyStore } from '../sdk';
+export declare function generateWellboreSeismicSection(this: ReadonlyStore, id: string, stepSize?: number, minSize?: number, extension?: number, defaultExtensionAngle?: number): Promise<WellboreSeismicSectionGeneratorResponse | null>;

package/dist/types/hooks/useData.d.ts

@@ -0,0 +1,25 @@
+import { Store } from '../sdk/data/Store';
+/**
+ * Access the store from the `DataProvider` within a component to retrieve data.
+ *
+ * @example
+ * const store = useData()
+ *
+ * @remarks
+ * Use the store in a `useEffect` hook to retrieve the data you need and save it
+ * to a local state (if required)
+ *
+ * @example
+ * useEffect(() => {
+ *   if (store) {
+ *     store.get<WellboreHeader>('wellbore-headers', id).then(response => {
+ *       ... // do something with the data
+ *     })
+ *   }
+ * }, [store, id])
+ *
+ * @see [Data](/videx-3d/docs/documents/data.html)
+ *
+ * @group Hooks
+ */
+export declare const useData: () => Store | null;

package/dist/types/hooks/useGenerator.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Access a generator function from within a component.
+ *
+ * @example
+ * const generator = useGenerator(generatorKey)
+ *
+ * @remarks
+ * The generator is an async function that process and returns data required
+ * by your components, such as geometry for a mesh.
+ *
+ * @example
+ *
+ * const [geometry, setGeometry] = useState<BufferGeometry | null>(null)
+ *
+ * useEffect(() => {
+ *   if (generator) {
+ *     generator(id).then(response => {
+ *       if (response) {
+ *         const bufferGeometry = unpackBufferGeometry(response)
+ *         setGeometry(prev => {
+ *           if (prev) prev.dispose()
+ *           return bufferGeometry
+ *         })
+ *       } else {
+ *         setGeometry(null)
+ *       }
+ *     })
+ *   }
+ * }, [generator, id])
+ *
+ * if (!geometry) return null
+ *
+ * return (
+ *  <mesh geometry={geometry}>
+ *    <meshBasicMaterial />
+ *  </mesh>
+ * )
+ *
+ * @see [Generators](/videx-3d/docs/documents/generators.html)
+ *
+ * @group Hooks
+ */
+export declare const useGenerator: <T>(generator: string, priority?: number) => ((...args: any[]) => Promise<T>) | (() => Promise<null>);

package/dist/types/hooks/useWellboreContext.d.ts

@@ -0,0 +1,13 @@
+import { WellboreContextProps } from '../components/Wellbores/Wellbore/WellboreContext';
+/**
+ * Get the wellbore context from a parent `Wellbore` component.
+ *
+ *
+ * @example
+ * const { id } = useWellboreContext()
+ *
+ * @see {@link Wellbore}
+ *
+ * @group Hooks
+ */
+export declare const useWellboreContext: () => WellboreContextProps;