diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f36627ac9dd..cc5c93959d7 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -596,6 +596,9 @@ jobs: - name: Verify generated types are in sync with schema run: npm run schema-typegen-diff-check + - name: Verify entry point declarations are in sync + run: npm run entry-point-types-check + package-resolution: needs: install-and-cibuild runs-on: ubuntu-latest @@ -646,6 +649,21 @@ jobs: console.log('Loaded ' + modules.length + ' compiled modules and src/lib/index.js'); + - name: Type-check type imports from the entry points + working-directory: ${{ runner.temp }}/consumer + run: | + cat > entry-point-types.ts <<'EOF' + import type * as Root from 'plotly.js'; + import type { Config, Data, Layout } from 'plotly.js/lib/core'; + import type * as calendars from 'plotly.js/lib/calendars'; + import type * as indexBasic from 'plotly.js/lib/index-basic'; + import type * as scatter from 'plotly.js/lib/scatter'; + import type * as de from 'plotly.js/lib/locales/de'; + EOF + "$GITHUB_WORKSPACE"/node_modules/.bin/tsc entry-point-types.ts \ + --noEmit --strict --skipLibCheck \ + --target es2022 --module esnext --moduleResolution bundler + # ============================================================ # Standalone jobs (no dependencies on install-and-cibuild) # ============================================================ diff --git a/package.json b/package.json index 40ffca7239a..e6653c479b9 100644 --- a/package.json +++ b/package.json @@ -5,6 +5,19 @@ "license": "MIT", "main": "./lib/index.js", "types": "./lib/index.d.ts", + "typesVersions": { + "*": { + "lib/index.d.ts": [ + "./lib/index.d.ts" + ], + "lib/index": [ + "./lib/index.d.ts" + ], + "lib/*": [ + "./src/types/generated/entry_points/*.d.ts" + ] + } + }, "webpack": "./dist/plotly.js", "repository": { "type": "git", @@ -30,14 +43,16 @@ "extra-bundles": "node tasks/extra_bundles.mjs", "locales": "node tasks/locales.mjs", "schema": "node tasks/schema.mjs", - "schema-typegen-diff-check": "npm run schema && git diff --exit-code src/types/generated/ test/plot-schema.json", + "schema-typegen-diff-check": "npm run schema && git diff --exit-code src/types/generated/schema.d.ts test/plot-schema.json", + "entry-point-types": "node tasks/entry_point_types.mjs", + "entry-point-types-check": "node tasks/entry_point_types.mjs --check", "stats": "node tasks/stats.mjs", "find-strings": "node tasks/find_locale_strings.js", "preprocess": "node tasks/preprocess.js", "use-draftlogs": "node tasks/use_draftlogs.js", "empty-draftlogs": "node tasks/empty_draftlogs.js", "empty-dist": "node tasks/empty_dist.js", - "build": "npm run empty-dist && npm run preprocess && npm run find-strings && npm run bundle && npm run extra-bundles && npm run locales && npm run schema dist && npm run stats", + "build": "npm run empty-dist && npm run preprocess && npm run entry-point-types && npm run find-strings && npm run bundle && npm run extra-bundles && npm run locales && npm run schema dist && npm run stats", "regl-codegen": "node devtools/regl_codegen/server.mjs", "cibuild": "npm run empty-dist && npm run preprocess && node tasks/cibundle.mjs", "lint": "npx @biomejs/biome lint", diff --git a/src/types/ARCHITECTURE.md b/src/types/ARCHITECTURE.md index 06d6064a0ee..a0cf29bc91b 100644 --- a/src/types/ARCHITECTURE.md +++ b/src/types/ARCHITECTURE.md @@ -27,6 +27,9 @@ How TypeScript types are organized in plotly.js. │ │ │ schema.d.ts — common enums, │ │ │ │ traces, layout, animation, │ │ │ │ config, _internal namespace │ +│ │ │ │ +│ │ │ entry_points/ — one │ +│ │ │ declaration per lib/ path │ └──────────────────────────┘ └────────────────────────────────┘ ``` @@ -119,9 +122,33 @@ src/types/ │ └── attributes.d.ts # AttributeMap, AttrInfo (compile-time validation) │ └── generated/ # machine-generated types - └── schema.d.ts # all traces + layout + shared types (from plot-schema.json) + ├── schema.d.ts # all traces + layout + shared types (from plot-schema.json) + └── entry_points/ # one declaration per lib/ entry point + ├── core.d.ts # plotly.js/lib/core + ├── scatter.d.ts # plotly.js/lib/scatter, and one per trace + └── locales/ # plotly.js/lib/locales/, one per locale ``` +### The `generated/entry_points/` directory + +`lib/` holds one entry point per trace, component, bundle, and locale, so a +consumer can import `plotly.js/lib/scatter` instead of the whole library. Each +entry point needs its own declaration. Those declarations live here rather than +beside the entry points so `lib/` stays readable. + +`typesVersions` in package.json maps `plotly.js/lib/` onto this directory. +Two things follow from that: + +- The `lib/index.d.ts` key in that table is necessary. TypeScript 5 runs the + resolved `types` field back through the table, and without the key the `lib/*` + pattern captures it and breaks the plain `plotly.js` import. +- WARNING: TypeScript ignores `typesVersions` once a package has an `exports` + field. Adding `exports` to package.json breaks every subpath declaration here. + +Run `npm run entry-point-types` to regenerate. Run +`npm run entry-point-types-check` to fail when the committed output is stale. CI +runs the check, so a new entry point cannot ship without its declaration. + ### The `.internal.d.ts` convention Files with the `.internal.d.ts` suffix contain types that are **not** part of the diff --git a/src/types/CONVERTING_ATTRIBUTES.md b/src/types/CONVERTING_ATTRIBUTES.md index 9d06863984a..8ed0e164121 100644 --- a/src/types/CONVERTING_ATTRIBUTES.md +++ b/src/types/CONVERTING_ATTRIBUTES.md @@ -103,7 +103,7 @@ should be added to the corresponding `Full*` interface instead. ```bash npm run typecheck # zero errors npm run schema-typegen-diff-check # regen + check test/plot-schema.json - # and src/types/generated/ are unchanged + # and generated/schema.d.ts are unchanged ``` The `schema-typegen-diff-check` script regenerates both the runtime schema diff --git a/src/types/GENERATOR.md b/src/types/GENERATOR.md index b626684ec9d..49f2a9973c6 100644 --- a/src/types/GENERATOR.md +++ b/src/types/GENERATOR.md @@ -330,10 +330,14 @@ wildcard) but their bare names are not. ## CI integration `npm run schema-typegen-diff-check` runs the generator and then verifies that -both `test/plot-schema.json` and `src/types/generated/` are unchanged via -`git diff --exit-code`. If either differs, the command fails with exit code 1 +both `test/plot-schema.json` and `src/types/generated/schema.d.ts` are unchanged +via `git diff --exit-code`. If either differs, the command fails with exit code 1 and outputs the diff to the console. +The path names `schema.d.ts` rather than the whole `generated/` directory, so an +uncommitted change to the entry point declarations cannot fail this check. +`npm run entry-point-types-check` covers those. + This is what makes the JS-to-TS conversion workflow safe: a correct conversion produces a byte-identical schema, so the check passes; an incorrect conversion (typo in a `values` array, missed default, wrong diff --git a/src/types/README.md b/src/types/README.md index b11bd508fcb..283d38728cc 100644 --- a/src/types/README.md +++ b/src/types/README.md @@ -7,7 +7,7 @@ This directory documents the TypeScript conversion in progress. | [SETUP.md](SETUP.md) | First-time contributor — toolchain overview, npm scripts | | [ARCHITECTURE.md](ARCHITECTURE.md) | Anyone working with types — directory layout, public/private split | | [CONVERTING_ATTRIBUTES.md](CONVERTING_ATTRIBUTES.md) | **Contributor doing conversion work** — step-by-step recipe | -| [GENERATOR.md](GENERATOR.md) | Maintainer extending or debugging the type generator | +| [GENERATOR.md](GENERATOR.md) | Maintainer extending or debugging the schema type generator | ## Status @@ -16,7 +16,8 @@ This directory documents the TypeScript conversion in progress. - `AttributeMap` validation machinery: ✅ done - **Schema-based type generator**: ✅ done — all trace types + layout + shared interfaces - Consumer entry point (`lib/index.d.ts`, wired via `package.json#types`): ✅ done -- CI gates (`typecheck` + `schema-typegen-diff-check`): ✅ done +- Modular entry points (`plotly.js/lib/`, wired via `package.json#typesVersions`): ✅ done +- CI gates (`typecheck` + `schema-typegen-diff-check` + `entry-point-types-check`): ✅ done - First attribute file converted (modebar): ✅ done - Conversion of remaining files: 🚧 in progress @@ -36,12 +37,24 @@ This directory documents the TypeScript conversion in progress. `Datum[] | Datum[][] | TypedArray` for *every* `data_array` so 2D/3D usage typechecks, but the trade-off is that 1D-only fields also accept 2D arrays. -The published consumer surface lives at [`lib/index.d.ts`](../../lib/index.d.ts). +The published consumer surface has two parts. [`lib/index.d.ts`](../../lib/index.d.ts) +declares the full library for `import ... from 'plotly.js'`. The generated +declarations in [`generated/entry_points/`](generated/entry_points/) cover the +modular entry points, one file each: `plotly.js/lib/core`, every trace and +component, the partial bundles, and every locale under +`plotly.js/lib/locales/`. + This `src/types/` directory is the authoring location — internal types live here, public types are re-exported through `lib/index.d.ts` to consumers. ## Generated types +Two tasks generate types. This section covers the schema generator. For the +entry point declarations under +[`generated/entry_points/`](generated/entry_points/), see +[ARCHITECTURE.md](ARCHITECTURE.md#the-generatedentry_points-directory) and run +`npm run entry-point-types`. + The following are **auto-generated from `plot-schema.json`** by `tasks/generate_schema_types.mjs`: diff --git a/src/types/SETUP.md b/src/types/SETUP.md index 3ba19342439..72277ff1b63 100644 --- a/src/types/SETUP.md +++ b/src/types/SETUP.md @@ -29,6 +29,10 @@ npm run typecheck-watch # incremental rechecking on change npm run schema # rebuild test/plot-schema.json + regenerate types under src/types/generated/ npm run schema-typegen-diff-check # regenerate + verify no changes to test/plot-schema.json or src/types/generated/schema.d.ts + +npm run entry-point-types # regenerate the entry point declarations under src/types/generated/entry_points/ +npm run entry-point-types-check # verify the committed entry point declarations are current + npm run build # full production build (regenerate all files under `dist/`) ``` @@ -48,14 +52,16 @@ npm start ```bash npm run typecheck -npm run schema # if attribute files changed +npm run schema # if attribute files changed +npm run entry-point-types # if you added or removed a lib/ entry point ``` -**CI** runs both checks as separate jobs (see `.github/workflows/ci.yml`): +**CI** runs these checks (see `.github/workflows/ci.yml`): ```bash npm run typecheck # validates the type system is internally consistent npm run schema-typegen-diff-check # verifies generated types match the schema +npm run entry-point-types-check # verifies every lib/ entry point has a current declaration ``` ## How esbuild handles `.ts` diff --git a/src/types/generated/entry_points/bar.d.ts b/src/types/generated/entry_points/bar.d.ts new file mode 100644 index 00000000000..9bf7f1c290c --- /dev/null +++ b/src/types/generated/entry_points/bar.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/bar.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `bar` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as bar from 'plotly.js/lib/bar'; + * + * Plotly.register([bar]); + */ +declare const bar: RegisterTraceModule & { name: 'bar' }; + +export = bar; diff --git a/src/types/generated/entry_points/barpolar.d.ts b/src/types/generated/entry_points/barpolar.d.ts new file mode 100644 index 00000000000..3ee0da63760 --- /dev/null +++ b/src/types/generated/entry_points/barpolar.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/barpolar.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `barpolar` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as barpolar from 'plotly.js/lib/barpolar'; + * + * Plotly.register([barpolar]); + */ +declare const barpolar: RegisterTraceModule & { name: 'barpolar' }; + +export = barpolar; diff --git a/src/types/generated/entry_points/box.d.ts b/src/types/generated/entry_points/box.d.ts new file mode 100644 index 00000000000..ea3358f9cea --- /dev/null +++ b/src/types/generated/entry_points/box.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/box.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `box` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as box from 'plotly.js/lib/box'; + * + * Plotly.register([box]); + */ +declare const box: RegisterTraceModule & { name: 'box' }; + +export = box; diff --git a/src/types/generated/entry_points/calendars.d.ts b/src/types/generated/entry_points/calendars.d.ts new file mode 100644 index 00000000000..2cec14c2043 --- /dev/null +++ b/src/types/generated/entry_points/calendars.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/calendars.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterComponentModule } from '../../core/api'; + +/** + * The `calendars` component module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as calendars from 'plotly.js/lib/calendars'; + * + * Plotly.register([calendars]); + */ +declare const calendars: RegisterComponentModule & { name: 'calendars' }; + +export = calendars; diff --git a/src/types/generated/entry_points/candlestick.d.ts b/src/types/generated/entry_points/candlestick.d.ts new file mode 100644 index 00000000000..2d90126862b --- /dev/null +++ b/src/types/generated/entry_points/candlestick.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/candlestick.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `candlestick` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as candlestick from 'plotly.js/lib/candlestick'; + * + * Plotly.register([candlestick]); + */ +declare const candlestick: RegisterTraceModule & { name: 'candlestick' }; + +export = candlestick; diff --git a/src/types/generated/entry_points/carpet.d.ts b/src/types/generated/entry_points/carpet.d.ts new file mode 100644 index 00000000000..c2c4d6d012b --- /dev/null +++ b/src/types/generated/entry_points/carpet.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/carpet.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `carpet` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as carpet from 'plotly.js/lib/carpet'; + * + * Plotly.register([carpet]); + */ +declare const carpet: RegisterTraceModule & { name: 'carpet' }; + +export = carpet; diff --git a/src/types/generated/entry_points/choropleth.d.ts b/src/types/generated/entry_points/choropleth.d.ts new file mode 100644 index 00000000000..1d3a47ef7ef --- /dev/null +++ b/src/types/generated/entry_points/choropleth.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/choropleth.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `choropleth` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as choropleth from 'plotly.js/lib/choropleth'; + * + * Plotly.register([choropleth]); + */ +declare const choropleth: RegisterTraceModule & { name: 'choropleth' }; + +export = choropleth; diff --git a/src/types/generated/entry_points/choroplethmap.d.ts b/src/types/generated/entry_points/choroplethmap.d.ts new file mode 100644 index 00000000000..e9e7e35be22 --- /dev/null +++ b/src/types/generated/entry_points/choroplethmap.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/choroplethmap.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `choroplethmap` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as choroplethmap from 'plotly.js/lib/choroplethmap'; + * + * Plotly.register([choroplethmap]); + */ +declare const choroplethmap: RegisterTraceModule & { name: 'choroplethmap' }; + +export = choroplethmap; diff --git a/src/types/generated/entry_points/cone.d.ts b/src/types/generated/entry_points/cone.d.ts new file mode 100644 index 00000000000..6e707ba4963 --- /dev/null +++ b/src/types/generated/entry_points/cone.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/cone.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `cone` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as cone from 'plotly.js/lib/cone'; + * + * Plotly.register([cone]); + */ +declare const cone: RegisterTraceModule & { name: 'cone' }; + +export = cone; diff --git a/src/types/generated/entry_points/contour.d.ts b/src/types/generated/entry_points/contour.d.ts new file mode 100644 index 00000000000..41ae26212ac --- /dev/null +++ b/src/types/generated/entry_points/contour.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/contour.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `contour` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as contour from 'plotly.js/lib/contour'; + * + * Plotly.register([contour]); + */ +declare const contour: RegisterTraceModule & { name: 'contour' }; + +export = contour; diff --git a/src/types/generated/entry_points/contourcarpet.d.ts b/src/types/generated/entry_points/contourcarpet.d.ts new file mode 100644 index 00000000000..93b7ba4586f --- /dev/null +++ b/src/types/generated/entry_points/contourcarpet.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/contourcarpet.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `contourcarpet` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as contourcarpet from 'plotly.js/lib/contourcarpet'; + * + * Plotly.register([contourcarpet]); + */ +declare const contourcarpet: RegisterTraceModule & { name: 'contourcarpet' }; + +export = contourcarpet; diff --git a/src/types/generated/entry_points/core.d.ts b/src/types/generated/entry_points/core.d.ts new file mode 100644 index 00000000000..fb0354ae22a --- /dev/null +++ b/src/types/generated/entry_points/core.d.ts @@ -0,0 +1,18 @@ +/** + * Generated from lib/core.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +/** + * Type surface of `plotly.js/lib/core`. + * + * It pre-registers no trace modules. Pass the ones you need to `Plotly.register`. + * + * The type surface is the same as the full bundle, so this re-exports the + * main declaration. A trace that is not registered at runtime still + * type-checks, which matches the `@types/plotly.js` declarations that this + * replaces. + */ + +export * from '../../../../lib/index'; +export { default } from '../../../../lib/index'; diff --git a/src/types/generated/entry_points/densitymap.d.ts b/src/types/generated/entry_points/densitymap.d.ts new file mode 100644 index 00000000000..43f6ff33ff9 --- /dev/null +++ b/src/types/generated/entry_points/densitymap.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/densitymap.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `densitymap` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as densitymap from 'plotly.js/lib/densitymap'; + * + * Plotly.register([densitymap]); + */ +declare const densitymap: RegisterTraceModule & { name: 'densitymap' }; + +export = densitymap; diff --git a/src/types/generated/entry_points/funnel.d.ts b/src/types/generated/entry_points/funnel.d.ts new file mode 100644 index 00000000000..fdfb9bd9e47 --- /dev/null +++ b/src/types/generated/entry_points/funnel.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/funnel.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `funnel` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as funnel from 'plotly.js/lib/funnel'; + * + * Plotly.register([funnel]); + */ +declare const funnel: RegisterTraceModule & { name: 'funnel' }; + +export = funnel; diff --git a/src/types/generated/entry_points/funnelarea.d.ts b/src/types/generated/entry_points/funnelarea.d.ts new file mode 100644 index 00000000000..79fd094bffe --- /dev/null +++ b/src/types/generated/entry_points/funnelarea.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/funnelarea.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `funnelarea` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as funnelarea from 'plotly.js/lib/funnelarea'; + * + * Plotly.register([funnelarea]); + */ +declare const funnelarea: RegisterTraceModule & { name: 'funnelarea' }; + +export = funnelarea; diff --git a/src/types/generated/entry_points/heatmap.d.ts b/src/types/generated/entry_points/heatmap.d.ts new file mode 100644 index 00000000000..8b462a074cc --- /dev/null +++ b/src/types/generated/entry_points/heatmap.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/heatmap.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `heatmap` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as heatmap from 'plotly.js/lib/heatmap'; + * + * Plotly.register([heatmap]); + */ +declare const heatmap: RegisterTraceModule & { name: 'heatmap' }; + +export = heatmap; diff --git a/src/types/generated/entry_points/histogram.d.ts b/src/types/generated/entry_points/histogram.d.ts new file mode 100644 index 00000000000..465606366ca --- /dev/null +++ b/src/types/generated/entry_points/histogram.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/histogram.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `histogram` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as histogram from 'plotly.js/lib/histogram'; + * + * Plotly.register([histogram]); + */ +declare const histogram: RegisterTraceModule & { name: 'histogram' }; + +export = histogram; diff --git a/src/types/generated/entry_points/histogram2d.d.ts b/src/types/generated/entry_points/histogram2d.d.ts new file mode 100644 index 00000000000..1d52428bf8c --- /dev/null +++ b/src/types/generated/entry_points/histogram2d.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/histogram2d.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `histogram2d` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as histogram2d from 'plotly.js/lib/histogram2d'; + * + * Plotly.register([histogram2d]); + */ +declare const histogram2d: RegisterTraceModule & { name: 'histogram2d' }; + +export = histogram2d; diff --git a/src/types/generated/entry_points/histogram2dcontour.d.ts b/src/types/generated/entry_points/histogram2dcontour.d.ts new file mode 100644 index 00000000000..96171c4c0d1 --- /dev/null +++ b/src/types/generated/entry_points/histogram2dcontour.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/histogram2dcontour.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `histogram2dcontour` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as histogram2dcontour from 'plotly.js/lib/histogram2dcontour'; + * + * Plotly.register([histogram2dcontour]); + */ +declare const histogram2dcontour: RegisterTraceModule & { name: 'histogram2dcontour' }; + +export = histogram2dcontour; diff --git a/src/types/generated/entry_points/icicle.d.ts b/src/types/generated/entry_points/icicle.d.ts new file mode 100644 index 00000000000..e41de56d788 --- /dev/null +++ b/src/types/generated/entry_points/icicle.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/icicle.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `icicle` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as icicle from 'plotly.js/lib/icicle'; + * + * Plotly.register([icicle]); + */ +declare const icicle: RegisterTraceModule & { name: 'icicle' }; + +export = icicle; diff --git a/src/types/generated/entry_points/image.d.ts b/src/types/generated/entry_points/image.d.ts new file mode 100644 index 00000000000..498557da82e --- /dev/null +++ b/src/types/generated/entry_points/image.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/image.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `image` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as image from 'plotly.js/lib/image'; + * + * Plotly.register([image]); + */ +declare const image: RegisterTraceModule & { name: 'image' }; + +export = image; diff --git a/src/types/generated/entry_points/index-basic.d.ts b/src/types/generated/entry_points/index-basic.d.ts new file mode 100644 index 00000000000..8de66d33d72 --- /dev/null +++ b/src/types/generated/entry_points/index-basic.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/index-basic.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +/** + * Type surface of `plotly.js/lib/index-basic`. + * + * It pre-registers the 3 trace modules of the basic bundle: + * bar, pie, scatter. + * + * The type surface is the same as the full bundle, so this re-exports the + * main declaration. A trace that is not registered at runtime still + * type-checks, which matches the `@types/plotly.js` declarations that this + * replaces. + */ + +export * from '../../../../lib/index'; +export { default } from '../../../../lib/index'; diff --git a/src/types/generated/entry_points/index-cartesian.d.ts b/src/types/generated/entry_points/index-cartesian.d.ts new file mode 100644 index 00000000000..4e2e0cdf475 --- /dev/null +++ b/src/types/generated/entry_points/index-cartesian.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/index-cartesian.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +/** + * Type surface of `plotly.js/lib/index-cartesian`. + * + * It pre-registers the 12 trace modules of the cartesian bundle: + * bar, box, contour, heatmap, histogram, histogram2d, histogram2dcontour, image, pie, scatter, scatterternary, violin. + * + * The type surface is the same as the full bundle, so this re-exports the + * main declaration. A trace that is not registered at runtime still + * type-checks, which matches the `@types/plotly.js` declarations that this + * replaces. + */ + +export * from '../../../../lib/index'; +export { default } from '../../../../lib/index'; diff --git a/src/types/generated/entry_points/index-finance.d.ts b/src/types/generated/entry_points/index-finance.d.ts new file mode 100644 index 00000000000..f05e6fa5e4e --- /dev/null +++ b/src/types/generated/entry_points/index-finance.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/index-finance.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +/** + * Type surface of `plotly.js/lib/index-finance`. + * + * It pre-registers the 10 trace modules of the finance bundle: + * bar, candlestick, funnel, funnelarea, histogram, indicator, ohlc, pie, scatter, waterfall. + * + * The type surface is the same as the full bundle, so this re-exports the + * main declaration. A trace that is not registered at runtime still + * type-checks, which matches the `@types/plotly.js` declarations that this + * replaces. + */ + +export * from '../../../../lib/index'; +export { default } from '../../../../lib/index'; diff --git a/src/types/generated/entry_points/index-geo.d.ts b/src/types/generated/entry_points/index-geo.d.ts new file mode 100644 index 00000000000..888a7eb733a --- /dev/null +++ b/src/types/generated/entry_points/index-geo.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/index-geo.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +/** + * Type surface of `plotly.js/lib/index-geo`. + * + * It pre-registers the 3 trace modules of the geo bundle: + * choropleth, scatter, scattergeo. + * + * The type surface is the same as the full bundle, so this re-exports the + * main declaration. A trace that is not registered at runtime still + * type-checks, which matches the `@types/plotly.js` declarations that this + * replaces. + */ + +export * from '../../../../lib/index'; +export { default } from '../../../../lib/index'; diff --git a/src/types/generated/entry_points/index-gl2d.d.ts b/src/types/generated/entry_points/index-gl2d.d.ts new file mode 100644 index 00000000000..6252c3de6af --- /dev/null +++ b/src/types/generated/entry_points/index-gl2d.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/index-gl2d.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +/** + * Type surface of `plotly.js/lib/index-gl2d`. + * + * It pre-registers the 4 trace modules of the gl2d bundle: + * parcoords, scatter, scattergl, splom. + * + * The type surface is the same as the full bundle, so this re-exports the + * main declaration. A trace that is not registered at runtime still + * type-checks, which matches the `@types/plotly.js` declarations that this + * replaces. + */ + +export * from '../../../../lib/index'; +export { default } from '../../../../lib/index'; diff --git a/src/types/generated/entry_points/index-gl3d.d.ts b/src/types/generated/entry_points/index-gl3d.d.ts new file mode 100644 index 00000000000..e17a417cae2 --- /dev/null +++ b/src/types/generated/entry_points/index-gl3d.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/index-gl3d.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +/** + * Type surface of `plotly.js/lib/index-gl3d`. + * + * It pre-registers the 8 trace modules of the gl3d bundle: + * cone, isosurface, mesh3d, scatter, scatter3d, streamtube, surface, volume. + * + * The type surface is the same as the full bundle, so this re-exports the + * main declaration. A trace that is not registered at runtime still + * type-checks, which matches the `@types/plotly.js` declarations that this + * replaces. + */ + +export * from '../../../../lib/index'; +export { default } from '../../../../lib/index'; diff --git a/src/types/generated/entry_points/index-map.d.ts b/src/types/generated/entry_points/index-map.d.ts new file mode 100644 index 00000000000..36799331035 --- /dev/null +++ b/src/types/generated/entry_points/index-map.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/index-map.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +/** + * Type surface of `plotly.js/lib/index-map`. + * + * It pre-registers the 4 trace modules of the map bundle: + * choroplethmap, densitymap, scatter, scattermap. + * + * The type surface is the same as the full bundle, so this re-exports the + * main declaration. A trace that is not registered at runtime still + * type-checks, which matches the `@types/plotly.js` declarations that this + * replaces. + */ + +export * from '../../../../lib/index'; +export { default } from '../../../../lib/index'; diff --git a/src/types/generated/entry_points/index-strict.d.ts b/src/types/generated/entry_points/index-strict.d.ts new file mode 100644 index 00000000000..570cc647ccb --- /dev/null +++ b/src/types/generated/entry_points/index-strict.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/index-strict.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +/** + * Type surface of `plotly.js/lib/index-strict`. + * + * It pre-registers the 46 trace modules of the strict bundle: + * bar, barpolar, box, candlestick, carpet, choropleth, choroplethmap, cone, contour, contourcarpet, densitymap, funnel, funnelarea, heatmap, histogram, histogram2d, histogram2dcontour, icicle, image, indicator, isosurface, mesh3d, ohlc, parcats, parcoords, pie, sankey, scatter, scattergl, scatter3d, scattercarpet, scattergeo, scattermap, scatterpolar, scatterpolargl, scattersmith, scatterternary, splom, streamtube, sunburst, surface, table, treemap, violin, volume, waterfall. + * + * The type surface is the same as the full bundle, so this re-exports the + * main declaration. A trace that is not registered at runtime still + * type-checks, which matches the `@types/plotly.js` declarations that this + * replaces. + */ + +export * from '../../../../lib/index'; +export { default } from '../../../../lib/index'; diff --git a/src/types/generated/entry_points/indicator.d.ts b/src/types/generated/entry_points/indicator.d.ts new file mode 100644 index 00000000000..be8c70b464b --- /dev/null +++ b/src/types/generated/entry_points/indicator.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/indicator.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `indicator` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as indicator from 'plotly.js/lib/indicator'; + * + * Plotly.register([indicator]); + */ +declare const indicator: RegisterTraceModule & { name: 'indicator' }; + +export = indicator; diff --git a/src/types/generated/entry_points/isosurface.d.ts b/src/types/generated/entry_points/isosurface.d.ts new file mode 100644 index 00000000000..9b43e0df60d --- /dev/null +++ b/src/types/generated/entry_points/isosurface.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/isosurface.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `isosurface` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as isosurface from 'plotly.js/lib/isosurface'; + * + * Plotly.register([isosurface]); + */ +declare const isosurface: RegisterTraceModule & { name: 'isosurface' }; + +export = isosurface; diff --git a/src/types/generated/entry_points/locales/af.d.ts b/src/types/generated/entry_points/locales/af.d.ts new file mode 100644 index 00000000000..2e0909e2c42 --- /dev/null +++ b/src/types/generated/entry_points/locales/af.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/af.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `af` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as af from 'plotly.js/lib/locales/af'; + * + * Plotly.register([af]); + */ +declare const af: LocaleModule & { name: 'af' }; + +export = af; diff --git a/src/types/generated/entry_points/locales/am.d.ts b/src/types/generated/entry_points/locales/am.d.ts new file mode 100644 index 00000000000..23806551062 --- /dev/null +++ b/src/types/generated/entry_points/locales/am.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/am.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `am` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as am from 'plotly.js/lib/locales/am'; + * + * Plotly.register([am]); + */ +declare const am: LocaleModule & { name: 'am' }; + +export = am; diff --git a/src/types/generated/entry_points/locales/ar-dz.d.ts b/src/types/generated/entry_points/locales/ar-dz.d.ts new file mode 100644 index 00000000000..720437e043e --- /dev/null +++ b/src/types/generated/entry_points/locales/ar-dz.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/ar-dz.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `ar-DZ` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as arDz from 'plotly.js/lib/locales/ar-dz'; + * + * Plotly.register([arDz]); + */ +declare const arDz: LocaleModule & { name: 'ar-DZ' }; + +export = arDz; diff --git a/src/types/generated/entry_points/locales/ar-eg.d.ts b/src/types/generated/entry_points/locales/ar-eg.d.ts new file mode 100644 index 00000000000..9422da5d37e --- /dev/null +++ b/src/types/generated/entry_points/locales/ar-eg.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/ar-eg.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `ar-EG` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as arEg from 'plotly.js/lib/locales/ar-eg'; + * + * Plotly.register([arEg]); + */ +declare const arEg: LocaleModule & { name: 'ar-EG' }; + +export = arEg; diff --git a/src/types/generated/entry_points/locales/ar.d.ts b/src/types/generated/entry_points/locales/ar.d.ts new file mode 100644 index 00000000000..685f4ceb4f9 --- /dev/null +++ b/src/types/generated/entry_points/locales/ar.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/ar.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `ar` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as ar from 'plotly.js/lib/locales/ar'; + * + * Plotly.register([ar]); + */ +declare const ar: LocaleModule & { name: 'ar' }; + +export = ar; diff --git a/src/types/generated/entry_points/locales/az.d.ts b/src/types/generated/entry_points/locales/az.d.ts new file mode 100644 index 00000000000..90e801428ff --- /dev/null +++ b/src/types/generated/entry_points/locales/az.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/az.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `az` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as az from 'plotly.js/lib/locales/az'; + * + * Plotly.register([az]); + */ +declare const az: LocaleModule & { name: 'az' }; + +export = az; diff --git a/src/types/generated/entry_points/locales/bg.d.ts b/src/types/generated/entry_points/locales/bg.d.ts new file mode 100644 index 00000000000..8f3ce32a447 --- /dev/null +++ b/src/types/generated/entry_points/locales/bg.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/bg.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `bg` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as bg from 'plotly.js/lib/locales/bg'; + * + * Plotly.register([bg]); + */ +declare const bg: LocaleModule & { name: 'bg' }; + +export = bg; diff --git a/src/types/generated/entry_points/locales/bs.d.ts b/src/types/generated/entry_points/locales/bs.d.ts new file mode 100644 index 00000000000..b11532d369f --- /dev/null +++ b/src/types/generated/entry_points/locales/bs.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/bs.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `bs` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as bs from 'plotly.js/lib/locales/bs'; + * + * Plotly.register([bs]); + */ +declare const bs: LocaleModule & { name: 'bs' }; + +export = bs; diff --git a/src/types/generated/entry_points/locales/ca.d.ts b/src/types/generated/entry_points/locales/ca.d.ts new file mode 100644 index 00000000000..7cd984dd15f --- /dev/null +++ b/src/types/generated/entry_points/locales/ca.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/ca.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `ca` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as ca from 'plotly.js/lib/locales/ca'; + * + * Plotly.register([ca]); + */ +declare const ca: LocaleModule & { name: 'ca' }; + +export = ca; diff --git a/src/types/generated/entry_points/locales/cs.d.ts b/src/types/generated/entry_points/locales/cs.d.ts new file mode 100644 index 00000000000..6ee433431a0 --- /dev/null +++ b/src/types/generated/entry_points/locales/cs.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/cs.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `cs` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as cs from 'plotly.js/lib/locales/cs'; + * + * Plotly.register([cs]); + */ +declare const cs: LocaleModule & { name: 'cs' }; + +export = cs; diff --git a/src/types/generated/entry_points/locales/cy.d.ts b/src/types/generated/entry_points/locales/cy.d.ts new file mode 100644 index 00000000000..805d105b262 --- /dev/null +++ b/src/types/generated/entry_points/locales/cy.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/cy.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `cy` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as cy from 'plotly.js/lib/locales/cy'; + * + * Plotly.register([cy]); + */ +declare const cy: LocaleModule & { name: 'cy' }; + +export = cy; diff --git a/src/types/generated/entry_points/locales/da.d.ts b/src/types/generated/entry_points/locales/da.d.ts new file mode 100644 index 00000000000..c910a1fe9aa --- /dev/null +++ b/src/types/generated/entry_points/locales/da.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/da.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `da` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as da from 'plotly.js/lib/locales/da'; + * + * Plotly.register([da]); + */ +declare const da: LocaleModule & { name: 'da' }; + +export = da; diff --git a/src/types/generated/entry_points/locales/de-ch.d.ts b/src/types/generated/entry_points/locales/de-ch.d.ts new file mode 100644 index 00000000000..c901e20b328 --- /dev/null +++ b/src/types/generated/entry_points/locales/de-ch.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/de-ch.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `de-CH` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as deCh from 'plotly.js/lib/locales/de-ch'; + * + * Plotly.register([deCh]); + */ +declare const deCh: LocaleModule & { name: 'de-CH' }; + +export = deCh; diff --git a/src/types/generated/entry_points/locales/de.d.ts b/src/types/generated/entry_points/locales/de.d.ts new file mode 100644 index 00000000000..e4de099e41e --- /dev/null +++ b/src/types/generated/entry_points/locales/de.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/de.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `de` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as de from 'plotly.js/lib/locales/de'; + * + * Plotly.register([de]); + */ +declare const de: LocaleModule & { name: 'de' }; + +export = de; diff --git a/src/types/generated/entry_points/locales/el.d.ts b/src/types/generated/entry_points/locales/el.d.ts new file mode 100644 index 00000000000..71ac5b10de9 --- /dev/null +++ b/src/types/generated/entry_points/locales/el.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/el.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `el` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as el from 'plotly.js/lib/locales/el'; + * + * Plotly.register([el]); + */ +declare const el: LocaleModule & { name: 'el' }; + +export = el; diff --git a/src/types/generated/entry_points/locales/eo.d.ts b/src/types/generated/entry_points/locales/eo.d.ts new file mode 100644 index 00000000000..2472a95bad6 --- /dev/null +++ b/src/types/generated/entry_points/locales/eo.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/eo.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `eo` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as eo from 'plotly.js/lib/locales/eo'; + * + * Plotly.register([eo]); + */ +declare const eo: LocaleModule & { name: 'eo' }; + +export = eo; diff --git a/src/types/generated/entry_points/locales/es-ar.d.ts b/src/types/generated/entry_points/locales/es-ar.d.ts new file mode 100644 index 00000000000..971d10d3127 --- /dev/null +++ b/src/types/generated/entry_points/locales/es-ar.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/es-ar.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `es-AR` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as esAr from 'plotly.js/lib/locales/es-ar'; + * + * Plotly.register([esAr]); + */ +declare const esAr: LocaleModule & { name: 'es-AR' }; + +export = esAr; diff --git a/src/types/generated/entry_points/locales/es-pe.d.ts b/src/types/generated/entry_points/locales/es-pe.d.ts new file mode 100644 index 00000000000..043127f3bf7 --- /dev/null +++ b/src/types/generated/entry_points/locales/es-pe.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/es-pe.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `es-PE` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as esPe from 'plotly.js/lib/locales/es-pe'; + * + * Plotly.register([esPe]); + */ +declare const esPe: LocaleModule & { name: 'es-PE' }; + +export = esPe; diff --git a/src/types/generated/entry_points/locales/es.d.ts b/src/types/generated/entry_points/locales/es.d.ts new file mode 100644 index 00000000000..a0f1df43526 --- /dev/null +++ b/src/types/generated/entry_points/locales/es.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/es.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `es` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as es from 'plotly.js/lib/locales/es'; + * + * Plotly.register([es]); + */ +declare const es: LocaleModule & { name: 'es' }; + +export = es; diff --git a/src/types/generated/entry_points/locales/et.d.ts b/src/types/generated/entry_points/locales/et.d.ts new file mode 100644 index 00000000000..641350cdbf9 --- /dev/null +++ b/src/types/generated/entry_points/locales/et.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/et.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `et` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as et from 'plotly.js/lib/locales/et'; + * + * Plotly.register([et]); + */ +declare const et: LocaleModule & { name: 'et' }; + +export = et; diff --git a/src/types/generated/entry_points/locales/eu.d.ts b/src/types/generated/entry_points/locales/eu.d.ts new file mode 100644 index 00000000000..98bb0ad0188 --- /dev/null +++ b/src/types/generated/entry_points/locales/eu.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/eu.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `eu` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as eu from 'plotly.js/lib/locales/eu'; + * + * Plotly.register([eu]); + */ +declare const eu: LocaleModule & { name: 'eu' }; + +export = eu; diff --git a/src/types/generated/entry_points/locales/fa.d.ts b/src/types/generated/entry_points/locales/fa.d.ts new file mode 100644 index 00000000000..85128169c6b --- /dev/null +++ b/src/types/generated/entry_points/locales/fa.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/fa.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `fa` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as fa from 'plotly.js/lib/locales/fa'; + * + * Plotly.register([fa]); + */ +declare const fa: LocaleModule & { name: 'fa' }; + +export = fa; diff --git a/src/types/generated/entry_points/locales/fi.d.ts b/src/types/generated/entry_points/locales/fi.d.ts new file mode 100644 index 00000000000..87b7b3d2062 --- /dev/null +++ b/src/types/generated/entry_points/locales/fi.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/fi.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `fi` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as fi from 'plotly.js/lib/locales/fi'; + * + * Plotly.register([fi]); + */ +declare const fi: LocaleModule & { name: 'fi' }; + +export = fi; diff --git a/src/types/generated/entry_points/locales/fo.d.ts b/src/types/generated/entry_points/locales/fo.d.ts new file mode 100644 index 00000000000..8661cee374e --- /dev/null +++ b/src/types/generated/entry_points/locales/fo.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/fo.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `fo` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as fo from 'plotly.js/lib/locales/fo'; + * + * Plotly.register([fo]); + */ +declare const fo: LocaleModule & { name: 'fo' }; + +export = fo; diff --git a/src/types/generated/entry_points/locales/fr-ch.d.ts b/src/types/generated/entry_points/locales/fr-ch.d.ts new file mode 100644 index 00000000000..e05eb483912 --- /dev/null +++ b/src/types/generated/entry_points/locales/fr-ch.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/fr-ch.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `fr-CH` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as frCh from 'plotly.js/lib/locales/fr-ch'; + * + * Plotly.register([frCh]); + */ +declare const frCh: LocaleModule & { name: 'fr-CH' }; + +export = frCh; diff --git a/src/types/generated/entry_points/locales/fr.d.ts b/src/types/generated/entry_points/locales/fr.d.ts new file mode 100644 index 00000000000..2d728777b8e --- /dev/null +++ b/src/types/generated/entry_points/locales/fr.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/fr.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `fr` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as fr from 'plotly.js/lib/locales/fr'; + * + * Plotly.register([fr]); + */ +declare const fr: LocaleModule & { name: 'fr' }; + +export = fr; diff --git a/src/types/generated/entry_points/locales/gl.d.ts b/src/types/generated/entry_points/locales/gl.d.ts new file mode 100644 index 00000000000..6299dfc2e9a --- /dev/null +++ b/src/types/generated/entry_points/locales/gl.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/gl.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `gl` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as gl from 'plotly.js/lib/locales/gl'; + * + * Plotly.register([gl]); + */ +declare const gl: LocaleModule & { name: 'gl' }; + +export = gl; diff --git a/src/types/generated/entry_points/locales/gu.d.ts b/src/types/generated/entry_points/locales/gu.d.ts new file mode 100644 index 00000000000..a57f00f0330 --- /dev/null +++ b/src/types/generated/entry_points/locales/gu.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/gu.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `gu` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as gu from 'plotly.js/lib/locales/gu'; + * + * Plotly.register([gu]); + */ +declare const gu: LocaleModule & { name: 'gu' }; + +export = gu; diff --git a/src/types/generated/entry_points/locales/he.d.ts b/src/types/generated/entry_points/locales/he.d.ts new file mode 100644 index 00000000000..c622bedba53 --- /dev/null +++ b/src/types/generated/entry_points/locales/he.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/he.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `he` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as he from 'plotly.js/lib/locales/he'; + * + * Plotly.register([he]); + */ +declare const he: LocaleModule & { name: 'he' }; + +export = he; diff --git a/src/types/generated/entry_points/locales/hi-in.d.ts b/src/types/generated/entry_points/locales/hi-in.d.ts new file mode 100644 index 00000000000..00e50bd437a --- /dev/null +++ b/src/types/generated/entry_points/locales/hi-in.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/hi-in.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `hi-IN` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as hiIn from 'plotly.js/lib/locales/hi-in'; + * + * Plotly.register([hiIn]); + */ +declare const hiIn: LocaleModule & { name: 'hi-IN' }; + +export = hiIn; diff --git a/src/types/generated/entry_points/locales/hr.d.ts b/src/types/generated/entry_points/locales/hr.d.ts new file mode 100644 index 00000000000..97acb7d0b12 --- /dev/null +++ b/src/types/generated/entry_points/locales/hr.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/hr.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `hr` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as hr from 'plotly.js/lib/locales/hr'; + * + * Plotly.register([hr]); + */ +declare const hr: LocaleModule & { name: 'hr' }; + +export = hr; diff --git a/src/types/generated/entry_points/locales/hu.d.ts b/src/types/generated/entry_points/locales/hu.d.ts new file mode 100644 index 00000000000..639ac5cb83e --- /dev/null +++ b/src/types/generated/entry_points/locales/hu.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/hu.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `hu` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as hu from 'plotly.js/lib/locales/hu'; + * + * Plotly.register([hu]); + */ +declare const hu: LocaleModule & { name: 'hu' }; + +export = hu; diff --git a/src/types/generated/entry_points/locales/hy.d.ts b/src/types/generated/entry_points/locales/hy.d.ts new file mode 100644 index 00000000000..c783a81b138 --- /dev/null +++ b/src/types/generated/entry_points/locales/hy.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/hy.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `hy` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as hy from 'plotly.js/lib/locales/hy'; + * + * Plotly.register([hy]); + */ +declare const hy: LocaleModule & { name: 'hy' }; + +export = hy; diff --git a/src/types/generated/entry_points/locales/id.d.ts b/src/types/generated/entry_points/locales/id.d.ts new file mode 100644 index 00000000000..ed85257b8f8 --- /dev/null +++ b/src/types/generated/entry_points/locales/id.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/id.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `id` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as id from 'plotly.js/lib/locales/id'; + * + * Plotly.register([id]); + */ +declare const id: LocaleModule & { name: 'id' }; + +export = id; diff --git a/src/types/generated/entry_points/locales/is.d.ts b/src/types/generated/entry_points/locales/is.d.ts new file mode 100644 index 00000000000..743096ce7b0 --- /dev/null +++ b/src/types/generated/entry_points/locales/is.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/is.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `is` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as is from 'plotly.js/lib/locales/is'; + * + * Plotly.register([is]); + */ +declare const is: LocaleModule & { name: 'is' }; + +export = is; diff --git a/src/types/generated/entry_points/locales/it.d.ts b/src/types/generated/entry_points/locales/it.d.ts new file mode 100644 index 00000000000..897b977d49d --- /dev/null +++ b/src/types/generated/entry_points/locales/it.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/it.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `it` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as it from 'plotly.js/lib/locales/it'; + * + * Plotly.register([it]); + */ +declare const it: LocaleModule & { name: 'it' }; + +export = it; diff --git a/src/types/generated/entry_points/locales/ja.d.ts b/src/types/generated/entry_points/locales/ja.d.ts new file mode 100644 index 00000000000..2ca8a123817 --- /dev/null +++ b/src/types/generated/entry_points/locales/ja.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/ja.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `ja` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as ja from 'plotly.js/lib/locales/ja'; + * + * Plotly.register([ja]); + */ +declare const ja: LocaleModule & { name: 'ja' }; + +export = ja; diff --git a/src/types/generated/entry_points/locales/ka.d.ts b/src/types/generated/entry_points/locales/ka.d.ts new file mode 100644 index 00000000000..eade84216e0 --- /dev/null +++ b/src/types/generated/entry_points/locales/ka.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/ka.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `ka` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as ka from 'plotly.js/lib/locales/ka'; + * + * Plotly.register([ka]); + */ +declare const ka: LocaleModule & { name: 'ka' }; + +export = ka; diff --git a/src/types/generated/entry_points/locales/km.d.ts b/src/types/generated/entry_points/locales/km.d.ts new file mode 100644 index 00000000000..229a0a6750e --- /dev/null +++ b/src/types/generated/entry_points/locales/km.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/km.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `km` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as km from 'plotly.js/lib/locales/km'; + * + * Plotly.register([km]); + */ +declare const km: LocaleModule & { name: 'km' }; + +export = km; diff --git a/src/types/generated/entry_points/locales/ko.d.ts b/src/types/generated/entry_points/locales/ko.d.ts new file mode 100644 index 00000000000..1cd1a544767 --- /dev/null +++ b/src/types/generated/entry_points/locales/ko.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/ko.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `ko` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as ko from 'plotly.js/lib/locales/ko'; + * + * Plotly.register([ko]); + */ +declare const ko: LocaleModule & { name: 'ko' }; + +export = ko; diff --git a/src/types/generated/entry_points/locales/lt.d.ts b/src/types/generated/entry_points/locales/lt.d.ts new file mode 100644 index 00000000000..b68204d49f7 --- /dev/null +++ b/src/types/generated/entry_points/locales/lt.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/lt.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `lt` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as lt from 'plotly.js/lib/locales/lt'; + * + * Plotly.register([lt]); + */ +declare const lt: LocaleModule & { name: 'lt' }; + +export = lt; diff --git a/src/types/generated/entry_points/locales/lv.d.ts b/src/types/generated/entry_points/locales/lv.d.ts new file mode 100644 index 00000000000..9b9f0e0f416 --- /dev/null +++ b/src/types/generated/entry_points/locales/lv.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/lv.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `lv` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as lv from 'plotly.js/lib/locales/lv'; + * + * Plotly.register([lv]); + */ +declare const lv: LocaleModule & { name: 'lv' }; + +export = lv; diff --git a/src/types/generated/entry_points/locales/me-me.d.ts b/src/types/generated/entry_points/locales/me-me.d.ts new file mode 100644 index 00000000000..6e5bd13c2d8 --- /dev/null +++ b/src/types/generated/entry_points/locales/me-me.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/me-me.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `me-ME` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as meMe from 'plotly.js/lib/locales/me-me'; + * + * Plotly.register([meMe]); + */ +declare const meMe: LocaleModule & { name: 'me-ME' }; + +export = meMe; diff --git a/src/types/generated/entry_points/locales/me.d.ts b/src/types/generated/entry_points/locales/me.d.ts new file mode 100644 index 00000000000..b3a35f846a5 --- /dev/null +++ b/src/types/generated/entry_points/locales/me.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/me.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `me` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as me from 'plotly.js/lib/locales/me'; + * + * Plotly.register([me]); + */ +declare const me: LocaleModule & { name: 'me' }; + +export = me; diff --git a/src/types/generated/entry_points/locales/mk.d.ts b/src/types/generated/entry_points/locales/mk.d.ts new file mode 100644 index 00000000000..8d45c4bfec1 --- /dev/null +++ b/src/types/generated/entry_points/locales/mk.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/mk.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `mk` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as mk from 'plotly.js/lib/locales/mk'; + * + * Plotly.register([mk]); + */ +declare const mk: LocaleModule & { name: 'mk' }; + +export = mk; diff --git a/src/types/generated/entry_points/locales/ml.d.ts b/src/types/generated/entry_points/locales/ml.d.ts new file mode 100644 index 00000000000..cd9ee034be3 --- /dev/null +++ b/src/types/generated/entry_points/locales/ml.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/ml.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `ml` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as ml from 'plotly.js/lib/locales/ml'; + * + * Plotly.register([ml]); + */ +declare const ml: LocaleModule & { name: 'ml' }; + +export = ml; diff --git a/src/types/generated/entry_points/locales/ms.d.ts b/src/types/generated/entry_points/locales/ms.d.ts new file mode 100644 index 00000000000..5f145ea7185 --- /dev/null +++ b/src/types/generated/entry_points/locales/ms.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/ms.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `ms` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as ms from 'plotly.js/lib/locales/ms'; + * + * Plotly.register([ms]); + */ +declare const ms: LocaleModule & { name: 'ms' }; + +export = ms; diff --git a/src/types/generated/entry_points/locales/mt.d.ts b/src/types/generated/entry_points/locales/mt.d.ts new file mode 100644 index 00000000000..214844dbfe1 --- /dev/null +++ b/src/types/generated/entry_points/locales/mt.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/mt.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `mt` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as mt from 'plotly.js/lib/locales/mt'; + * + * Plotly.register([mt]); + */ +declare const mt: LocaleModule & { name: 'mt' }; + +export = mt; diff --git a/src/types/generated/entry_points/locales/nl-be.d.ts b/src/types/generated/entry_points/locales/nl-be.d.ts new file mode 100644 index 00000000000..90d80b53374 --- /dev/null +++ b/src/types/generated/entry_points/locales/nl-be.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/nl-be.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `nl-BE` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as nlBe from 'plotly.js/lib/locales/nl-be'; + * + * Plotly.register([nlBe]); + */ +declare const nlBe: LocaleModule & { name: 'nl-BE' }; + +export = nlBe; diff --git a/src/types/generated/entry_points/locales/nl.d.ts b/src/types/generated/entry_points/locales/nl.d.ts new file mode 100644 index 00000000000..13a58274b63 --- /dev/null +++ b/src/types/generated/entry_points/locales/nl.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/nl.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `nl` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as nl from 'plotly.js/lib/locales/nl'; + * + * Plotly.register([nl]); + */ +declare const nl: LocaleModule & { name: 'nl' }; + +export = nl; diff --git a/src/types/generated/entry_points/locales/no.d.ts b/src/types/generated/entry_points/locales/no.d.ts new file mode 100644 index 00000000000..7148f36ae0a --- /dev/null +++ b/src/types/generated/entry_points/locales/no.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/no.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `no` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as no from 'plotly.js/lib/locales/no'; + * + * Plotly.register([no]); + */ +declare const no: LocaleModule & { name: 'no' }; + +export = no; diff --git a/src/types/generated/entry_points/locales/pa.d.ts b/src/types/generated/entry_points/locales/pa.d.ts new file mode 100644 index 00000000000..65c70930e7c --- /dev/null +++ b/src/types/generated/entry_points/locales/pa.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/pa.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `pa` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as pa from 'plotly.js/lib/locales/pa'; + * + * Plotly.register([pa]); + */ +declare const pa: LocaleModule & { name: 'pa' }; + +export = pa; diff --git a/src/types/generated/entry_points/locales/pl.d.ts b/src/types/generated/entry_points/locales/pl.d.ts new file mode 100644 index 00000000000..f3cdb84a384 --- /dev/null +++ b/src/types/generated/entry_points/locales/pl.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/pl.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `pl` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as pl from 'plotly.js/lib/locales/pl'; + * + * Plotly.register([pl]); + */ +declare const pl: LocaleModule & { name: 'pl' }; + +export = pl; diff --git a/src/types/generated/entry_points/locales/pt-br.d.ts b/src/types/generated/entry_points/locales/pt-br.d.ts new file mode 100644 index 00000000000..fccdd210b9a --- /dev/null +++ b/src/types/generated/entry_points/locales/pt-br.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/pt-br.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `pt-BR` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as ptBr from 'plotly.js/lib/locales/pt-br'; + * + * Plotly.register([ptBr]); + */ +declare const ptBr: LocaleModule & { name: 'pt-BR' }; + +export = ptBr; diff --git a/src/types/generated/entry_points/locales/pt-pt.d.ts b/src/types/generated/entry_points/locales/pt-pt.d.ts new file mode 100644 index 00000000000..1702f8b56b0 --- /dev/null +++ b/src/types/generated/entry_points/locales/pt-pt.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/pt-pt.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `pt-PT` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as ptPt from 'plotly.js/lib/locales/pt-pt'; + * + * Plotly.register([ptPt]); + */ +declare const ptPt: LocaleModule & { name: 'pt-PT' }; + +export = ptPt; diff --git a/src/types/generated/entry_points/locales/rm.d.ts b/src/types/generated/entry_points/locales/rm.d.ts new file mode 100644 index 00000000000..b4e2fcc1fd0 --- /dev/null +++ b/src/types/generated/entry_points/locales/rm.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/rm.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `rm` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as rm from 'plotly.js/lib/locales/rm'; + * + * Plotly.register([rm]); + */ +declare const rm: LocaleModule & { name: 'rm' }; + +export = rm; diff --git a/src/types/generated/entry_points/locales/ro.d.ts b/src/types/generated/entry_points/locales/ro.d.ts new file mode 100644 index 00000000000..2512e07c9a7 --- /dev/null +++ b/src/types/generated/entry_points/locales/ro.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/ro.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `ro` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as ro from 'plotly.js/lib/locales/ro'; + * + * Plotly.register([ro]); + */ +declare const ro: LocaleModule & { name: 'ro' }; + +export = ro; diff --git a/src/types/generated/entry_points/locales/ru.d.ts b/src/types/generated/entry_points/locales/ru.d.ts new file mode 100644 index 00000000000..4cf1ab10f4d --- /dev/null +++ b/src/types/generated/entry_points/locales/ru.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/ru.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `ru` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as ru from 'plotly.js/lib/locales/ru'; + * + * Plotly.register([ru]); + */ +declare const ru: LocaleModule & { name: 'ru' }; + +export = ru; diff --git a/src/types/generated/entry_points/locales/si.d.ts b/src/types/generated/entry_points/locales/si.d.ts new file mode 100644 index 00000000000..b2dce41bdfb --- /dev/null +++ b/src/types/generated/entry_points/locales/si.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/si.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `si` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as si from 'plotly.js/lib/locales/si'; + * + * Plotly.register([si]); + */ +declare const si: LocaleModule & { name: 'si' }; + +export = si; diff --git a/src/types/generated/entry_points/locales/sk.d.ts b/src/types/generated/entry_points/locales/sk.d.ts new file mode 100644 index 00000000000..8bf63601ac4 --- /dev/null +++ b/src/types/generated/entry_points/locales/sk.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/sk.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `sk` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as sk from 'plotly.js/lib/locales/sk'; + * + * Plotly.register([sk]); + */ +declare const sk: LocaleModule & { name: 'sk' }; + +export = sk; diff --git a/src/types/generated/entry_points/locales/sl.d.ts b/src/types/generated/entry_points/locales/sl.d.ts new file mode 100644 index 00000000000..09befc5c6f7 --- /dev/null +++ b/src/types/generated/entry_points/locales/sl.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/sl.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `sl` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as sl from 'plotly.js/lib/locales/sl'; + * + * Plotly.register([sl]); + */ +declare const sl: LocaleModule & { name: 'sl' }; + +export = sl; diff --git a/src/types/generated/entry_points/locales/sq.d.ts b/src/types/generated/entry_points/locales/sq.d.ts new file mode 100644 index 00000000000..93faf1498cd --- /dev/null +++ b/src/types/generated/entry_points/locales/sq.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/sq.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `sq` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as sq from 'plotly.js/lib/locales/sq'; + * + * Plotly.register([sq]); + */ +declare const sq: LocaleModule & { name: 'sq' }; + +export = sq; diff --git a/src/types/generated/entry_points/locales/sr-sr.d.ts b/src/types/generated/entry_points/locales/sr-sr.d.ts new file mode 100644 index 00000000000..f9332f17287 --- /dev/null +++ b/src/types/generated/entry_points/locales/sr-sr.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/sr-sr.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `sr-SR` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as srSr from 'plotly.js/lib/locales/sr-sr'; + * + * Plotly.register([srSr]); + */ +declare const srSr: LocaleModule & { name: 'sr-SR' }; + +export = srSr; diff --git a/src/types/generated/entry_points/locales/sr.d.ts b/src/types/generated/entry_points/locales/sr.d.ts new file mode 100644 index 00000000000..bfd1f6c59c5 --- /dev/null +++ b/src/types/generated/entry_points/locales/sr.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/sr.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `sr` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as sr from 'plotly.js/lib/locales/sr'; + * + * Plotly.register([sr]); + */ +declare const sr: LocaleModule & { name: 'sr' }; + +export = sr; diff --git a/src/types/generated/entry_points/locales/sv.d.ts b/src/types/generated/entry_points/locales/sv.d.ts new file mode 100644 index 00000000000..03b543ff473 --- /dev/null +++ b/src/types/generated/entry_points/locales/sv.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/sv.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `sv` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as sv from 'plotly.js/lib/locales/sv'; + * + * Plotly.register([sv]); + */ +declare const sv: LocaleModule & { name: 'sv' }; + +export = sv; diff --git a/src/types/generated/entry_points/locales/sw.d.ts b/src/types/generated/entry_points/locales/sw.d.ts new file mode 100644 index 00000000000..9662f8227f4 --- /dev/null +++ b/src/types/generated/entry_points/locales/sw.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/sw.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `sw` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as sw from 'plotly.js/lib/locales/sw'; + * + * Plotly.register([sw]); + */ +declare const sw: LocaleModule & { name: 'sw' }; + +export = sw; diff --git a/src/types/generated/entry_points/locales/ta.d.ts b/src/types/generated/entry_points/locales/ta.d.ts new file mode 100644 index 00000000000..092fd99e1d8 --- /dev/null +++ b/src/types/generated/entry_points/locales/ta.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/ta.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `ta` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as ta from 'plotly.js/lib/locales/ta'; + * + * Plotly.register([ta]); + */ +declare const ta: LocaleModule & { name: 'ta' }; + +export = ta; diff --git a/src/types/generated/entry_points/locales/th.d.ts b/src/types/generated/entry_points/locales/th.d.ts new file mode 100644 index 00000000000..fdf146b58b5 --- /dev/null +++ b/src/types/generated/entry_points/locales/th.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/th.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `th` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as th from 'plotly.js/lib/locales/th'; + * + * Plotly.register([th]); + */ +declare const th: LocaleModule & { name: 'th' }; + +export = th; diff --git a/src/types/generated/entry_points/locales/tr.d.ts b/src/types/generated/entry_points/locales/tr.d.ts new file mode 100644 index 00000000000..8bbbaafef76 --- /dev/null +++ b/src/types/generated/entry_points/locales/tr.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/tr.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `tr` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as tr from 'plotly.js/lib/locales/tr'; + * + * Plotly.register([tr]); + */ +declare const tr: LocaleModule & { name: 'tr' }; + +export = tr; diff --git a/src/types/generated/entry_points/locales/tt.d.ts b/src/types/generated/entry_points/locales/tt.d.ts new file mode 100644 index 00000000000..2c41903db85 --- /dev/null +++ b/src/types/generated/entry_points/locales/tt.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/tt.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `tt` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as tt from 'plotly.js/lib/locales/tt'; + * + * Plotly.register([tt]); + */ +declare const tt: LocaleModule & { name: 'tt' }; + +export = tt; diff --git a/src/types/generated/entry_points/locales/uk.d.ts b/src/types/generated/entry_points/locales/uk.d.ts new file mode 100644 index 00000000000..acf45d3d8bb --- /dev/null +++ b/src/types/generated/entry_points/locales/uk.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/uk.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `uk` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as uk from 'plotly.js/lib/locales/uk'; + * + * Plotly.register([uk]); + */ +declare const uk: LocaleModule & { name: 'uk' }; + +export = uk; diff --git a/src/types/generated/entry_points/locales/ur.d.ts b/src/types/generated/entry_points/locales/ur.d.ts new file mode 100644 index 00000000000..e95615f214b --- /dev/null +++ b/src/types/generated/entry_points/locales/ur.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/ur.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `ur` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as ur from 'plotly.js/lib/locales/ur'; + * + * Plotly.register([ur]); + */ +declare const ur: LocaleModule & { name: 'ur' }; + +export = ur; diff --git a/src/types/generated/entry_points/locales/vi.d.ts b/src/types/generated/entry_points/locales/vi.d.ts new file mode 100644 index 00000000000..b61e48b2e85 --- /dev/null +++ b/src/types/generated/entry_points/locales/vi.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/vi.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `vi` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as vi from 'plotly.js/lib/locales/vi'; + * + * Plotly.register([vi]); + */ +declare const vi: LocaleModule & { name: 'vi' }; + +export = vi; diff --git a/src/types/generated/entry_points/locales/zh-cn.d.ts b/src/types/generated/entry_points/locales/zh-cn.d.ts new file mode 100644 index 00000000000..48b8d7ff6e8 --- /dev/null +++ b/src/types/generated/entry_points/locales/zh-cn.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/zh-cn.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `zh-CN` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as zhCn from 'plotly.js/lib/locales/zh-cn'; + * + * Plotly.register([zhCn]); + */ +declare const zhCn: LocaleModule & { name: 'zh-CN' }; + +export = zhCn; diff --git a/src/types/generated/entry_points/locales/zh-hk.d.ts b/src/types/generated/entry_points/locales/zh-hk.d.ts new file mode 100644 index 00000000000..37ecf5cc6b5 --- /dev/null +++ b/src/types/generated/entry_points/locales/zh-hk.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/zh-hk.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `zh-HK` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as zhHk from 'plotly.js/lib/locales/zh-hk'; + * + * Plotly.register([zhHk]); + */ +declare const zhHk: LocaleModule & { name: 'zh-HK' }; + +export = zhHk; diff --git a/src/types/generated/entry_points/locales/zh-tw.d.ts b/src/types/generated/entry_points/locales/zh-tw.d.ts new file mode 100644 index 00000000000..157466fb0f4 --- /dev/null +++ b/src/types/generated/entry_points/locales/zh-tw.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/locales/zh-tw.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { LocaleModule } from '../../../core/api'; + +/** + * The `zh-TW` locale module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as zhTw from 'plotly.js/lib/locales/zh-tw'; + * + * Plotly.register([zhTw]); + */ +declare const zhTw: LocaleModule & { name: 'zh-TW' }; + +export = zhTw; diff --git a/src/types/generated/entry_points/mesh3d.d.ts b/src/types/generated/entry_points/mesh3d.d.ts new file mode 100644 index 00000000000..3c6ae5564ca --- /dev/null +++ b/src/types/generated/entry_points/mesh3d.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/mesh3d.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `mesh3d` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as mesh3d from 'plotly.js/lib/mesh3d'; + * + * Plotly.register([mesh3d]); + */ +declare const mesh3d: RegisterTraceModule & { name: 'mesh3d' }; + +export = mesh3d; diff --git a/src/types/generated/entry_points/ohlc.d.ts b/src/types/generated/entry_points/ohlc.d.ts new file mode 100644 index 00000000000..110f53164b0 --- /dev/null +++ b/src/types/generated/entry_points/ohlc.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/ohlc.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `ohlc` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as ohlc from 'plotly.js/lib/ohlc'; + * + * Plotly.register([ohlc]); + */ +declare const ohlc: RegisterTraceModule & { name: 'ohlc' }; + +export = ohlc; diff --git a/src/types/generated/entry_points/parcats.d.ts b/src/types/generated/entry_points/parcats.d.ts new file mode 100644 index 00000000000..1af78aa616b --- /dev/null +++ b/src/types/generated/entry_points/parcats.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/parcats.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `parcats` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as parcats from 'plotly.js/lib/parcats'; + * + * Plotly.register([parcats]); + */ +declare const parcats: RegisterTraceModule & { name: 'parcats' }; + +export = parcats; diff --git a/src/types/generated/entry_points/parcoords.d.ts b/src/types/generated/entry_points/parcoords.d.ts new file mode 100644 index 00000000000..9981cac531e --- /dev/null +++ b/src/types/generated/entry_points/parcoords.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/parcoords.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `parcoords` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as parcoords from 'plotly.js/lib/parcoords'; + * + * Plotly.register([parcoords]); + */ +declare const parcoords: RegisterTraceModule & { name: 'parcoords' }; + +export = parcoords; diff --git a/src/types/generated/entry_points/pie.d.ts b/src/types/generated/entry_points/pie.d.ts new file mode 100644 index 00000000000..92a2b717f46 --- /dev/null +++ b/src/types/generated/entry_points/pie.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/pie.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `pie` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as pie from 'plotly.js/lib/pie'; + * + * Plotly.register([pie]); + */ +declare const pie: RegisterTraceModule & { name: 'pie' }; + +export = pie; diff --git a/src/types/generated/entry_points/quiver.d.ts b/src/types/generated/entry_points/quiver.d.ts new file mode 100644 index 00000000000..64395e618da --- /dev/null +++ b/src/types/generated/entry_points/quiver.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/quiver.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `quiver` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as quiver from 'plotly.js/lib/quiver'; + * + * Plotly.register([quiver]); + */ +declare const quiver: RegisterTraceModule & { name: 'quiver' }; + +export = quiver; diff --git a/src/types/generated/entry_points/sankey.d.ts b/src/types/generated/entry_points/sankey.d.ts new file mode 100644 index 00000000000..2b7d606e498 --- /dev/null +++ b/src/types/generated/entry_points/sankey.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/sankey.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `sankey` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as sankey from 'plotly.js/lib/sankey'; + * + * Plotly.register([sankey]); + */ +declare const sankey: RegisterTraceModule & { name: 'sankey' }; + +export = sankey; diff --git a/src/types/generated/entry_points/scatter.d.ts b/src/types/generated/entry_points/scatter.d.ts new file mode 100644 index 00000000000..d12e2a94530 --- /dev/null +++ b/src/types/generated/entry_points/scatter.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/scatter.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `scatter` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as scatter from 'plotly.js/lib/scatter'; + * + * Plotly.register([scatter]); + */ +declare const scatter: RegisterTraceModule & { name: 'scatter' }; + +export = scatter; diff --git a/src/types/generated/entry_points/scatter3d.d.ts b/src/types/generated/entry_points/scatter3d.d.ts new file mode 100644 index 00000000000..a723616c062 --- /dev/null +++ b/src/types/generated/entry_points/scatter3d.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/scatter3d.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `scatter3d` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as scatter3d from 'plotly.js/lib/scatter3d'; + * + * Plotly.register([scatter3d]); + */ +declare const scatter3d: RegisterTraceModule & { name: 'scatter3d' }; + +export = scatter3d; diff --git a/src/types/generated/entry_points/scattercarpet.d.ts b/src/types/generated/entry_points/scattercarpet.d.ts new file mode 100644 index 00000000000..93dfd716c95 --- /dev/null +++ b/src/types/generated/entry_points/scattercarpet.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/scattercarpet.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `scattercarpet` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as scattercarpet from 'plotly.js/lib/scattercarpet'; + * + * Plotly.register([scattercarpet]); + */ +declare const scattercarpet: RegisterTraceModule & { name: 'scattercarpet' }; + +export = scattercarpet; diff --git a/src/types/generated/entry_points/scattergeo.d.ts b/src/types/generated/entry_points/scattergeo.d.ts new file mode 100644 index 00000000000..f60994954af --- /dev/null +++ b/src/types/generated/entry_points/scattergeo.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/scattergeo.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `scattergeo` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as scattergeo from 'plotly.js/lib/scattergeo'; + * + * Plotly.register([scattergeo]); + */ +declare const scattergeo: RegisterTraceModule & { name: 'scattergeo' }; + +export = scattergeo; diff --git a/src/types/generated/entry_points/scattergl.d.ts b/src/types/generated/entry_points/scattergl.d.ts new file mode 100644 index 00000000000..6a739b14f98 --- /dev/null +++ b/src/types/generated/entry_points/scattergl.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/scattergl.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `scattergl` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as scattergl from 'plotly.js/lib/scattergl'; + * + * Plotly.register([scattergl]); + */ +declare const scattergl: RegisterTraceModule & { name: 'scattergl' }; + +export = scattergl; diff --git a/src/types/generated/entry_points/scattermap.d.ts b/src/types/generated/entry_points/scattermap.d.ts new file mode 100644 index 00000000000..468c1e63ba8 --- /dev/null +++ b/src/types/generated/entry_points/scattermap.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/scattermap.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `scattermap` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as scattermap from 'plotly.js/lib/scattermap'; + * + * Plotly.register([scattermap]); + */ +declare const scattermap: RegisterTraceModule & { name: 'scattermap' }; + +export = scattermap; diff --git a/src/types/generated/entry_points/scatterpolar.d.ts b/src/types/generated/entry_points/scatterpolar.d.ts new file mode 100644 index 00000000000..3d295fd39cd --- /dev/null +++ b/src/types/generated/entry_points/scatterpolar.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/scatterpolar.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `scatterpolar` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as scatterpolar from 'plotly.js/lib/scatterpolar'; + * + * Plotly.register([scatterpolar]); + */ +declare const scatterpolar: RegisterTraceModule & { name: 'scatterpolar' }; + +export = scatterpolar; diff --git a/src/types/generated/entry_points/scatterpolargl.d.ts b/src/types/generated/entry_points/scatterpolargl.d.ts new file mode 100644 index 00000000000..078ed52689b --- /dev/null +++ b/src/types/generated/entry_points/scatterpolargl.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/scatterpolargl.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `scatterpolargl` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as scatterpolargl from 'plotly.js/lib/scatterpolargl'; + * + * Plotly.register([scatterpolargl]); + */ +declare const scatterpolargl: RegisterTraceModule & { name: 'scatterpolargl' }; + +export = scatterpolargl; diff --git a/src/types/generated/entry_points/scattersmith.d.ts b/src/types/generated/entry_points/scattersmith.d.ts new file mode 100644 index 00000000000..fcecc07d08d --- /dev/null +++ b/src/types/generated/entry_points/scattersmith.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/scattersmith.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `scattersmith` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as scattersmith from 'plotly.js/lib/scattersmith'; + * + * Plotly.register([scattersmith]); + */ +declare const scattersmith: RegisterTraceModule & { name: 'scattersmith' }; + +export = scattersmith; diff --git a/src/types/generated/entry_points/scatterternary.d.ts b/src/types/generated/entry_points/scatterternary.d.ts new file mode 100644 index 00000000000..725cd8bcb26 --- /dev/null +++ b/src/types/generated/entry_points/scatterternary.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/scatterternary.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `scatterternary` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as scatterternary from 'plotly.js/lib/scatterternary'; + * + * Plotly.register([scatterternary]); + */ +declare const scatterternary: RegisterTraceModule & { name: 'scatterternary' }; + +export = scatterternary; diff --git a/src/types/generated/entry_points/splom.d.ts b/src/types/generated/entry_points/splom.d.ts new file mode 100644 index 00000000000..b86f62cb2a6 --- /dev/null +++ b/src/types/generated/entry_points/splom.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/splom.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `splom` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as splom from 'plotly.js/lib/splom'; + * + * Plotly.register([splom]); + */ +declare const splom: RegisterTraceModule & { name: 'splom' }; + +export = splom; diff --git a/src/types/generated/entry_points/streamtube.d.ts b/src/types/generated/entry_points/streamtube.d.ts new file mode 100644 index 00000000000..b9da3bf6f06 --- /dev/null +++ b/src/types/generated/entry_points/streamtube.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/streamtube.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `streamtube` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as streamtube from 'plotly.js/lib/streamtube'; + * + * Plotly.register([streamtube]); + */ +declare const streamtube: RegisterTraceModule & { name: 'streamtube' }; + +export = streamtube; diff --git a/src/types/generated/entry_points/sunburst.d.ts b/src/types/generated/entry_points/sunburst.d.ts new file mode 100644 index 00000000000..79ac1ccd7c8 --- /dev/null +++ b/src/types/generated/entry_points/sunburst.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/sunburst.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `sunburst` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as sunburst from 'plotly.js/lib/sunburst'; + * + * Plotly.register([sunburst]); + */ +declare const sunburst: RegisterTraceModule & { name: 'sunburst' }; + +export = sunburst; diff --git a/src/types/generated/entry_points/surface.d.ts b/src/types/generated/entry_points/surface.d.ts new file mode 100644 index 00000000000..19ac25cec20 --- /dev/null +++ b/src/types/generated/entry_points/surface.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/surface.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `surface` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as surface from 'plotly.js/lib/surface'; + * + * Plotly.register([surface]); + */ +declare const surface: RegisterTraceModule & { name: 'surface' }; + +export = surface; diff --git a/src/types/generated/entry_points/table.d.ts b/src/types/generated/entry_points/table.d.ts new file mode 100644 index 00000000000..da0d17a2af3 --- /dev/null +++ b/src/types/generated/entry_points/table.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/table.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `table` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as table from 'plotly.js/lib/table'; + * + * Plotly.register([table]); + */ +declare const table: RegisterTraceModule & { name: 'table' }; + +export = table; diff --git a/src/types/generated/entry_points/treemap.d.ts b/src/types/generated/entry_points/treemap.d.ts new file mode 100644 index 00000000000..11781481d5d --- /dev/null +++ b/src/types/generated/entry_points/treemap.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/treemap.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `treemap` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as treemap from 'plotly.js/lib/treemap'; + * + * Plotly.register([treemap]); + */ +declare const treemap: RegisterTraceModule & { name: 'treemap' }; + +export = treemap; diff --git a/src/types/generated/entry_points/violin.d.ts b/src/types/generated/entry_points/violin.d.ts new file mode 100644 index 00000000000..fb5605c457b --- /dev/null +++ b/src/types/generated/entry_points/violin.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/violin.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `violin` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as violin from 'plotly.js/lib/violin'; + * + * Plotly.register([violin]); + */ +declare const violin: RegisterTraceModule & { name: 'violin' }; + +export = violin; diff --git a/src/types/generated/entry_points/volume.d.ts b/src/types/generated/entry_points/volume.d.ts new file mode 100644 index 00000000000..436299b4c09 --- /dev/null +++ b/src/types/generated/entry_points/volume.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/volume.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `volume` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as volume from 'plotly.js/lib/volume'; + * + * Plotly.register([volume]); + */ +declare const volume: RegisterTraceModule & { name: 'volume' }; + +export = volume; diff --git a/src/types/generated/entry_points/waterfall.d.ts b/src/types/generated/entry_points/waterfall.d.ts new file mode 100644 index 00000000000..d3d18dc1fe3 --- /dev/null +++ b/src/types/generated/entry_points/waterfall.d.ts @@ -0,0 +1,19 @@ +/** + * Generated from lib/waterfall.js by tasks/generate_entry_point_types.mjs. + * Do not edit by hand — run `npm run entry-point-types` to regenerate. + */ + +import type { RegisterTraceModule } from '../../core/api'; + +/** + * The `waterfall` trace module, for `Plotly.register`. + * + * @example + * import * as Plotly from 'plotly.js/lib/core'; + * import * as waterfall from 'plotly.js/lib/waterfall'; + * + * Plotly.register([waterfall]); + */ +declare const waterfall: RegisterTraceModule & { name: 'waterfall' }; + +export = waterfall; diff --git a/tasks/entry_point_types.mjs b/tasks/entry_point_types.mjs new file mode 100644 index 00000000000..b7b438c4d60 --- /dev/null +++ b/tasks/entry_point_types.mjs @@ -0,0 +1,28 @@ +/** + * Write the TypeScript declarations for the modular `lib/` entry points. + * + * Run via `npm run entry-point-types`. With `--check`, the task writes nothing and exits + * 1 when a committed declaration is missing, stale, or no longer generated. CI + * runs the check so a new entry point cannot ship without its declaration. + */ + +import { findStaleEntryPointTypes, OUTPUT_DIR, writeEntryPointTypes } from './generate_entry_point_types.mjs'; + +if (process.argv.includes('--check')) { + const stale = findStaleEntryPointTypes(); + + if (stale.length) { + console.error( + `Found ${stale.length} entry point declaration(s) out of date. Run \`npm run entry-point-types\`:` + ); + for (const file of stale) console.error(` ${OUTPUT_DIR}/${file}`); + process.exit(1); + } + + console.log('OK: entry point declarations are up to date'); +} else { + const { written, removed } = writeEntryPointTypes(); + + console.log(`Generated ${written} declaration(s) → ${OUTPUT_DIR}/`); + for (const file of removed) console.log(`Removed stale ${OUTPUT_DIR}/${file}`); +} diff --git a/tasks/generate_entry_point_types.mjs b/tasks/generate_entry_point_types.mjs new file mode 100644 index 00000000000..f698423c713 --- /dev/null +++ b/tasks/generate_entry_point_types.mjs @@ -0,0 +1,393 @@ +/** + * Generate TypeScript declarations for the modular `lib/` entry points. + * + * `lib/index.d.ts` is hand-written and declares the full public API. Every + * other entry point in `lib/` ships without a declaration, so a consumer that + * writes `import * as scatter from 'plotly.js/lib/scatter'` is told that no + * declaration file was found for the module. This task writes one declaration + * per entry point. + * + * Declarations are written to `OUTPUT_DIR`, not next to the entry points, and + * `typesVersions` in package.json maps `plotly.js/lib/` onto them. + * + * Four entry point shapes exist, and each maps to one declaration: + * + * 1. `core.js` and `index-*.js` expose the whole `Plotly` object, so their + * declarations re-export the hand-written `lib/index.d.ts`. + * 2. `.js` re-exports `src/traces/`, a trace module descriptor + * for `Plotly.register`. + * 3. `.js` re-exports `src/components/`, a component + * module descriptor for `Plotly.register`. + * 4. `locales/.js` holds a locale module descriptor inline. + * + * The task reads `lib/` instead of a hard-coded list, and throws on an entry + * point it cannot classify. A new trace or locale therefore gets a declaration + * for free, and a new entry point shape fails the build instead of passing + * silently. + * + * Run via `npm run entry-point-types`. Run `npm run entry-point-types-check` to fail when the + * committed output is missing, stale, or no longer generated. + */ + +import * as fs from 'fs'; +import * as path from 'path'; + +import constants from './util/constants.js'; +import { generatedHeader, isGenerated, jsDocBlock, toFileText, tsLiteral } from './util/type_gen.mjs'; + +/** npm command that rewrites every declaration in `OUTPUT_DIR`. */ +const COMMAND = 'npm run entry-point-types'; + +/** Path of this task, for the generated header. */ +const TASK = 'tasks/generate_entry_point_types.mjs'; + +/** + * Directory that holds the generated declarations, relative to the repo root. + * + * The declarations live here rather than beside the entry points so `lib/` stays + * readable. `typesVersions` in package.json maps `plotly.js/lib/` onto + * this directory, which is what makes the redirect work for consumers. + */ +export const OUTPUT_DIR = 'src/types/generated/entry_points'; + +/** Absolute path of `OUTPUT_DIR`. */ +const pathToOutput = path.join(constants.pathToRoot, OUTPUT_DIR); + +/** Path of the module descriptor types, from a file in `OUTPUT_DIR`. */ +const API_TYPES_PATH = '../../core/api'; + +/** Path of the hand-written main declaration, from a file in `OUTPUT_DIR`. */ +const MAIN_TYPES_PATH = '../../../../lib/index'; + +/** + * Subdirectories of `lib/` that also hold entry points. + * + * `lib/locales/` holds one entry point per locale, each importable as + * `plotly.js/lib/locales/`, so each needs its own declaration. + */ +const GENERATED_SUBDIRS = ['locales']; + +/** + * `moduleType` value → the interface that describes that descriptor. + * + * An unmapped `moduleType` throws rather than emitting a wrong type. + */ +const DESCRIPTOR_INTERFACES = { + trace: 'RegisterTraceModule', + component: 'RegisterComponentModule', + locale: 'LocaleModule' +}; + +// --------------------------------------------------------------------------- +// Entry point classification +// --------------------------------------------------------------------------- + +/** `module.exports = require('../src/traces/scatter');` */ +const RE_EXPORT = /^module\.exports = require\('\.\.\/(src\/[\w/-]+)'\);$/m; + +/** `var Plotly = require('./core');` … `module.exports = Plotly;` */ +const RE_BUNDLE = /require\('\.\/core'\)/; + +/** + * Classify one `lib/` entry point from its source. + * + * @param name - entry point name without the `.js` extension + * @param source - full contents of the entry point + * @returns `{kind: 'bundle'}`, or `{kind: 'module', target}` where `target` is + * the re-exported path relative to the repository root + * @throws when the source matches no known shape + */ +function classify(name, source) { + if (name === 'core' || RE_BUNDLE.test(source)) return { kind: 'bundle' }; + + const match = source.match(RE_EXPORT); + if (match) return { kind: 'module', target: match[1] }; + + // `lib/locales/*.js` hold their descriptor inline rather than re-exporting it. + const inline = matchDescriptor(source); + if (inline) return { kind: 'inline', descriptor: inline }; + + throw new Error( + `Cannot classify lib/${name}.js. Its shape matches neither a bundle nor a module ` + + 're-export, so teach tasks/generate_entry_point_types.mjs how to declare it.' + ); +} + +// --------------------------------------------------------------------------- +// Module descriptor lookup +// --------------------------------------------------------------------------- + +/** `moduleType: 'trace',` */ +const RE_MODULE_TYPE = /moduleType: '(\w+)'/; + +/** `name: 'scatter',` */ +const RE_NAME = /\bname: '([\w-]+)'/; + +/** + * `var index = require('./base_index');` … `module.exports = index;` + * + * Four gl traces (parcoords, scattergl, scatterpolargl, splom) build their + * descriptor in `base_index.js` and patch one field in `index.js`, so the + * lookup follows this single level of indirection. + */ +const RE_INDIRECTION = /var (\w+) = require\('\.\/(\w+)'\);/; + +/** + * Read the `moduleType` and `name` that a module passes to `Plotly.register`. + * + * @param target - module path relative to the repository root, without `index.js` + * @returns the descriptor's `moduleType` and `name` + * @throws when neither the module nor the file it re-exports declares both fields + */ +function readDescriptor(target) { + const entry = path.join(constants.pathToRoot, target, 'index.js'); + const source = fs.readFileSync(entry, 'utf-8'); + + const found = matchDescriptor(source); + if (found) return found; + + const indirect = source.match(RE_INDIRECTION); + if (indirect && new RegExp(`module\\.exports = ${indirect[1]};`).test(source)) { + const base = path.join(constants.pathToRoot, target, `${indirect[2]}.js`); + const viaBase = matchDescriptor(fs.readFileSync(base, 'utf-8')); + if (viaBase) return viaBase; + } + + throw new Error(`Cannot read moduleType and name from ${target}/index.js`); +} + +function matchDescriptor(source) { + const moduleType = source.match(RE_MODULE_TYPE); + const name = source.match(RE_NAME); + if (!moduleType || !name) return null; + return { moduleType: moduleType[1], name: name[1] }; +} + +// --------------------------------------------------------------------------- +// Declaration templates +// --------------------------------------------------------------------------- + +/** + * Declaration for `core.js` and the `index-*.js` partial bundles. + * + * Each of these entry points exports the same `Plotly` object as `lib/index.js` + * and differs only in which trace modules it pre-registers. The type surface is + * therefore identical, and the declaration re-exports `lib/index.d.ts` verbatim. + * + * @param name - entry point name without the `.js` extension + */ +function bundleDeclaration(name) { + const bundle = name.replace(/^index-/, ''); + const traces = constants.partialBundleTraces[bundle]; + + if (name !== 'core' && !traces) { + throw new Error( + `No trace list for the ${bundle} bundle. Add it to partialBundleTraces in tasks/util/constants.js.` + ); + } + + const registered = + name === 'core' + ? ['It pre-registers no trace modules. Pass the ones you need to `Plotly.register`.'] + : [`It pre-registers the ${traces.length} trace modules of the ${bundle} bundle:`, `${traces.join(', ')}.`]; + + return toFileText([ + generatedHeader({ source: `lib/${name}.js`, task: TASK, command: COMMAND }), + '', + ...jsDocBlock({ + description: [ + `Type surface of \`plotly.js/lib/${name}\`.`, + '', + ...registered, + '', + 'The type surface is the same as the full bundle, so this re-exports the', + 'main declaration. A trace that is not registered at runtime still', + 'type-checks, which matches the `@types/plotly.js` declarations that this', + 'replaces.' + ].join('\n') + }), + '', + `export * from '${MAIN_TYPES_PATH}';`, + `export { default } from '${MAIN_TYPES_PATH}';` + ]); +} + +/** + * Declaration for a trace or component entry point. + * + * The declaration types the entry point as its `Plotly.register` descriptor with + * a literal `name`, and uses `export =` to mirror the CommonJS + * `module.exports = ` shape. `export =` keeps both + * `import * as scatter from '...'` and `import scatter from '...'` working. + * + * Only the fields that `Plotly.register` reads are declared. A trace module + * carries many more (`attributes`, `supplyDefaults`, `plot`, …), but those are + * internal and are deliberately left off the public surface. + * + * @param entry - entry point name without the `.js` extension + * @param descriptor - `moduleType` and `name` read from the module + * @param target - module path relative to the repository root, named in the error message + * @param subdir - subdirectory under `lib/`, or `''` for a top-level entry point + */ +function moduleDeclaration(entry, descriptor, target, subdir) { + const iface = DESCRIPTOR_INTERFACES[descriptor.moduleType]; + if (!iface) { + throw new Error(`Unknown moduleType '${descriptor.moduleType}' in ${target}. Add it to DESCRIPTOR_INTERFACES.`); + } + + const identifier = toIdentifier(entry); + const apiTypesPath = subdir ? `../${API_TYPES_PATH}` : API_TYPES_PATH; + const specifier = subdir ? `${subdir}/${entry}` : entry; + + return toFileText([ + generatedHeader({ source: `lib/${specifier}.js`, task: TASK, command: COMMAND }), + '', + `import type { ${iface} } from '${apiTypesPath}';`, + '', + ...jsDocBlock({ + description: [ + `The \`${descriptor.name}\` ${descriptor.moduleType} module, for \`Plotly.register\`.`, + '', + '@example', + "import * as Plotly from 'plotly.js/lib/core';", + `import * as ${identifier} from 'plotly.js/lib/${specifier}';`, + '', + `Plotly.register([${identifier}]);` + ].join('\n') + }), + `declare const ${identifier}: ${iface} & { name: ${tsLiteral(descriptor.name)} };`, + '', + `export = ${identifier};` + ]); +} + +/** Convert an entry point name to a valid TypeScript identifier. */ +function toIdentifier(name) { + const identifier = name.replace(/-(\w)/g, (_, c) => c.toUpperCase()); + return /^\d/.test(identifier) ? `_${identifier}` : identifier; +} + +// --------------------------------------------------------------------------- +// Generation +// --------------------------------------------------------------------------- + +/** + * Build the declaration text for every generated declaration. + * + * Reads `lib/` and `src/`, and writes nothing. Callers either write the result + * to disk or compare it against the committed files. + * + * @returns path under `OUTPUT_DIR` → declaration text, for every entry point + * except `lib/index.js`, whose declaration is hand-written + * @throws when an entry point cannot be classified, or when a module does not + * declare both `moduleType` and `name` + */ +export function buildEntryPointTypes() { + const declarations = new Map(); + + for (const subdir of ['', ...GENERATED_SUBDIRS]) { + const dir = path.join(constants.pathToLib, subdir); + + const entries = fs + .readdirSync(dir) + .filter((file) => file.endsWith('.js')) + .map((file) => path.basename(file, '.js')) + .filter((name) => !(subdir === '' && name === 'index')) + .sort(); + + for (const entry of entries) { + const source = fs.readFileSync(path.join(dir, `${entry}.js`), 'utf-8'); + const classified = classify(entry, source); + + let text; + if (classified.kind === 'bundle') { + text = bundleDeclaration(entry); + } else if (classified.kind === 'inline') { + text = moduleDeclaration(entry, classified.descriptor, `lib/${subdir}/${entry}.js`, subdir); + } else { + text = moduleDeclaration(entry, readDescriptor(classified.target), classified.target, subdir); + } + + declarations.set(subdir ? `${subdir}/${entry}.d.ts` : `${entry}.d.ts`, text); + } + } + + return declarations; +} + +/** + * List every committed `.d.ts` under `OUTPUT_DIR`. + * + * @returns paths relative to `OUTPUT_DIR`, using forward slashes + */ +function listCommittedDeclarations() { + const files = []; + + for (const subdir of ['', ...GENERATED_SUBDIRS]) { + const dir = path.join(pathToOutput, subdir); + if (!fs.existsSync(dir)) continue; + + for (const file of fs.readdirSync(dir)) { + if (!file.endsWith('.d.ts')) continue; + files.push(subdir ? `${subdir}/${file}` : file); + } + } + + return files; +} + +/** + * Write every generated declaration into `OUTPUT_DIR`, and delete stale ones. + * + * A declaration that carries the generated banner but no longer has a matching + * entry point in `lib/` is removed, so deleting a trace does not leave a + * declaration for a module that no longer exists. + * + * @returns counts of the files written and removed + */ +export function writeEntryPointTypes() { + const declarations = buildEntryPointTypes(); + + for (const subdir of ['', ...GENERATED_SUBDIRS]) { + fs.mkdirSync(path.join(pathToOutput, subdir), { recursive: true }); + } + + for (const [file, text] of declarations) { + fs.writeFileSync(path.join(pathToOutput, file), text); + } + + const removed = []; + for (const file of listCommittedDeclarations()) { + if (declarations.has(file)) continue; + + const full = path.join(pathToOutput, file); + if (!isGenerated(fs.readFileSync(full, 'utf-8'))) continue; + + fs.unlinkSync(full); + removed.push(file); + } + + return { written: declarations.size, removed }; +} + +/** + * Compare the committed declarations against freshly generated text. + * + * @returns names of the files that are missing, stale, or no longer generated + */ +export function findStaleEntryPointTypes() { + const declarations = buildEntryPointTypes(); + const stale = []; + + for (const [file, text] of declarations) { + const full = path.join(pathToOutput, file); + if (!fs.existsSync(full) || fs.readFileSync(full, 'utf-8') !== text) stale.push(file); + } + + for (const file of listCommittedDeclarations()) { + if (declarations.has(file)) continue; + if (isGenerated(fs.readFileSync(path.join(pathToOutput, file), 'utf-8'))) stale.push(file); + } + + return stale.sort(); +} diff --git a/tasks/generate_schema_types.mjs b/tasks/generate_schema_types.mjs index d70970488e7..81ea20edad9 100644 --- a/tasks/generate_schema_types.mjs +++ b/tasks/generate_schema_types.mjs @@ -15,6 +15,8 @@ import * as fs from 'fs'; +import { generatedHeader, jsDocBlock, toFileText, tsLiteral } from './util/type_gen.mjs'; + // --------------------------------------------------------------------------- // Meta keys to skip (not user-facing attributes) // --------------------------------------------------------------------------- @@ -186,13 +188,7 @@ const LAYOUT_ARRAY_NAMES = new Map([ // valType → TS type // --------------------------------------------------------------------------- -function serializeValue(v) { - if (typeof v === 'string') { - const escaped = v.replace(/\\/g, '\\\\').replace(/'/g, "\\'"); - return `'${escaped}'`; - } - return String(v); // numbers, booleans -} +const serializeValue = tsLiteral; /** * Try to match a values array to a known common type. @@ -305,27 +301,7 @@ function formatJSDoc(attr, indent) { } } - if (!description && tags.length === 0) return []; - - // Single-line — preserve original compact format when there's only a description - if (description && tags.length === 0) { - const text = description.replace(/\*\//g, '*\\/'); - return [`${indent}/** ${text} */`]; - } - - // Multi-line block - const out = [`${indent}/**`]; - if (description) { - const text = description.replace(/\*\//g, '*\\/'); - for (const line of text.split('\n')) { - out.push(`${indent} * ${line}`); - } - } - for (const tag of tags) { - out.push(`${indent} * ${tag}`); - } - out.push(`${indent} */`); - return out; + return jsDocBlock({ description, tags, indent }); } /** @@ -1075,10 +1051,11 @@ export function generateSchemaTypes(schema, outputPath) { // ----- Phase 4: Build output ----- const chunks = [ - '/**', - ' * Generated from plot-schema.json by tasks/generate_schema_types.mjs.', - ' * Do not edit by hand — run `npm run schema` to regenerate.', - ' */', + generatedHeader({ + source: 'plot-schema.json', + task: 'tasks/generate_schema_types.mjs', + command: 'npm run schema' + }), '', "import type { Color, ColorScale, Datum, MarkerSymbol, TypedArray } from '../lib/common';", '' @@ -1265,7 +1242,7 @@ export function generateSchemaTypes(schema, outputPath) { } } - fs.writeFileSync(outputPath, chunks.join('\n')); + fs.writeFileSync(outputPath, toFileText(chunks)); const sharedCount = sharedList.length; const layoutCount = subplotGroups.size + arrayItems.size + 1; // +1 for Layout itself diff --git a/tasks/util/type_gen.mjs b/tasks/util/type_gen.mjs new file mode 100644 index 00000000000..7b57319348b --- /dev/null +++ b/tasks/util/type_gen.mjs @@ -0,0 +1,132 @@ +/** + * Shared helpers for the TypeScript declaration generators. + */ + +// --------------------------------------------------------------------------- +// Generated file headers +// --------------------------------------------------------------------------- + +/** + * Opening text of every generated header. + * + * `generatedHeader` writes this text and `isGenerated` looks for it, so the two + * cannot drift apart. A task that deletes its own stale output depends on that: + * if the recognizer stopped matching the emitter, cleanup would quietly skip + * every file instead of failing. + */ +const HEADER_OPENING = '/**\n * Generated from '; + +/** + * Build the header block for a generated file. + * + * The caller adds the blank line that separates the header from the body. + * + * @param source - what the file is generated from, as a path or file name + * @param task - path of the task that writes the file, from the repository root + * @param command - npm command that regenerates the file + * @returns the header block, without a trailing newline + */ +export function generatedHeader({ source, task, command }) { + return [ + `${HEADER_OPENING}${source} by ${task}.`, + // NOTE: the em dash matches the header that `schema.d.ts` already + // carries. Changing it rewrites that file for no behavioral gain. + ` * Do not edit by hand — run \`${command}\` to regenerate.`, + ' */' + ].join('\n'); +} + +/** + * Report whether a file was written by one of the type generators. + * + * Use this before deleting a file that a generator no longer produces, so a + * hand-written file in the same directory is never removed. + * + * @param text - the file's contents + * @returns true when the file carries a generated header + */ +export function isGenerated(text) { + return text.startsWith(HEADER_OPENING); +} + +// --------------------------------------------------------------------------- +// File text +// --------------------------------------------------------------------------- + +/** + * Join generated lines into a file body. + * + * The result ends in exactly one newline, whatever the caller's array ends with. + * `npm run test-syntax` asserts that every file in the repository ends in a + * newline, and a generator that emits two would fail the repository's own + * formatting rules. + * + * @param lines - the generated lines, without line endings + * @returns the file body + */ +export function toFileText(lines) { + return `${lines.join('\n').replace(/\n+$/, '')}\n`; +} + +// --------------------------------------------------------------------------- +// TypeScript literals +// --------------------------------------------------------------------------- + +/** + * Render a JavaScript value as a TypeScript literal. + * + * Strings are single-quoted, with backslashes and single quotes escaped. + * Numbers and booleans are rendered as themselves. + * + * @param value - the value to render + * @returns the literal, ready to paste into generated source + */ +export function tsLiteral(value) { + if (typeof value === 'string') { + const escaped = value.replace(/\\/g, '\\\\').replace(/'/g, "\\'"); + return `'${escaped}'`; + } + return String(value); +} + +// --------------------------------------------------------------------------- +// JSDoc +// --------------------------------------------------------------------------- + +/** + * Build a JSDoc comment block. + * + * A description and no tags collapse to a single line. Anything longer becomes a + * multi-line block. A description with no tags and no text produces no lines at + * all, so a caller can pass whatever it has without testing for emptiness first. + * + * Any `*​/` inside the text is escaped, so a description cannot close the comment + * early and corrupt the file. + * + * @param description - free text, which may contain newlines + * @param tags - extra lines placed after the description, such as `@default 3` + * @param indent - string prefixed to every emitted line + * @returns the block's lines, without line endings + */ +export function jsDocBlock({ description, tags = [], indent = '' }) { + if (!description && tags.length === 0) return []; + + const escape = (text) => text.replace(/\*\//g, '*\\/'); + + if (description && tags.length === 0 && !description.includes('\n')) { + return [`${indent}/** ${escape(description)} */`]; + } + + const out = [`${indent}/**`]; + + if (description) { + for (const line of escape(description).split('\n')) { + out.push(line === '' ? `${indent} *` : `${indent} * ${line}`); + } + } + + for (const tag of tags) out.push(`${indent} * ${tag}`); + + out.push(`${indent} */`); + return out; +}