@rebasepro/app 0.23.0 → 0.24.0

package/dist/util/index.d.ts

@@ -7,3 +7,4 @@ export * from "./previews.js";
 export * from "./enums.js";
 export * from "./constants.js";
 export * from "./local_storage.js";
+export * from "./realtime.js";

package/dist/util/realtime.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Whether an error is the realtime client saying the connection is down —
+ * not that the data is gone.
+ *
+ * Once the socket has been down for longer than a blip, the SDK tells every
+ * live subscription `CONNECTION_LOST` through its `onError`, once, and keeps
+ * the subscription: when the socket is back it is re-subscribed and its next
+ * update carries what changed meanwhile. A view that already shows data should
+ * keep showing it (the admin's connection banner says it may be stale) rather
+ * than replace it with an error — for an open record that would unmount the
+ * form and everything typed into it.
+ *
+ * Read by `code` rather than `instanceof RebaseApiError`: two copies of
+ * `@rebasepro/types` in one tree disagree about the class, never about the code.
+ *
+ * @group Hooks and utilities
+ */
+export declare function isConnectionLostError(error: unknown): boolean;

package/dist/vitePlugin.js

@@ -2,12 +2,114 @@ import path from "path";
 import ts from "typescript";
 import MagicString from "magic-string";
 const LAZY_COMPONENT_KEYS = /* @__PURE__ */ new Set(["Field", "Preview", "Builder", "Filter", "Component"]);
-function isInsideCallbacksBlock(node) {
-  const objectLiteral = node.parent;
-  if (!objectLiteral || !ts.isObjectLiteralExpression(objectLiteral)) return false;
-  const owner = objectLiteral.parent;
-  if (!owner || !ts.isPropertyAssignment(owner)) return false;
-  return getPropertyName(owner) === "callbacks";
+function unwrapObjectLiteral(expr) {
+  let current = expr;
+  while (ts.isParenthesizedExpression(current) || ts.isAsExpression(current) || ts.isSatisfiesExpression(current) || ts.isNonNullExpression(current)) {
+    current = current.expression;
+  }
+  return ts.isObjectLiteralExpression(current) ? current : void 0;
+}
+function callbackStripEdits(sourceFile) {
+  const edits = [];
+  const memberEdit = (member) => {
+    if (ts.isPropertyAssignment(member)) {
+      return { start: member.initializer.getStart(sourceFile), end: member.initializer.getEnd(), text: "undefined" };
+    }
+    if (ts.isSpreadAssignment(member)) {
+      return { start: member.getStart(sourceFile), end: member.getEnd(), text: "...undefined" };
+    }
+    const name = member.name;
+    return name ? { start: member.getStart(sourceFile), end: member.getEnd(), text: `${name.getText(sourceFile)}: undefined` } : void 0;
+  };
+  walkAST(sourceFile, (node) => {
+    if (ts.isShorthandPropertyAssignment(node) && node.name.text === "callbacks") {
+      edits.push({ start: node.getStart(sourceFile), end: node.getEnd(), text: "callbacks: undefined" });
+      return;
+    }
+    if (!ts.isPropertyAssignment(node) || getPropertyName(node) !== "callbacks") return;
+    const literal = unwrapObjectLiteral(node.initializer);
+    if (!literal) {
+      edits.push({ start: node.initializer.getStart(sourceFile), end: node.initializer.getEnd(), text: "undefined" });
+      return;
+    }
+    for (const member of literal.properties) {
+      const edit = memberEdit(member);
+      if (edit) edits.push(edit);
+    }
+  });
+  return edits.filter((edit) => !edits.some((outer) => outer !== edit && outer.start <= edit.start && edit.end <= outer.end));
+}
+function isReference(id) {
+  const parent = id.parent;
+  if (!parent) return false;
+  if (ts.isPropertyAccessExpression(parent) && parent.name === id) return false;
+  if (ts.isQualifiedName(parent) && parent.right === id) return false;
+  if ((ts.isPropertyAssignment(parent) || ts.isMethodDeclaration(parent) || ts.isPropertyDeclaration(parent) || ts.isPropertySignature(parent) || ts.isMethodSignature(parent) || ts.isGetAccessorDeclaration(parent) || ts.isSetAccessorDeclaration(parent) || ts.isEnumMember(parent) || ts.isJsxAttribute(parent)) && parent.name === id) return false;
+  if ((ts.isVariableDeclaration(parent) || ts.isFunctionDeclaration(parent) || ts.isClassDeclaration(parent) || ts.isParameter(parent) || ts.isImportClause(parent) || ts.isNamespaceImport(parent) || ts.isBindingElement(parent) || ts.isFunctionExpression(parent) || ts.isClassExpression(parent) || ts.isTypeAliasDeclaration(parent) || ts.isInterfaceDeclaration(parent) || ts.isTypeParameterDeclaration(parent)) && parent.name === id) return false;
+  if (ts.isBindingElement(parent) && parent.propertyName === id) return false;
+  if (ts.isImportSpecifier(parent)) return false;
+  if (ts.isLabeledStatement(parent) || ts.isBreakOrContinueStatement(parent)) return false;
+  return true;
+}
+function deadTopLevelStatements(sourceFile, removed) {
+  const bindings = [];
+  for (const statement of sourceFile.statements) {
+    const exported = ts.canHaveModifiers(statement) && (ts.getModifiers(statement) ?? []).some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+    if (exported) continue;
+    if (ts.isImportDeclaration(statement)) {
+      const clause = statement.importClause;
+      if (!clause || clause.isTypeOnly) continue;
+      const names = [];
+      if (clause.name) names.push(clause.name.text);
+      const named = clause.namedBindings;
+      if (named && ts.isNamespaceImport(named)) names.push(named.name.text);
+      if (named && ts.isNamedImports(named)) {
+        for (const el of named.elements) if (!el.isTypeOnly) names.push(el.name.text);
+      }
+      if (names.length > 0) bindings.push({ statement, names });
+    } else if (ts.isVariableStatement(statement)) {
+      const names = [];
+      const collect = (name) => {
+        if (ts.isIdentifier(name)) names.push(name.text);
+        else for (const el of name.elements) if (!ts.isOmittedExpression(el)) collect(el.name);
+      };
+      for (const decl of statement.declarationList.declarations) collect(decl.name);
+      bindings.push({ statement, names });
+    } else if ((ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) && statement.name) {
+      bindings.push({ statement, names: [statement.name.text] });
+    }
+  }
+  if (bindings.length === 0) return [];
+  const references = [];
+  walkAST(sourceFile, (node) => {
+    if (ts.isIdentifier(node) && isReference(node)) references.push(node);
+  });
+  const ranges = removed.map(({ start, end }) => ({ start, end }));
+  const within = (node) => {
+    const at = node.getStart(sourceFile);
+    return ranges.some((r) => r.start <= at && node.getEnd() <= r.end);
+  };
+  const dead = [];
+  for (let changed = true; changed; ) {
+    changed = false;
+    for (const binding of bindings) {
+      if (dead.includes(binding.statement)) continue;
+      let readByStripped = false;
+      let readLive = false;
+      for (const ref of references) {
+        if (!binding.names.includes(ref.text)) continue;
+        if (ref.getStart(sourceFile) >= binding.statement.getStart(sourceFile) && ref.getEnd() <= binding.statement.getEnd()) continue;
+        if (within(ref)) readByStripped = true;
+        else readLive = true;
+      }
+      if (readByStripped && !readLive) {
+        dead.push(binding.statement);
+        ranges.push({ start: binding.statement.getStart(sourceFile), end: binding.statement.getEnd() });
+        changed = true;
+      }
+    }
+  }
+  return dead;
 }
 function walkAST(node, visitor) {
   visitor(node);
@@ -30,15 +132,22 @@ function transformCollectionSource(code, id) {
   );
   const ms = new MagicString(code);
   let replaced = false;
+  const strips = callbackStripEdits(sourceFile);
+  for (const edit of strips) {
+    ms.overwrite(edit.start, edit.end, edit.text);
+    replaced = true;
+  }
+  const gone = [...strips];
+  for (const statement of deadTopLevelStatements(sourceFile, strips)) {
+    ms.remove(statement.getStart(sourceFile), statement.getEnd());
+    gone.push({ start: statement.getStart(sourceFile), end: statement.getEnd() });
+    replaced = true;
+  }
+  const stripped = (node) => gone.some((e) => e.start <= node.getStart(sourceFile) && node.getEnd() <= e.end);
   walkAST(sourceFile, (node) => {
     if (!ts.isPropertyAssignment(node)) return;
+    if (stripped(node)) return;
     const name = getPropertyName(node);
-    if (name && isInsideCallbacksBlock(node)) {
-      const value = node.initializer;
-      ms.overwrite(value.getStart(sourceFile), value.getEnd(), "undefined");
-      replaced = true;
-      return;
-    }
     const propName = name;
     if (!propName || !LAZY_COMPONENT_KEYS.has(propName)) return;
     const init = node.initializer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rebasepro/app",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "description": "Rebase core — framework-agnostic runtime for data-driven admin panels",
   "keywords": [
     "rebase",
@@ -63,12 +63,12 @@
     "magic-string": "^0.30.0",
     "notistack": "^3.0.2",
     "react-i18next": "^17.0.11",
-    "@rebasepro/cms-types": "0.23.0",
-    "@rebasepro/types": "0.23.0",
-    "@rebasepro/common": "0.23.0",
-    "@rebasepro/ui": "0.23.0",
-    "@rebasepro/forms": "0.23.0",
-    "@rebasepro/utils": "0.23.0"
+    "@rebasepro/cms-types": "0.24.0",
+    "@rebasepro/common": "0.24.0",
+    "@rebasepro/types": "0.24.0",
+    "@rebasepro/ui": "0.24.0",
+    "@rebasepro/utils": "0.24.0",
+    "@rebasepro/forms": "0.24.0"
   },
   "peerDependencies": {
     "react": "^19.2.7",