@yapmod/builder 0.0.0-stage → 1.0.2

package/dist/build.d.ts

@@ -0,0 +1,17 @@
+export interface BuildPluginOptions {
+    /** Plugin entry file (`.ts`, `.tsx`, `.js` or `.jsx`). */
+    entry: string;
+    /** Where the loadable expression is written. */
+    outfile: string;
+    /** Minify the bundle. */
+    minify?: boolean;
+}
+/**
+ * Bundles a plugin entry into a self-contained expression the client's
+ * loader can evaluate: Babel compiles TSX and rewrites shared-module
+ * imports, esbuild bundles everything else, and the result is wrapped in
+ * the `function (yapmod) { ... }` shape from `expression.ts`.
+ *
+ * Returns the expression and writes it to `options.outfile`.
+ */
+export declare function buildPlugin(options: BuildPluginOptions): Promise<string>;

package/dist/expression.d.ts

@@ -0,0 +1,10 @@
+/** Name bundlers assign to the bundle; the footer reads the exports back. */
+export declare const EXPRESSION_GLOBAL_NAME = "yapmodPlugin";
+/** Opens the expression: runs the bundle in the loader's `yapmod` scope. */
+export declare const expressionBanner = "(function () {\n";
+/**
+ * Closes the expression and returns the default export. Bundlers expose
+ * `export default` as `<globalName>.default`; a function default reaches
+ * the loader unchanged and is called with the API, so factories work too.
+ */
+export declare const expressionFooter = "\n;const plugin = typeof yapmodPlugin !== 'undefined'\n  ? yapmodPlugin.default ?? yapmodPlugin\n  : undefined;\nif (plugin === undefined) {\n  throw new Error(\n    'yapmod: bundle has no default export; export the plugin with `export default`.',\n  );\n}\nreturn plugin;\n})();\n";

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { EXPRESSION_GLOBAL_NAME, expressionBanner, expressionFooter } from './expression.ts';
+export { buildPlugin, type BuildPluginOptions } from './build.ts';
+export { transformPluginSource } from './transform.ts';
+export { yapmodPlugin } from './unplugin.ts';

package/dist/index.js

@@ -0,0 +1,203 @@
+// src/expression.ts
+var EXPRESSION_GLOBAL_NAME = "yapmodPlugin";
+var expressionBanner = "(function () {\n";
+var expressionFooter = `
+;const plugin = typeof ${EXPRESSION_GLOBAL_NAME} !== 'undefined'
+  ? ${EXPRESSION_GLOBAL_NAME}.default ?? ${EXPRESSION_GLOBAL_NAME}
+  : undefined;
+if (plugin === undefined) {
+  throw new Error(
+    'yapmod: bundle has no default export; export the plugin with \`export default\`.',
+  );
+}
+return plugin;
+})();
+`;
+
+// src/build.ts
+import { readFileSync } from "fs";
+import { mkdir, writeFile } from "fs/promises";
+import { dirname } from "path";
+import { build } from "esbuild";
+
+// src/transform.ts
+import { transformSync, types as t } from "@babel/core";
+import presetSolid from "babel-preset-solid";
+import presetTypescript from "@babel/preset-typescript";
+var SHARED_MODULES = {
+  "solid-js": "solid",
+  "solid-js/web": "solidWeb",
+  "solid-js/store": "solidStore"
+};
+function sharedAccess(namespace) {
+  return t.memberExpression(t.identifier("yapmod"), t.identifier(namespace));
+}
+function reexportError(source) {
+  return `@yapmod/builder cannot re-export from "${source}"; import the bindings and export them locally instead.`;
+}
+function rewriteSharedImports() {
+  return {
+    name: "yapmod:rewrite-shared-imports",
+    visitor: {
+      ImportDeclaration(path) {
+        const namespace = SHARED_MODULES[path.node.source.value];
+        if (namespace === void 0) return;
+        if (path.node.importKind === "type") {
+          path.remove();
+          return;
+        }
+        const statements = [];
+        const named = [];
+        for (const specifier of path.node.specifiers) {
+          if (t.isImportNamespaceSpecifier(specifier)) {
+            statements.push(
+              t.variableDeclaration("const", [
+                t.variableDeclarator(specifier.local, sharedAccess(namespace))
+              ])
+            );
+            continue;
+          }
+          if (t.isImportDefaultSpecifier(specifier)) {
+            statements.push(
+              t.variableDeclaration("const", [
+                t.variableDeclarator(
+                  specifier.local,
+                  t.memberExpression(sharedAccess(namespace), t.identifier("default"))
+                )
+              ])
+            );
+            continue;
+          }
+          if (specifier.importKind === "type") continue;
+          named.push(specifier);
+        }
+        if (named.length > 0) {
+          const properties = [];
+          for (const specifier of named) {
+            const key = t.isIdentifier(specifier.imported) ? specifier.imported : t.stringLiteral(specifier.imported.value);
+            properties.push(t.objectProperty(key, specifier.local));
+          }
+          statements.push(
+            t.variableDeclaration("const", [
+              t.variableDeclarator(t.objectPattern(properties), sharedAccess(namespace))
+            ])
+          );
+        }
+        if (statements.length === 0) {
+          path.remove();
+          return;
+        }
+        path.replaceWithMultiple(statements);
+      },
+      ExportNamedDeclaration(path) {
+        if (path.node.exportKind === "type") {
+          path.remove();
+          return;
+        }
+        const source = path.node.source?.value;
+        if (source !== void 0 && source in SHARED_MODULES) {
+          throw path.buildCodeFrameError(reexportError(source));
+        }
+      },
+      ExportAllDeclaration(path) {
+        if (path.node.exportKind === "type") {
+          path.remove();
+          return;
+        }
+        const source = path.node.source.value;
+        if (source in SHARED_MODULES) {
+          throw path.buildCodeFrameError(reexportError(source));
+        }
+      }
+    }
+  };
+}
+function transformPluginSource(code, id) {
+  const first = transformSync(code, {
+    filename: id,
+    babelrc: false,
+    configFile: false,
+    // Presets run in reverse, so TypeScript strips the source before the
+    // Solid preset compiles the now annotation-free JSX.
+    presets: [presetSolid, presetTypescript],
+    sourceType: "module",
+    ast: false,
+    cloneInputAst: false
+  });
+  if (!first?.code) return null;
+  const second = transformSync(first.code, {
+    filename: id,
+    babelrc: false,
+    configFile: false,
+    plugins: [rewriteSharedImports()],
+    sourceType: "module",
+    ast: false
+  });
+  return second?.code ?? null;
+}
+
+// src/build.ts
+var babelTransform = {
+  name: "yapmod:babel-transform",
+  setup(buildApi) {
+    buildApi.onLoad({ filter: /\.(?:[cm]?[jt]sx?)$/ }, (args) => {
+      if (args.path.includes("node_modules")) return void 0;
+      const source = readFileSync(args.path, "utf8");
+      const code = transformPluginSource(source, args.path);
+      return code === null ? void 0 : { contents: code, loader: "js" };
+    });
+  }
+};
+var sharedModuleGuard = {
+  name: "yapmod:shared-module-guard",
+  setup(buildApi) {
+    buildApi.onResolve({ filter: /^solid-js(?:\/.*)?$/ }, (args) => ({
+      errors: [
+        {
+          text: `Dependency "${args.path}" imports solid-js, but the page already runs the shared instance (yapmod.solid*). Plugin dependencies must not bundle their own copy of Solid.`
+        }
+      ]
+    }));
+  }
+};
+async function buildPlugin(options) {
+  const result = await build({
+    entryPoints: [options.entry],
+    bundle: true,
+    write: false,
+    format: "iife",
+    globalName: EXPRESSION_GLOBAL_NAME,
+    // The Babel pass already compiled JSX away; keep esbuild from guessing.
+    jsx: "preserve",
+    target: "es2020",
+    minify: options.minify ?? false,
+    plugins: [babelTransform, sharedModuleGuard]
+  });
+  const output = result.outputFiles[0];
+  if (!output) throw new Error("@yapmod/builder: esbuild produced no output.");
+  const expression = expressionBanner + output.text + expressionFooter;
+  await mkdir(dirname(options.outfile), { recursive: true });
+  await writeFile(options.outfile, expression, "utf8");
+  return expression;
+}
+
+// src/unplugin.ts
+import { createUnplugin } from "unplugin";
+var yapmodPlugin = createUnplugin(() => ({
+  name: "yapmod-plugin",
+  enforce: "pre",
+  transform(code, id) {
+    if (id.includes("node_modules")) return null;
+    if (!/\.(?:[cm]?[jt]sx?)$/.test(id)) return null;
+    const transformed = transformPluginSource(code, id);
+    return transformed === null ? null : { code: transformed, map: null };
+  }
+}));
+export {
+  EXPRESSION_GLOBAL_NAME,
+  buildPlugin,
+  expressionBanner,
+  expressionFooter,
+  transformPluginSource,
+  yapmodPlugin
+};

package/dist/transform.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Compiles one plugin module: TypeScript and JSX first, then the shared-
+ * import rewrite. Returns `null` only when Babel produced no code at all.
+ */
+export declare function transformPluginSource(code: string, id: string): string | null;

package/dist/unplugin.d.ts

@@ -0,0 +1 @@
+export declare const yapmodPlugin: import("unplugin").UnpluginInstance<unknown, boolean>;

package/global.d.ts

@@ -0,0 +1,72 @@
+/*
+ * Self-contained type declaration for the `yapmod` global.
+ *
+ * Inlined from `@yapmod/types` so the builder package has no runtime
+ * dependency on the monorepo types package (which itself depends on
+ * `@yapmod/ui` and `solid-js`).  Plugin authors only need these shapes
+ * for type-checking; the real API object is provided at runtime by the
+ * Yapmod client on the host page.
+ *
+ * Usage: `import type {} from '@yapmod/builder/global'` loads this
+ * ambient declaration into a project.
+ */
+
+import type { Component, JSX } from 'solid-js';
+
+interface YapmodPluginApi {
+  readonly apiVersion: 1;
+  readonly id: string;
+  readonly manifest: {
+    name: string;
+    author: string;
+    description: string;
+    version?: string;
+    hash?: string;
+  };
+  readonly storage: Record<string, unknown>;
+  flushStorage(): void;
+  log(...args: unknown[]): void;
+  observe(selector: string, onFound: (element: Element) => void): () => void;
+  readonly ui: {
+    showToast(message: string, kind?: 'success' | 'error'): void;
+    openModal(options: {
+      title: string;
+      description?: string;
+      wide?: boolean;
+      content: (close: () => void) => JSX.Element;
+      footer?: (close: () => void) => JSX.Element;
+      onClose?: () => void;
+    }): () => void;
+    injectCss(css: string): () => void;
+    Button: Component<JSX.IntrinsicElements['button'] & { variant?: string }>;
+    Hint: Component<JSX.IntrinsicElements['span']>;
+    Panel: Component<JSX.IntrinsicElements['div']>;
+    Icon: Component<{ name: string; class?: string; size?: string }>;
+  };
+  readonly settings: {
+    registerSection(section: {
+      id: string;
+      label: string;
+      icon?: string;
+      render: () => JSX.Element;
+    }): () => void;
+  };
+  onDispose(dispose: () => void): void;
+  showSettings(): void;
+  readonly solid: typeof import('solid-js');
+  readonly solidWeb: typeof import('solid-js/web');
+  readonly solidStore: typeof import('solid-js/store');
+}
+
+declare global {
+  /**
+   * The plugin API the host injects. Every `@yapmod/builder` bundle runs
+   * inside `function (yapmod) { ... }`, so top-level plugin code can use it
+   * without importing anything.
+   */
+  const yapmod: YapmodPluginApi;
+}
+
+// Export the interface so this file is treated as a module (allows empty
+// type imports: `import type {} from '@yapmod/builder/global'`).
+export type { YapmodPluginApi };

package/package.json

@@ -1,6 +1,50 @@
 {
   "name": "@yapmod/builder",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.2",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yapmod/client.git",
+    "directory": "packages/builder"
+  },
+  "files": [
+    "dist",
+    "global.d.ts"
+  ],
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./global": {
+      "types": "./global.d.ts"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup && tsc --emitDeclarationOnly -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "example": "node examples/build.mjs && vite build --config examples/vite.config.mjs && node examples/check.mjs"
+  },
+  "dependencies": {
+    "@babel/core": "^7.29.0",
+    "@babel/preset-typescript": "^7.29.0",
+    "babel-preset-solid": "^1.8.4",
+    "esbuild": "^0.28.2",
+    "solid-js": "^1.9.18",
+    "unplugin": "^3.7.0"
+  },
+  "devDependencies": {
+    "@types/babel__core": "^7.20.5",
+    "@types/node": "^26.0.0",
+    "@typescript/typescript6": "^6.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^7.0.2",
+    "vite": "^8.3.7"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.