add createPlotly() factory for tree-shakeable builds

New entry point `lib/factory.js` exports `createPlotly()` — consumers
import only the traces and components they need:

    import { createPlotly } from 'plotly.js/factory';
    import scatter from 'plotly.js/src/traces/scatter/index.js';
    import legend from 'plotly.js/src/components/legend/index.js';
    const Plotly = createPlotly({ traces: [scatter], components: [legend] });

Essential components (colorscale, fx, modebar) are always included.
Optional components (shapes, errorbars, annotations, etc.) are only
included if explicitly passed.

Results (minified, scatter+bar+legend):
- factory: 770 KB (-29% vs upstream basic 1,089 KB)
- vs fork lite: -62 KB (shapes + errorbars tree-shaken away)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: ryan-williams

lib/factory.js

@@ -0,0 +1 @@
+export { createPlotly } from '../src/core-factory.js';

perf/bundle-compare/app-factory.js

@@ -0,0 +1,25 @@
+/**
+ * Factory-based app for bundle size comparison.
+ * Uses createPlotly() with only scatter + bar + legend.
+ */
+import { createPlotly } from '../../src/core-factory.js';
+import scatter from '../../src/traces/scatter/index.js';
+import bar from '../../src/traces/bar/index.js';
+import legend from '../../src/components/legend/index.js';
+
+var Plotly = createPlotly({
+    traces: [scatter, bar],
+    components: [legend],
+});
+
+var el = document.createElement('div');
+document.body.appendChild(el);
+
+Plotly.newPlot(el, [
+    { x: [1, 2, 3, 4], y: [10, 15, 13, 17], type: 'scatter', name: 'Line' },
+    { x: [1, 2, 3, 4], y: [16, 5, 11, 9], type: 'bar', name: 'Bar' },
+], {
+    title: 'Bundle size test (factory)',
+    width: 800,
+    height: 400,
+});

perf/bundle-compare/compare.mjs

@@ -110,6 +110,11 @@ async function main() {
     const forkMinimal = await measureEntry('fork-minimal', 'lib/index-minimal.js');
     const forkLite = await measureEntry('fork-lite', 'lib/index-lite.js');
 
+    // Factory: tree-shaken scatter+bar+legend only
+    const appFactory = await bundleSize('app-factory', {
+        entryPoints: [join(__dirname, 'app-factory.js')],
+    });
+
     // App-level comparison (what consumers actually experience)
     const appUpBasic = await measureApp('app-upstream-basic', join(__dirname, 'upstream/plotly-basic.min.js'));
     const appForkLite = await measureApp('app-fork-lite', join(root, 'lib/index-lite.js'));
@@ -122,10 +127,12 @@ async function main() {
         ['fork basic (min)',           forkBasic,    upBasic],
         ['fork minimal (min)',         forkMinimal,  upBasic],
         ['fork lite (min)',            forkLite,     upBasic],
+        ['fork factory (min)',         appFactory,   upBasic],
         ['', 0, 0],
         ['app + upstream basic',       appUpBasic,   appUpBasic],
         ['app + fork basic',           appForkBasic, appUpBasic],
         ['app + fork lite',            appForkLite,  appUpBasic],
+        ['app + fork factory',         appFactory,   appUpBasic],
     ];
 
     for (const [label, size, baseline] of allResults) {

perf/bundle-compare/thresholds.json

@@ -1,11 +1,11 @@
 {
     "upstream_full__min_": 4831947,
     "upstream_basic__min_": 1114816,
-    "fork_full__min_": 4818460,
-    "fork_basic__min_": 1104615,
-    "fork_minimal__min_": 996905,
-    "fork_lite__min_": 856900,
+    "fork_full__min_": 4818593,
+    "fork_basic__min_": 1104752,
+    "fork_minimal__min_": 997042,
+    "fork_lite__min_": 857037,
     "app___upstream_basic": 1115573,
-    "app___fork_basic": 1104763,
-    "app___fork_lite": 856992
+    "app___fork_basic": 1104900,
+    "app___fork_lite": 857129
 }

perf/thresholds.json

@@ -1,19 +1,19 @@
 {
     "bundleSize": {
         "lite": {
-            "expected_bytes": 1825817
+            "expected_bytes": 1830745
         },
         "lite-min": {
             "expected_bytes": 916326
         },
         "minimal": {
-            "expected_bytes": 2153474
+            "expected_bytes": 2153511
         },
         "minimal-min": {
             "expected_bytes": 1076875
         },
         "basic": {
-            "expected_bytes": 2458549
+            "expected_bytes": 2458595
         },
         "basic-min": {
             "expected_bytes": 1185641

src/core-factory.js

@@ -0,0 +1,80 @@
+/**
+ * Tree-shakeable plotly.js factory.
+ *
+ * Instead of registering all components at import time (which forces
+ * the bundler to include everything), consumers import only what they
+ * need and pass it to createPlotly():
+ *
+ *   import { createPlotly } from 'plotly.js/core';
+ *   import scatter from 'plotly.js/traces/scatter';
+ *   import bar from 'plotly.js/traces/bar';
+ *   import legend from 'plotly.js/components/legend';
+ *
+ *   const Plotly = createPlotly({
+ *       traces: [scatter, bar],
+ *       components: [legend],
+ *   });
+ *   Plotly.newPlot(el, data, layout);
+ */
+import './lib/d3-compat.js';
+import 'd3-transition';
+import 'native-promise-only';
+import Registry from './registry.js';
+import plotApi from './plot_api/index.js';
+import FxModule from './components/fx/index.js';
+import PlotsModule from './plots/plots.js';
+import { version } from './version.js';
+import './plotcss.js';
+
+// Essential components that every plot needs (always registered)
+import colorscale from './components/colorscale/index.js';
+import fx from './components/fx/index.js';
+import modebar from './components/modebar/index.js';
+
+import localeEn from './locale-en.js';
+import localeEnUs from './locale-en-us.js';
+import Icons from './fonts/ploticon.js';
+import Snapshot from './snapshot/index.js';
+import PlotSchema from './plot_api/plot_schema.js';
+
+export function createPlotly({ traces = [], components = [] } = {}) {
+    var register = Registry.register;
+    var Plotly = { version, register, Icons, Snapshot, PlotSchema };
+
+    // Register API methods
+    var methodNames = Object.keys(plotApi);
+    for(var i = 0; i < methodNames.length; i++) {
+        var name = methodNames[i];
+        if(name.charAt(0) !== '_') Plotly[name] = plotApi[name];
+        register({ moduleType: 'apiMethod', name: name, fn: plotApi[name] });
+    }
+
+    // Register essential components (always needed)
+    register([colorscale, fx, modebar]);
+
+    // Register user-chosen traces and components
+    for(var t = 0; t < traces.length; t++) register(traces[t]);
+    for(var c = 0; c < components.length; c++) register(components[c]);
+
+    // Register locales
+    register([localeEn, localeEnUs]);
+    if(typeof window !== 'undefined' && window.PlotlyLocales && Array.isArray(window.PlotlyLocales)) {
+        register(window.PlotlyLocales);
+        delete window.PlotlyLocales;
+    }
+
+    Plotly.Plots = {
+        resize: PlotsModule.resize,
+        graphJson: PlotsModule.graphJson,
+        sendDataToCloud: PlotsModule.sendDataToCloud,
+    };
+    Plotly.Fx = {
+        hover: FxModule.hover,
+        unhover: FxModule.unhover,
+        loneHover: FxModule.loneHover,
+        loneUnhover: FxModule.loneUnhover,
+    };
+
+    return Plotly;
+}
+