@needle-tools/engine 4.16.1 → 4.16.2

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';

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

@@ -213,7 +213,7 @@ function recordLocalizedAsset(stats, url, sizeBytes, mimeType) {
  * @param {import('../types').userSettings} userSettings
  * @returns {import('vite').Plugin | null}
  */
-export const needleMakeFilesLocal = (command, _config, userSettings) => {
+export function needleMakeFilesLocal(command, _config, userSettings) {
     if (!makeFilesLocalIsEnabled(userSettings)) {
         return null;
     }
@@ -373,7 +373,7 @@ export const needleMakeFilesLocal = (command, _config, userSettings) => {
         }
     });
     return plugin;
-};
+}
 
 /**
  * @param {LocalizationOptions} options

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

@@ -0,0 +1,3 @@
+export { getActiveHandlers, getFeatureBasePath, handleWebXRProfiles, makeLocal, makeLocalHtml } from "./local-files-core.js";
+export { analyzeProjectGlbs, buildAutoPolicy, collectAssetGlbs, collectIndexHtmlSkyboxUrls, collectNeedleComponentExtensionBlobs, detectAutoPolicy, getWebXRProfilesForMode, hasAutoFeatureSelection, readGlbJsonChunk, resolveSkyboxSelectionUrls, resolveSkyboxValueToUrl, shouldHandleUrlInAutoMode } from "./local-files-analysis.js";
+export { fixDracoRangeQueryProbe, fixRelativeNewURL, getRelativeToBasePath } from "./local-files-utils.js";

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

@@ -0,0 +1,77 @@
+export function finishMakeLocalProgress(): void;
+/**
+ * @param {string} src
+ * @param {string} search
+ * @param {string} replacement
+ * @returns {string}
+ */
+export function replaceAll(src: string, search: string, replacement: string): string;
+/**
+ * @param {string} path
+ * @param {string} basePath
+ * @returns {string}
+ */
+export function getRelativeToBasePath(path: string, basePath: string): string;
+/**
+ * @param {string} path
+ * @returns {string}
+ */
+export function normalizeWebPath(path: string): string;
+/**
+ * @param {string} path
+ * @returns {string}
+ */
+export function ensureTrailingSlash(path: string): string;
+/**
+ * @param {string} src
+ * @returns {string}
+ */
+export function fixRelativeNewURL(src: string): string;
+/**
+ * @param {string} src
+ * @returns {string}
+ */
+export function fixDracoRangeQueryProbe(src: string): string;
+/**
+ * @param {string} path
+ * @param {string|Buffer} content
+ * @returns {string}
+ */
+export function getValidFilename(path: string, content: string | Buffer): string;
+/**
+ * @param {string} url
+ * @returns {Promise<string>}
+ */
+export function downloadText(url: string): Promise<string>;
+/**
+ * @param {string} url
+ * @returns {Promise<Buffer>}
+ */
+export function downloadBinary(url: string): Promise<Buffer>;
+/**
+ * @param {LocalizationContext} context
+ * @param {string} url
+ * @param {unknown} err
+ */
+export function recordFailedDownload(context: LocalizationContext, url: string, err: unknown): void;
+/**
+ * @param {string} url
+ * @returns {string}
+ */
+export function getShortUrlName(url: string): string;
+export class Cache {
+    /** @type {Map<string, Buffer|string>} */
+    __cache: Map<string, Buffer | string>;
+    /**
+     * @param {string} key
+     * @param {Buffer|string} value
+     */
+    addToCache(key: string, value: Buffer | string): void;
+    /**
+     * @param {string} key
+     * @returns {Buffer|string|null}
+     */
+    getFromCache(key: string): Buffer | string | null;
+    get map(): Map<string, string | Buffer<ArrayBufferLike>>;
+}
+export type LocalizationContext = import("./local-files-types.js").LocalizationContext;

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

@@ -0,0 +1,2 @@
+export { needleLocalFilesSceneAnalysis } from "./local-files-analysis.js";
+export { needleMakeFilesLocal, makeFilesLocalIsEnabled } from "./local-files-core.js";

package/plugins/vite/logger.d.ts

@@ -0,0 +1,8 @@
+/**
+ * write logs to local file
+ * @param {string} command
+ * @param {unknown} _config
+ * @param {import('../types/userconfig.js').userSettings} userSettings
+ * @returns {import('vite').Plugin | null}
+ */
+export function needleLogger(command: string, _config: unknown, userSettings: import("../types/userconfig.js").userSettings): import("vite").Plugin | null;

package/plugins/vite/logger.js

@@ -15,7 +15,7 @@ const __dirname = path.dirname(__filename);
  * @param {import('../types/userconfig.js').userSettings} userSettings
  * @returns {import('vite').Plugin | null}
  */
-export const needleLogger = (command, _config, userSettings) => {
+export function needleLogger(command, _config, userSettings) {
 
     if (userSettings?.disableLogging === true) {
         return null;

package/plugins/vite/logging.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Resets the sticky-header state so the next needleLog call always emits its
+ * [plugin-name] header. Call this at the start of a new build or any logical
+ * output section where you want a guaranteed fresh header.
+ */
+export function resetLastLoggedPlugin(): void;
+/**
+ * @param {string} pluginName
+ * @param {string | string[]} message
+ * @param {'log' | 'warn' | 'error'} [level='log']
+ * @param {{ dimBody?: boolean, leadingNewline?: boolean, showHeader?: boolean }} [options]
+ */
+export function needleLog(pluginName: string, message: string | string[], level?: "log" | "warn" | "error", options?: {
+    dimBody?: boolean;
+    leadingNewline?: boolean;
+    showHeader?: boolean;
+}): void;
+/**
+ * @param {string} pluginName
+ * @param {string[]} lines
+ * @param {'log' | 'warn' | 'error'} [level='log']
+ */
+export function needleLogLines(pluginName: string, lines: string[], level?: "log" | "warn" | "error"): void;
+export function needleSupportsColor(): boolean;
+export function needleBlue(text: any): string;
+export function needleDim(text: any): string;
+export function needleGreenBold(text: any): string;
+/**
+ * @param {(() => void) | null} cleaner
+ */
+export function setTransientLogLineCleaner(cleaner: (() => void) | null): void;

package/plugins/vite/meta.d.ts

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