@needle-tools/engine 4.16.1 → 4.16.3

package/plugins/vite/buildinfo.js

@@ -6,11 +6,13 @@ import { needleBlue, needleDim, needleLog, needleSupportsColor } from './logging
 
 let level = 0;
 
-/** Create a buildinfo file in the build directory
+/** Create a buildinfo file in the build directory.
+ * @param {"build" | "serve"} command
+ * @param {import('../types/needleConfig').needleMeta | null | undefined} config
  * @param {import('../types').userSettings} userSettings
  * @returns {import('vite').Plugin | null}
  */
-export const needleBuildInfo = (command, config, userSettings) => {
+export function needleBuildInfo(command, config, userSettings) {
 
     if (userSettings?.noBuildInfo) return null;
 

package/plugins/vite/config.d.ts

@@ -0,0 +1,13 @@
+/** Load the codegen meta file.
+ * @param {string | null} path
+ * @returns {Promise<import("../types/needleConfig").needleMeta | null>}
+ */
+export function loadConfig(path?: string | null): Promise<import("../types/needleConfig").needleMeta | null>;
+/** get the needle.config.json
+ * @returns {import("../types/needleConfig").needleConfig | null}
+ */
+export function tryLoadProjectConfig(): import("../types/needleConfig").needleConfig | null;
+/** "assets" -> the directory name inside the output directory to put e.g. glb files into */
+export function builtAssetsDirectory(): string;
+/** @returns the fullpath of the build */
+export function getOutputDirectory(): string;

package/plugins/vite/config.js

@@ -3,7 +3,7 @@ import path from 'path';
 
 let didLogCanNotFindConfig = false;
 
-/**  the codegen meta file
+/** Load the codegen meta file.
  * @param {string | null} path
  * @returns {Promise<import("../types/needleConfig").needleMeta | null>}
  */

package/plugins/vite/copyfiles.d.ts

@@ -0,0 +1,7 @@
+/** Copy files on build from assets to dist.
+ * @param {"build" | "serve"} command
+ * @param {import('../types/needleConfig').needleMeta | null | undefined} config
+ * @param {import('../types').userSettings} userSettings
+ * @returns {import('vite').Plugin | null}
+ */
+export function needleCopyFiles(command: "build" | "serve", config: import("../types/needleConfig").needleMeta | null | undefined, userSettings: import("../types").userSettings): import("vite").Plugin | null;

package/plugins/vite/copyfiles.js

@@ -8,11 +8,13 @@ import { needleBlue, needleDim, needleLog, needleSupportsColor } from './logging
 const pluginName = "needle-copy-files";
 
 
-/** copy files on build from assets to dist 
+/** Copy files on build from assets to dist.
+ * @param {"build" | "serve"} command
+ * @param {import('../types/needleConfig').needleMeta | null | undefined} config
  * @param {import('../types').userSettings} userSettings
  * @returns {import('vite').Plugin | null}
  */
-export const needleCopyFiles = (command, config, userSettings) => {
+export function needleCopyFiles(command, config, userSettings) {
 
     if (config?.noCopy === true || userSettings?.noCopy === true) {
         return null;

package/plugins/vite/custom-element-data.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Ensure the repo workspace or .vscode settings include Needle Engine custom HTML data if they exist.
+ * Copies custom-elements.json to the project and merges with existing user content.
+ * - Copies/merges `custom-elements.json` to project root
+ * - Adds `./custom-elements.json` to `.code-workspace settings.html.customData`
+ * - Adds `./custom-elements.json` to `.vscode/settings.json html.customData`
+ * @param {"build" | "serve"} _command
+ * @param {import('../types').needleMeta | null} _config
+ * @param {import('../types').userSettings} userSettings
+ * @returns {import('vite').Plugin | null}
+ */
+export function needleCustomElementData(_command: "build" | "serve", _config: import("../types").needleMeta | null, userSettings?: import("../types").userSettings): import("vite").Plugin | null;
+export default needleCustomElementData;
+export type CustomElementData = {
+    version?: number;
+    tags?: {
+        name: string;
+        [key: string]: unknown;
+    }[];
+    valueSets?: {
+        name: string;
+        [key: string]: unknown;
+    }[];
+    globalAttributes?: unknown[];
+};

package/plugins/vite/custom-element-data.js

@@ -64,8 +64,9 @@ function mergeCustomElementData(sourceData, targetData) {
  * @param {"build" | "serve"} _command
  * @param {import('../types').needleMeta | null} _config
  * @param {import('../types').userSettings} userSettings
+ * @returns {import('vite').Plugin | null}
  */
-export const needleCustomElementData = (_command, _config, userSettings = {}) => {
+export function needleCustomElementData(_command, _config, userSettings = {}) {
     // Allow disabling the workspace updater
     if (userSettings?.noCustomElementData === true) return null;
 

package/plugins/vite/defines.d.ts

@@ -0,0 +1,10 @@
+/** used to pass config variables into vite.config.define
+ * for example "useRapier"
+ */
+/**
+ * @param {"build" | "serve"} command
+ * @param {import('../types/needleConfig').needleMeta | null | undefined} needleEngineConfig
+ * @param {import('../types').userSettings} userSettings
+ * @returns {import('vite').Plugin}
+ */
+export function needleDefines(command: "build" | "serve", needleEngineConfig: import("../types/needleConfig").needleMeta | null | undefined, userSettings: import("../types").userSettings): import("vite").Plugin;

package/plugins/vite/defines.js

@@ -12,11 +12,12 @@ import { needleLog } from "./logging.js";
 // https://vitejs.dev/config/#using-environment-variables-in-config
 
 /**
- * @param {string} command
- * @param {{ generator?: string, useRapier?: boolean } | null | undefined} needleEngineConfig
+ * @param {"build" | "serve"} command
+ * @param {import('../types/needleConfig').needleMeta | null | undefined} needleEngineConfig
  * @param {import('../types').userSettings} userSettings
+ * @returns {import('vite').Plugin}
  */
-export const needleDefines = (command, needleEngineConfig, userSettings) => {
+export function needleDefines(command, needleEngineConfig, userSettings) {
 
     if (!userSettings) userSettings = {};
 

package/plugins/vite/dependencies.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Returns true when \`@needle-tools/engine\` is installed as a local package
+ * (i.e. it has its own nested `node_modules`). Vite's optimiser must skip such
+ * packages, otherwise it tries to pre-bundle source that was never meant to be
+ * pre-bundled and fails at dev-server start.
+ *
+ * @param {string} [root] – project root; defaults to `process.cwd()`.
+ * @returns {boolean}
+ */
+export function isLocalNeedleEngineInstalled(root?: string): boolean;
+/**
+ * @param {"build" | "serve"} command
+ * @param {import('../types/needleConfig').needleMeta | null | undefined} config
+ * @param {import('../types').userSettings} userSettings
+ * @returns {import('vite').Plugin[]}
+ */
+export function needleDependencies(command: "build" | "serve", config: import("../types/needleConfig").needleMeta | null | undefined, userSettings: import("../types").userSettings): import("vite").Plugin[];
+/**
+ * @type {string[]}
+ */
+export const preloadScriptPaths: string[];

package/plugins/vite/dependencies.js

@@ -24,10 +24,12 @@ export function isLocalNeedleEngineInstalled(root = process.cwd()) {
 }
 
 /**
+ * @param {"build" | "serve"} command
+ * @param {import('../types/needleConfig').needleMeta | null | undefined} config
  * @param {import('../types').userSettings} userSettings
  * @returns {import('vite').Plugin[]}
  */
-export const needleDependencies = (command, config, userSettings) => {
+export function needleDependencies(command, config, userSettings) {
 
     /**
      * @type {import('vite').Plugin}

package/plugins/vite/dependency-watcher.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @param {"build" | "serve"} command
+ * @param {unknown} _config
+ * @param {import('../types').userSettings} userSettings
+ * @returns {import('vite').Plugin | null}
+ */
+export function needleDependencyWatcher(command: "build" | "serve", _config: unknown, userSettings: import("../types").userSettings): import("vite").Plugin | null;
+export type PackageJson = {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+};

package/plugins/vite/dependency-watcher.js

@@ -15,8 +15,9 @@ function log(...msg) {
  * @param {"build" | "serve"} command
  * @param {unknown} _config
  * @param {import('../types').userSettings} userSettings
+ * @returns {import('vite').Plugin | null}
  */
-export const needleDependencyWatcher = (command, _config, userSettings) => {
+export function needleDependencyWatcher(command, _config, userSettings) {
     if (command === "build") return null;
 
     if (userSettings?.noDependencyWatcher === true) return null;

package/plugins/vite/drop-client.d.ts

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

package/plugins/vite/drop.d.ts

@@ -0,0 +1,7 @@
+/** Experimental, allow dropping files from Unity into the running scene.
+ * @param {"build" | "serve"} command
+ * @param {import('../types/needleConfig').needleMeta | null | undefined} config
+ * @param {import('../types/userconfig.js').userSettings} userSettings
+ * @returns {import('vite').Plugin | null | undefined}
+ */
+export function needleDrop(command: "build" | "serve", config: import("../types/needleConfig").needleMeta | null | undefined, userSettings: import("../types/userconfig.js").userSettings): import("vite").Plugin | null | undefined;

package/plugins/vite/drop.js

@@ -6,13 +6,13 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-/** experimental, allow dropping files from Unity into the running scene */
-/**
- * @param {string} command
+/** Experimental, allow dropping files from Unity into the running scene.
+ * @param {"build" | "serve"} command
  * @param {import('../types/needleConfig').needleMeta | null | undefined} config
  * @param {import('../types/userconfig.js').userSettings} userSettings
+ * @returns {import('vite').Plugin | null | undefined}
  */
-export const needleDrop = (command, config, userSettings) => {
+export function needleDrop(command, config, userSettings) {
     if (command === "build") return;
     
     if(userSettings.useDrop !== true) return null;

package/plugins/vite/editor-connection.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param {"build" | "serve"} command
+ * @param {import('../types/needleConfig').needleMeta | null | undefined} config
+ * @param {import('../types').userSettings} userSettings
+ * @param {import('vite').Plugin[]} [pluginsArray]
+ * @returns {Promise<import('vite').Plugin | undefined>}
+ */
+export function editorConnection(command: "build" | "serve", config: import("../types/needleConfig").needleMeta | null | undefined, userSettings: import("../types").userSettings, pluginsArray?: import("vite").Plugin[]): Promise<import("vite").Plugin | undefined>;

package/plugins/vite/editor-connection.js

@@ -14,9 +14,13 @@ const editorSyncPackageName = "@needle-tools/editor-sync"
 let editorSyncEnabled = false;
 
 /**
- * @type {(command: string, config: { generator?: string | null, needleEditor?: { enabled?: boolean } | string | null, dontInstallEditor?: boolean }, userSettings: { dontInstallEditor?: boolean }, pluginsArray: unknown[]) => Promise<import('vite').Plugin | undefined>}
+ * @param {"build" | "serve"} command
+ * @param {import('../types/needleConfig').needleMeta | null | undefined} config
+ * @param {import('../types').userSettings} userSettings
+ * @param {import('vite').Plugin[]} [pluginsArray]
+ * @returns {Promise<import('vite').Plugin | undefined>}
  */
-export const editorConnection = async (command, config, userSettings, pluginsArray) => {
+export async function editorConnection(command, config, userSettings, pluginsArray) {
     if (command === "build") return;
 
     // Editor sync currently only supports Unity

package/plugins/vite/facebook-instant-games.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @param {"build" | "serve"} command
+ * @param {import('../types/needleConfig').needleMeta | null | undefined} config
+ * @param {import('../types').userSettings} userSettings
+ * @returns {import('vite').Plugin | undefined}
+ */
+export function needleFacebookInstantGames(command: "build" | "serve", config: import("../types/needleConfig").needleMeta | null | undefined, userSettings: import("../types").userSettings): import("vite").Plugin | undefined;

package/plugins/vite/facebook-instant-games.js

@@ -31,10 +31,12 @@ function log(...any) {
 }
 
 /**
- * @param {{facebookInstantGames?:object}} config
+ * @param {"build" | "serve"} command
+ * @param {import('../types/needleConfig').needleMeta | null | undefined} config
  * @param {import('../types').userSettings} userSettings
+ * @returns {import('vite').Plugin | undefined}
  */
-export const needleFacebookInstantGames = (command, config, userSettings) => {
+export function needleFacebookInstantGames(command, config, userSettings) {
 
     if (userSettings.noFacebookInstantGames === true) return;
 

package/plugins/vite/gzip.d.ts

@@ -0,0 +1,6 @@
+/** Returns `true` when the Needle project is configured to serve gzip-compressed assets.
+ * Reads the `gzip` field from the config object.
+ * @param {import('../types/needleConfig').needleConfig | undefined} config
+ * @returns {boolean}
+ */
+export function useGzip(config: import("../types/needleConfig").needleConfig | undefined): boolean;

package/plugins/vite/gzip.js

@@ -1,6 +1,11 @@
 
 // import { existsSync } from 'fs';
 
+/** Returns `true` when the Needle project is configured to serve gzip-compressed assets.
+ * Reads the `gzip` field from the config object.
+ * @param {import('../types/needleConfig').needleConfig | undefined} config
+ * @returns {boolean}
+ */
 export function useGzip(config) {
     return config?.gzip ? true : false;
 }

package/plugins/vite/imports-logger.d.ts

@@ -0,0 +1,13 @@
+/** @typedef {{ id: string, imports: GraphNode[], importedBy: GraphNode[] }} GraphNode */
+/**
+ * @param {"build" | "serve"} _command
+ * @param {unknown} _config
+ * @param {import('../types').userSettings} userSettings
+ * @returns {import('vite').Plugin | null}
+ */
+export function needleImportsLogger(_command: "build" | "serve", _config: unknown, userSettings: import("../types").userSettings): import("vite").Plugin | null;
+export type GraphNode = {
+    id: string;
+    imports: GraphNode[];
+    importedBy: GraphNode[];
+};

package/plugins/vite/imports-logger.js

@@ -8,8 +8,9 @@ import fs from 'fs';
  * @param {"build" | "serve"} _command
  * @param {unknown} _config
  * @param {import('../types').userSettings} userSettings
+ * @returns {import('vite').Plugin | null}
  */
-export const needleImportsLogger = (_command, _config, userSettings) => {
+export function needleImportsLogger(_command, _config, userSettings) {
 
     if (!userSettings.debugImportChains) return null;
 

package/plugins/vite/index.d.ts

@@ -0,0 +1,54 @@
+/** # Needle Engine plugins for Vite
+ * Plugins include hot reload support, meta tags, defines, build pipeline, PWA, and more.
+ * ## Using PWA
+ * How to add PWA support to your vite project:
+ * 1) Install the [vite pwa plugin](https://vite-pwa-org.netlify.app/): `npm install vite-plugin-pwa --save-dev`
+ * 2) Add the following to your vite.config.js:
+ *   You first pass the PWAOptions to the needlePlugins function, then you pass the same PWAOptions to the VitePWA plugin.
+ * You *can* use also add a `.webmanifest` file to your web project and edit the [PWA manifest](https://developer.mozilla.org/en-US/docs/Web/Manifest) settings there.
+ * ```js
+ * export default defineConfig(async ({ command }) => {
+ *    // @type {import("vite-plugin-pwa").VitePWAOptions}
+ *    const PWAOptions = {};
+ *    ...
+ *    return {
+ *        plugins: [
+ *            ...
+ *            needlePlugins(command, needleConfig, { pwaOptions: PWAOptions }),
+ *            VitePWA(PWAOptions),
+ *        ],
+ *    }
+ * ```
+ * @param {"build" | "serve"} command
+ * @param {import('../types/needleConfig').needleMeta | null | undefined} config
+ * @param {import('../types/index.js').userSettings} [userSettings]
+ * @returns {Promise<import('vite').Plugin[]>}
+ */
+export function needlePlugins(command: "build" | "serve", config?: import("../types/needleConfig").needleMeta | null | undefined, userSettings?: import("../types/index.js").userSettings): Promise<import("vite").Plugin[]>;
+export { needleAI } from "./ai.js";
+export { needleAsap } from "./asap.js";
+export { needleDefines } from "./defines.js";
+export { needleBuildPipeline } from "./build-pipeline.js";
+export { needleBuild } from "./build.js";
+export { needleMeta } from "./meta.js";
+export { needlePoster } from "./poster.js";
+export { needlePWA } from "./pwa.js";
+export { needleReload } from "./reload.js";
+export { needleDrop } from "./drop.js";
+export { editorConnection } from "./editor-connection.js";
+export { needleCopyFiles } from "./copyfiles.js";
+export { needleViteAlias } from "./alias.js";
+export { needleCustomElementData } from "./custom-element-data.js";
+export { needleTransformCodegen } from "./transform-codegen.js";
+export { needleLicense } from "./license.js";
+export { needlePeerjs } from "./peer.js";
+export { needleDependencyWatcher } from "./dependency-watcher.js";
+export { needleDependencies } from "./dependencies.js";
+export { needleFacebookInstantGames } from "./facebook-instant-games.js";
+export { needleImportsLogger } from "./imports-logger.js";
+export { needleBuildInfo } from "./buildinfo.js";
+export { needleApp } from "./needle-app.js";
+export { needleServer } from "./server.js";
+export * from "./gzip.js";
+export * from "./config.js";
+export { needleMakeFilesLocal, needleLocalFilesSceneAnalysis } from "./local-files.js";

package/plugins/vite/index.js

@@ -94,27 +94,28 @@ const defaultUserSettings = {
  * ## Using PWA
  * How to add PWA support to your vite project:
  * 1) Install the [vite pwa plugin](https://vite-pwa-org.netlify.app/): `npm install vite-plugin-pwa --save-dev`
- * 2) Add the following to your vite.config.js:  
+ * 2) Add the following to your vite.config.js:
  *   You first pass the PWAOptions to the needlePlugins function, then you pass the same PWAOptions to the VitePWA plugin.
  * You *can* use also add a `.webmanifest` file to your web project and edit the [PWA manifest](https://developer.mozilla.org/en-US/docs/Web/Manifest) settings there.
-* ```js
+ * ```js
  * export default defineConfig(async ({ command }) => {
-    // \@type(import("vite-plugin-pwa").VitePWAOptions) (remove the backslash)
-    const PWAOptions = {};
-    ...
-    return {
-        plugins: [
-            ...
-            needlePlugins(command, needleConfig, { pwaOptions: PWAOptions }),
-            VitePWA(PWAOptions),
-        ],
-    }
+ *    // @type {import("vite-plugin-pwa").VitePWAOptions}
+ *    const PWAOptions = {};
+ *    ...
+ *    return {
+ *        plugins: [
+ *            ...
+ *            needlePlugins(command, needleConfig, { pwaOptions: PWAOptions }),
+ *            VitePWA(PWAOptions),
+ *        ],
+ *    }
  * ```
  * @param {"build" | "serve"} command
- * @param {{} | undefined | null} config
- * @param {import('../types/index.js').userSettings} userSettings
+ * @param {import('../types/needleConfig').needleMeta | null | undefined} config
+ * @param {import('../types/index.js').userSettings} [userSettings]
+ * @returns {Promise<import('vite').Plugin[]>}
  */
-export const needlePlugins = async (command, config = undefined, userSettings = {}) => {
+export async function needlePlugins(command, config = undefined, userSettings = {}) {
 
     if (!config) config = {}
 

package/plugins/vite/license.d.ts

@@ -0,0 +1,7 @@
+/** This plugin is used to apply the license to the needle engine.
+ * @param {"build" | "serve"} command
+ * @param {import('../types/needleConfig').needleMeta | null | undefined} config
+ * @param {import('../types/userconfig.js').userSettings} userSettings
+ * @returns {import('vite').Plugin}
+ */
+export function needleLicense(command: "build" | "serve", config: import("../types/needleConfig").needleMeta | null | undefined, userSettings: import("../types/userconfig.js").userSettings): import("vite").Plugin;

package/plugins/vite/license.js

@@ -1,13 +1,13 @@
 import { resolveLicense } from '../common/license.js';
 import { loadConfig } from './config.js';
 
-/**
- * This plugin is used to apply the license to the needle engine.  
- * @param {string} command - The command that is being run
- * @param {object} config - The config object
+/** This plugin is used to apply the license to the needle engine.
+ * @param {"build" | "serve"} command
+ * @param {import('../types/needleConfig').needleMeta | null | undefined} config
  * @param {import('../types/userconfig.js').userSettings} userSettings
+ * @returns {import('vite').Plugin}
  */
-export const needleLicense = (command, config, userSettings) => {
+export function needleLicense(command, config, userSettings) {
     let license = undefined;
 
     return {
@@ -53,4 +53,4 @@ export const needleLicense = (command, config, userSettings) => {
             }
         }
     }
-};
+}

package/plugins/vite/local-files-analysis.d.ts

@@ -0,0 +1,95 @@
+/**
+ * @param {"build" | "serve"} command
+ * @param {unknown} _config
+ * @param {import('../types').userSettings} userSettings
+ * @returns {import('vite').Plugin | null}
+ */
+export function needleLocalFilesSceneAnalysis(command: "build" | "serve", _config: unknown, userSettings: import("../types").userSettings): import("vite").Plugin | null;
+/**
+ * @param {string} projectDir
+ * @returns {AutoPolicy | null}
+ */
+export function getLocalFilesAutoPolicy(projectDir: string): AutoPolicy | null;
+/**
+ * @param {import('../types').userSettings | undefined | null} userSettings
+ * @returns {boolean}
+ */
+export function makeFilesLocalIsEnabled(userSettings: import("../types").userSettings | undefined | null): boolean;
+/**
+ * @param {import('../types').userSettings | undefined | null} userSettings
+ * @returns {LocalizationOptions}
+ */
+export function resolveOptions(userSettings: import("../types").userSettings | undefined | null): LocalizationOptions;
+/**
+ * @param {string | string[] | undefined} features
+ * @returns {boolean}
+ */
+export function hasAutoFeatureSelection(features: string | string[] | undefined): boolean;
+/**
+ * @param {LocalizationOptions} options
+ * @param {string} projectDir
+ * @returns {AutoPolicy | null}
+ */
+export function buildAutoPolicy(options: LocalizationOptions, projectDir: string): AutoPolicy | null;
+/**
+ * @param {string} projectDir
+ * @param {LocalizationOptions} options
+ * @param {SceneAnalysisReport | null} [cachedAnalysis]
+ * @returns {AutoPolicy}
+ */
+export function detectAutoPolicy(projectDir: string, options: LocalizationOptions, cachedAnalysis?: SceneAnalysisReport | null): AutoPolicy;
+/**
+ * @param {string} projectDir
+ * @returns {SceneAnalysisReport}
+ */
+export function analyzeProjectGlbs(projectDir: string): SceneAnalysisReport;
+/**
+ * @param {string} projectDir
+ * @returns {string[]}
+ */
+export function collectAssetGlbs(projectDir: string): string[];
+/**
+ * @param {string} filePath
+ * @returns {Record<string, unknown>}
+ */
+export function readGlbJsonChunk(filePath: string): Record<string, unknown>;
+/**
+ * @param {unknown} json
+ * @returns {string[]}
+ */
+export function collectNeedleComponentExtensionBlobs(json: unknown): string[];
+/**
+ * @param {string} indexHtml
+ * @returns {Set<string>}
+ */
+export function collectIndexHtmlSkyboxUrls(indexHtml: string): Set<string>;
+/**
+ * @param {string | string[] | undefined | null} skyboxOption
+ * @param {Set<string>} indexSkyboxUrls
+ * @returns {Set<string> | null}
+ */
+export function resolveSkyboxSelectionUrls(skyboxOption: string | string[] | undefined | null, indexSkyboxUrls: Set<string>): Set<string> | null;
+/**
+ * @param {string | null | undefined} value
+ * @returns {string | null}
+ */
+export function resolveSkyboxValueToUrl(value: string | null | undefined): string | null;
+/**
+ * @param {string | undefined} mode
+ * @returns {string[]}
+ */
+export function getWebXRProfilesForMode(mode: string | undefined): string[];
+/**
+ * @param {string} url
+ * @param {UrlHandler} handler
+ * @param {LocalizationContext} context
+ * @returns {boolean}
+ */
+export function shouldHandleUrlInAutoMode(url: string, handler: UrlHandler, context: LocalizationContext): boolean;
+export const SKYBOX_MAGIC_KEYWORDS: string[];
+export type LocalizationOptions = import("./local-files-types.js").LocalizationOptions;
+export type AutoPolicy = import("./local-files-types.js").AutoPolicy;
+export type SceneAnalysisReport = import("./local-files-types.js").SceneAnalysisReport;
+export type SceneFile = import("./local-files-types.js").SceneFile;
+export type UrlHandler = import("./local-files-types.js").UrlHandler;
+export type LocalizationContext = import("./local-files-types.js").LocalizationContext;

package/plugins/vite/local-files-analysis.js

@@ -19,9 +19,10 @@ const HLS_CDN_SEGMENT = "/npm/hls.js@";
 const analysisByProject = new Map();
 
 /**
- * @param {string} command
+ * @param {"build" | "serve"} command
  * @param {unknown} _config
  * @param {import('../types').userSettings} userSettings
+ * @returns {import('vite').Plugin | null}
  */
 export function needleLocalFilesSceneAnalysis(command, _config, userSettings) {
     if (!makeFilesLocalIsEnabled(userSettings)) return null;

package/plugins/vite/local-files-core.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @param {"build" | "serve"} command
+ * @param {unknown} _config
+ * @param {import('../types').userSettings} userSettings
+ * @returns {import('vite').Plugin | null}
+ */
+export function needleMakeFilesLocal(command: "build" | "serve", _config: unknown, userSettings: import("../types").userSettings): import("vite").Plugin | null;
+/**
+ * @param {LocalizationOptions} options
+ * @param {AutoPolicy | null} autoPolicy
+ * @returns {UrlHandler[]}
+ */
+export function getActiveHandlers(options: LocalizationOptions, autoPolicy: AutoPolicy | null): UrlHandler[];
+/**
+ * @param {string} src
+ * @param {string} basePath
+ * @param {string} currentDir
+ * @param {LocalizationContext} context
+ * @param {UrlHandler[]} [handlers]
+ * @returns {Promise<string>}
+ */
+export function makeLocal(src: string, basePath: string, currentDir: string, context: LocalizationContext, handlers?: UrlHandler[]): Promise<string>;
+/**
+ * @param {string} html
+ * @param {string} basePath
+ * @param {LocalizationContext} context
+ * @param {UrlHandler[]} [handlers]
+ * @returns {Promise<string>}
+ */
+export function makeLocalHtml(html: string, basePath: string, context: LocalizationContext, handlers?: UrlHandler[]): Promise<string>;
+/**
+ * @param {string} basePath
+ * @param {string} feature
+ * @returns {string}
+ */
+export function getFeatureBasePath(basePath: string, feature: string): string;
+/**
+ * @param {string} baseUrl
+ * @param {string} basePath
+ * @param {string} currentDir
+ * @param {LocalizationContext} context
+ * @returns {Promise<string>}
+ */
+export function handleWebXRProfiles(baseUrl: string, basePath: string, currentDir: string, context: LocalizationContext): Promise<string>;
+export { makeFilesLocalIsEnabled };
+export type LocalizationContext = import("./local-files-types.js").LocalizationContext;
+export type LocalizationOptions = import("./local-files-types.js").LocalizationOptions;
+export type LocalizationStats = import("./local-files-types.js").LocalizationStats;
+export type AutoPolicy = import("./local-files-types.js").AutoPolicy;
+export type UrlHandler = import("./local-files-types.js").UrlHandler;
+import { makeFilesLocalIsEnabled } from './local-files-analysis.js';