beam-alpha 0.1.0

package/dist/next/pin-loader.cjs

@@ -0,0 +1,120 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/next/loaders/pins.ts
+var pins_exports = {};
+__export(pins_exports, {
+  default: () => pinLoader
+});
+module.exports = __toCommonJS(pins_exports);
+
+// src/pinTransform.ts
+var import_postcss = __toESM(require("postcss"), 1);
+var import_postcss_selector_parser = __toESM(require("postcss-selector-parser"), 1);
+var PIN_CLASSES = {
+  ":hover": "bp-pin-hover",
+  ":active": "bp-pin-active",
+  ":focus": "bp-pin-focus",
+  ":focus-within": "bp-pin-focus-within"
+};
+var QUICK_RE = /:(hover|active|focus)/;
+var MAX_COMBINATIONS = 4;
+function addPinVariants(css) {
+  let root;
+  try {
+    root = import_postcss.default.parse(css);
+  } catch {
+    return null;
+  }
+  let changed = false;
+  root.walkRules((rule) => {
+    const parent = rule.parent;
+    if (parent?.type === "atrule" && /keyframes$/i.test(parent.name)) return;
+    if (!QUICK_RE.test(rule.selector)) return;
+    const variants = [];
+    for (const selector of rule.selectors) {
+      variants.push(...pinVariantsOf(selector));
+    }
+    if (variants.length > 0) {
+      rule.selectors = [...rule.selectors, ...variants];
+      changed = true;
+    }
+  });
+  return changed ? root.toString() : null;
+}
+function pinVariantsOf(selector) {
+  let count = 0;
+  try {
+    (0, import_postcss_selector_parser.default)((sel) => {
+      sel.walkPseudos((p) => {
+        if (PIN_CLASSES[p.value] !== void 0 && p.nodes.length === 0) count++;
+      });
+    }).processSync(selector);
+  } catch {
+    return [];
+  }
+  if (count === 0) return [];
+  const subsets = [];
+  if (count > MAX_COMBINATIONS) {
+    subsets.push(Array.from({ length: count }, (_, i) => i));
+  } else {
+    for (let mask = 1; mask < 1 << count; mask++) {
+      const subset = [];
+      for (let bit = 0; bit < count; bit++) if (mask & 1 << bit) subset.push(bit);
+      subsets.push(subset);
+    }
+  }
+  const variants = [];
+  for (const subset of subsets) {
+    const chosen = new Set(subset);
+    try {
+      const replaced = (0, import_postcss_selector_parser.default)((sel) => {
+        let index = 0;
+        sel.walkPseudos((p) => {
+          const cls = PIN_CLASSES[p.value];
+          if (cls === void 0 || p.nodes.length > 0) return;
+          if (chosen.has(index)) p.replaceWith(import_postcss_selector_parser.default.className({ value: cls }));
+          index++;
+        });
+      }).processSync(selector);
+      variants.push(replaced);
+    } catch {
+    }
+  }
+  return variants;
+}
+
+// src/next/loaders/pins.ts
+function pinLoader(css) {
+  if (!/:(hover|active|focus)/.test(css)) {
+    this.callback(null, css);
+    return;
+  }
+  this.callback(null, addPinVariants(css) ?? css);
+}

package/dist/next/source-loader.cjs

@@ -0,0 +1,137 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/next/loaders/source.ts
+var source_exports = {};
+__export(source_exports, {
+  default: () => sourceLoader
+});
+module.exports = __toCommonJS(source_exports);
+
+// src/scope.ts
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+function isWorkspaceRoot(dir) {
+  if ((0, import_node_fs.existsSync)((0, import_node_path.resolve)(dir, "pnpm-workspace.yaml")) || (0, import_node_fs.existsSync)((0, import_node_path.resolve)(dir, "lerna.json"))) return true;
+  try {
+    const pkg = JSON.parse((0, import_node_fs.readFileSync)((0, import_node_path.resolve)(dir, "package.json"), "utf8"));
+    return Boolean(pkg.workspaces);
+  } catch {
+    return false;
+  }
+}
+function enclosingWorkspace(root) {
+  let outermost = root;
+  let current = root;
+  for (; ; ) {
+    if (isWorkspaceRoot(current) || (0, import_node_fs.existsSync)((0, import_node_path.resolve)(current, ".git"))) outermost = current;
+    const parent = (0, import_node_path.dirname)(current);
+    if (parent === current) return outermost;
+    current = parent;
+  }
+}
+function projectScope(root) {
+  return { root, workspace: enclosingWorkspace(root) };
+}
+function within(dir, file) {
+  return file === dir || file.startsWith(dir + import_node_path.sep);
+}
+function inScope(scope2, file) {
+  return within(scope2.workspace, file) && !file.split(import_node_path.sep).includes("node_modules");
+}
+function sourceRel(scope2, file) {
+  if (!inScope(scope2, file)) return null;
+  return (0, import_node_path.relative)(scope2.root, file).split(import_node_path.sep).join("/");
+}
+
+// src/sourceTransform.ts
+var import_parser = require("@babel/parser");
+var import_magic_string = __toESM(require("magic-string"), 1);
+var ATTR = "data-bp-source";
+function stampSources(code, rel) {
+  let ast;
+  try {
+    ast = (0, import_parser.parse)(code, {
+      sourceType: "module",
+      plugins: ["jsx", "typescript"],
+      errorRecovery: true
+    });
+  } catch {
+    return null;
+  }
+  const ms = new import_magic_string.default(code);
+  let stamped = 0;
+  walk(ast, (node) => {
+    if (node.type !== "JSXOpeningElement") return;
+    const name = node["name"];
+    if (!name || name.type !== "JSXIdentifier") return;
+    const tag = name["name"];
+    if (!/^[a-z]/.test(tag)) return;
+    const attrs = node["attributes"] ?? [];
+    const hasOwn = attrs.some(
+      (a) => a.type === "JSXAttribute" && a["name"]?.["name"] === ATTR
+    );
+    if (hasOwn) return;
+    if (typeof name.end !== "number" || !node.loc) return;
+    ms.appendLeft(name.end, ` ${ATTR}="${rel}:${node.loc.start.line}"`);
+    stamped++;
+  });
+  if (stamped === 0) return null;
+  return { code: ms.toString(), map: ms.generateMap({ hires: true }) };
+}
+function walk(node, visit) {
+  visit(node);
+  for (const key of Object.keys(node)) {
+    if (key === "loc") continue;
+    const value = node[key];
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item && typeof item === "object" && typeof item.type === "string") {
+          walk(item, visit);
+        }
+      }
+    } else if (value && typeof value === "object" && typeof value.type === "string") {
+      walk(value, visit);
+    }
+  }
+}
+
+// src/next/loaders/source.ts
+var scope = null;
+function sourceLoader(code) {
+  const root = this.getOptions().root ?? process.cwd();
+  if (!scope || scope.root !== root) scope = projectScope(root);
+  const rel = sourceRel(scope, this.resourcePath);
+  if (rel === null) {
+    this.callback(null, code);
+    return;
+  }
+  const out = stampSources(code, rel);
+  this.callback(null, out === null ? code : out.code);
+}

package/dist/next.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Public types for `@blueprint/dev/next` — hand-written and copied to dist,
+ * on the same rule as `index.d.ts`: nothing here names Next's own types
+ * (which would bind the package to one physical `next` install) or any
+ * internal module.
+ */
+import type { BlueprintOptions } from './index'
+
+export type { BlueprintOptions }
+
+/**
+ * Wrap your Next config. In development this registers Blueprint's source
+ * and pin transforms as loaders (Turbopack and webpack), rewrites
+ * `/__blueprint/*` onto the route file, and records the options for the
+ * handlers. Under `next build` the config comes back untouched.
+ *
+ * Takes whatever you pass — an object literal or a value typed with Next's
+ * own `NextConfig` — and returns the same type. Constrained to `object` and
+ * nothing more on purpose: `NextConfig` is an interface, and TypeScript
+ * will not assign an interface to a type with an index signature, so any
+ * structural constraint here would refuse the one thing a real project
+ * passes.
+ *
+ * ```ts
+ * // next.config.ts
+ * import type { NextConfig } from 'next'
+ * import { withBlueprint } from '@blueprint/dev/next'
+ * const nextConfig: NextConfig = { reactStrictMode: true }
+ * export default withBlueprint(nextConfig)
+ * ```
+ */
+export declare function withBlueprint<C extends object>(config?: C, options?: BlueprintOptions): C
+
+/** Where the route file lives, as a URL: `/api/blueprint`. */
+export declare const ROUTE_BASE: string
+
+/**
+ * The route handlers. One file:
+ *
+ * ```ts
+ * // app/api/blueprint/[[...path]]/route.ts
+ * export { GET, POST, PUT, DELETE } from '@blueprint/dev/next'
+ * export const dynamic = 'force-dynamic'
+ * ```
+ */
+export declare function GET(request: Request, context: { params: Promise<{ path?: string[] }> }): Promise<Response>
+export declare const POST: typeof GET
+export declare const PUT: typeof GET
+export declare const DELETE: typeof GET
+
+/**
+ * The probe, for the root layout's `<head>`: a script tag in development,
+ * nothing in production.
+ *
+ * ```tsx
+ * import { Beam } from '@blueprint/dev/next'
+ * <head><Beam /></head>
+ * ```
+ */
+export declare function Beam(): any