@holo-js/adapter-shared 0.3.0

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+import { NormalizedHoloHttpError } from '@holo-js/kernel/http-errors';
+export { HoloHttpErrorStatus, NormalizedHoloHttpError, isHoloHttpErrorStatus, normalizeHoloHttpError } from '@holo-js/kernel/http-errors';
+
+type ClientErrorPageOptions = {
+    readonly rootId: string;
+    readonly statusClassName: string;
+};
+declare function renderClientHttpErrorPage(error: NormalizedHoloHttpError, options: ClientErrorPageOptions): void;
+
+type RealtimeDefinitionSourceMap = {
+    readonly version: 3;
+    readonly file: string;
+    readonly sources: readonly string[];
+    readonly sourcesContent: readonly string[];
+    readonly names: readonly string[];
+    readonly mappings: string;
+};
+type RealtimeDefinitionTransformResult = {
+    readonly code: string;
+    readonly map: RealtimeDefinitionSourceMap;
+};
+declare function stripRealtimeServerHandlers(source: string): string;
+declare function createRealtimeClientDefinitionModule(source: string, importTarget: string): string;
+declare function createRealtimeClientDefinitionTransform(source: string, importTarget: string): RealtimeDefinitionTransformResult;
+
+export { type ClientErrorPageOptions, type RealtimeDefinitionSourceMap, type RealtimeDefinitionTransformResult, createRealtimeClientDefinitionModule, createRealtimeClientDefinitionTransform, renderClientHttpErrorPage, stripRealtimeServerHandlers };

package/dist/index.mjs

@@ -0,0 +1,188 @@
+// src/index.ts
+import ts from "typescript";
+import {
+  isHoloHttpErrorStatus,
+  normalizeHoloHttpError
+} from "@holo-js/kernel/http-errors";
+
+// src/clientErrorPage.ts
+function escapePage(error, options) {
+  const browserDocument = globalThis.document;
+  if (!browserDocument) return;
+  browserDocument.title = `${error.status}: ${error.message}`;
+  const existingRoot = browserDocument.getElementById(options.rootId);
+  const root = existingRoot ?? browserDocument.createElement("main");
+  root.id = options.rootId;
+  root.setAttribute("role", "alert");
+  root.style.cssText = "position:fixed;inset:0;z-index:2147483647;display:grid;place-items:center;margin:0;background:#fff;color:#000;font-family:Arial,Helvetica,sans-serif";
+  const wrapper = browserDocument.createElement("div");
+  wrapper.style.cssText = "display:flex;align-items:center;gap:1.5rem;padding:1.5rem";
+  const status = browserDocument.createElement("h1");
+  status.className = options.statusClassName;
+  status.textContent = String(error.status);
+  status.style.cssText = "display:inline-block;margin:0 1.25rem 0 0;padding:0 1.5rem 0 0;font-size:24px;font-weight:500;line-height:49px;vertical-align:top;border-right:1px solid rgba(0,0,0,.3)";
+  const description = browserDocument.createElement("div");
+  description.style.cssText = "display:inline-block;text-align:left;line-height:49px;height:49px;vertical-align:middle";
+  const message = browserDocument.createElement("h2");
+  message.textContent = error.message;
+  message.style.cssText = "font-size:14px;font-weight:400;line-height:49px;margin:0";
+  description.append(message);
+  wrapper.append(status, description);
+  root.replaceChildren(wrapper);
+  for (const child of Array.from(browserDocument.body.children)) {
+    if (child.id !== root.id) child.style.display = "none";
+  }
+  if (!existingRoot) browserDocument.body.append(root);
+}
+function renderClientHttpErrorPage(error, options) {
+  escapePage(error, options);
+}
+
+// src/index.ts
+function propertyName(property) {
+  if (!("name" in property) || !property.name) return void 0;
+  return ts.isIdentifier(property.name) || ts.isStringLiteral(property.name) ? property.name.text : void 0;
+}
+function collectRealtimeFactories(sourceFile) {
+  const factories = /* @__PURE__ */ new Map([
+    ["query", "query"],
+    ["mutation", "mutation"]
+  ]);
+  for (const statement of sourceFile.statements) {
+    if (!ts.isImportDeclaration(statement) || !statement.importClause?.namedBindings) continue;
+    if (!ts.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== "@holo-js/realtime") continue;
+    if (!ts.isNamedImports(statement.importClause.namedBindings)) continue;
+    for (const element of statement.importClause.namedBindings.elements) {
+      const importedName = element.propertyName?.text ?? element.name.text;
+      if (importedName === "query" || importedName === "mutation") {
+        factories.set(element.name.text, importedName);
+      }
+    }
+  }
+  return factories;
+}
+function collectDefinitions(sourceFile) {
+  const definitions = [];
+  const factories = collectRealtimeFactories(sourceFile);
+  for (const statement of sourceFile.statements) {
+    if (!ts.isVariableStatement(statement) || !statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (!ts.isIdentifier(declaration.name) || !declaration.initializer || !ts.isCallExpression(declaration.initializer)) continue;
+      const factoryNode = declaration.initializer.expression;
+      if (!ts.isIdentifier(factoryNode)) continue;
+      const factory = factories.get(factoryNode.text);
+      if (!factory) continue;
+      const definitionNode = declaration.initializer.arguments[0];
+      if (!definitionNode || !ts.isObjectLiteralExpression(definitionNode)) continue;
+      const nameProperty = definitionNode.properties.find((property) => propertyName(property) === "name");
+      const name = nameProperty && ts.isPropertyAssignment(nameProperty) ? nameProperty.initializer.getText(sourceFile) : void 0;
+      const sourceLine = sourceFile.getLineAndCharacterOfPosition(declaration.getStart(sourceFile)).line;
+      definitions.push({ exportedName: declaration.name.text, factory, sourceLine, ...name ? { name } : {} });
+    }
+  }
+  return Object.freeze(definitions);
+}
+var base64VlqCharacters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function encodeVlq(value) {
+  let encoded = "";
+  let remaining = value < 0 ? (-value << 1) + 1 : value << 1;
+  do {
+    let digit = remaining & 31;
+    remaining >>>= 5;
+    if (remaining > 0) digit |= 32;
+    encoded += base64VlqCharacters[digit];
+  } while (remaining > 0);
+  return encoded;
+}
+function createSourceMap(source, sourceLines) {
+  let previousSourceLine = 0;
+  const mappings = sourceLines.map((sourceLine) => {
+    if (typeof sourceLine === "undefined") return "";
+    const segment = `${encodeVlq(0)}${encodeVlq(0)}${encodeVlq(sourceLine - previousSourceLine)}${encodeVlq(0)}`;
+    previousSourceLine = sourceLine;
+    return segment;
+  }).join(";");
+  return {
+    version: 3,
+    file: "realtime.client.ts",
+    sources: ["realtime.ts"],
+    sourcesContent: [source],
+    names: [],
+    mappings
+  };
+}
+function parseRealtimeSource(source) {
+  const result = ts.transpileModule(source, {
+    compilerOptions: { module: ts.ModuleKind.ESNext, target: ts.ScriptTarget.ESNext },
+    reportDiagnostics: true
+  });
+  const diagnostic = result.diagnostics?.find((entry) => entry.category === ts.DiagnosticCategory.Error);
+  if (diagnostic) {
+    throw new SyntaxError(ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
+  }
+  return ts.createSourceFile("realtime.ts", source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+}
+function stripRealtimeServerHandlers(source) {
+  const sourceFile = parseRealtimeSource(source);
+  const transformer = (context) => (root) => {
+    const visit = (node) => {
+      if (ts.isPropertyAssignment(node) && (propertyName(node) === "handler" || propertyName(node) === "authorize")) {
+        return ts.factory.updatePropertyAssignment(node, node.name, ts.factory.createIdentifier("undefined"));
+      }
+      if (ts.isMethodDeclaration(node) && (propertyName(node) === "handler" || propertyName(node) === "authorize")) {
+        return ts.factory.createPropertyAssignment(node.name, ts.factory.createIdentifier("undefined"));
+      }
+      return ts.visitEachChild(node, visit, context);
+    };
+    return ts.visitNode(root, visit);
+  };
+  const result = ts.transform(sourceFile, [transformer]);
+  try {
+    return ts.createPrinter({ newLine: ts.NewLineKind.LineFeed }).printFile(result.transformed[0]);
+  } finally {
+    result.dispose();
+  }
+}
+function createRealtimeClientDefinitionModule(source, importTarget) {
+  return createRealtimeClientDefinitionTransform(source, importTarget).code;
+}
+function createRealtimeClientDefinitionTransform(source, importTarget) {
+  const sourceFile = parseRealtimeSource(source);
+  const definitions = collectDefinitions(sourceFile);
+  if (definitions.length === 0) {
+    const code = stripRealtimeServerHandlers(source);
+    const sourceLineCount = source.split("\n").length;
+    return Object.freeze({
+      code,
+      map: createSourceMap(source, code.split("\n").map((_, index) => Math.min(index, sourceLineCount - 1)))
+    });
+  }
+  const factories = [...new Set(definitions.map((definition) => definition.factory))];
+  const outputLines = [
+    `import { ${factories.join(", ")} } from '${importTarget}'`,
+    ""
+  ];
+  const sourceLines = [void 0, void 0];
+  for (const definition of definitions) {
+    outputLines.push(`export const ${definition.exportedName} = ${definition.factory}({`);
+    sourceLines.push(definition.sourceLine);
+    if (definition.name) {
+      outputLines.push(`  name: ${definition.name},`);
+      sourceLines.push(definition.sourceLine);
+    }
+    outputLines.push("  handler: undefined,", "})", "");
+    sourceLines.push(definition.sourceLine, definition.sourceLine, void 0);
+  }
+  return Object.freeze({
+    code: outputLines.join("\n"),
+    map: createSourceMap(source, sourceLines)
+  });
+}
+export {
+  createRealtimeClientDefinitionModule,
+  createRealtimeClientDefinitionTransform,
+  isHoloHttpErrorStatus,
+  normalizeHoloHttpError,
+  renderClientHttpErrorPage,
+  stripRealtimeServerHandlers
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@holo-js/adapter-shared",
+  "version": "0.3.0",
+  "description": "Holo-JS Framework - shared framework adapter infrastructure",
+  "type": "module",
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "stub": "tsup",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest --run"
+  },
+  "dependencies": {
+    "@holo-js/kernel": "^0.3.0",
+    "typescript": "^5.7.2"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.5",
+    "vitest": "^4.1.5"
+  }
+}