@valbuild/shared 0.146.0 → 0.146.4

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # @valbuild/shared
 
+## 0.146.4
+
+### Patch Changes
+
+- [#870](https://github.com/valbuild/val/pull/870) [`81f2e80`](https://github.com/valbuild/val/commit/81f2e803c4cefdf58bbe6856c06e98ace95a8e0b) Thanks [@freekh](https://github.com/freekh)! - The canvas works on a page behind your site's own login.
+
+  A site with its own sign-in (a dashboard, an intranet, a members' area) can be edited in the canvas. The canvas is a frame on the same origin as the Studio, so it sends your site's cookies like any other tab: if you are signed in to the site, the canvas shows the page signed in as you.
+
+  If you were not signed in, the site redirected the canvas to its login page, and the canvas then broke. That page mounted Val's whole overlay inside the canvas, a Studio inside the Studio. The canvas stayed on "Preview is not ready yet" through the sign-in and after it, until you pressed Reload. Now a page shown in the Studio's canvas counts as the canvas wherever it navigated to, so you can sign in inside the canvas and keep editing.
+
+## 0.146.2
+
+### Patch Changes
+
+- [#871](https://github.com/valbuild/val/pull/871) [`e4913e1`](https://github.com/valbuild/val/commit/e4913e1f1178e09987a7c03fd540909ab4b499b0) Thanks [@freekh](https://github.com/freekh)! - An image, file or video picked from a gallery is checked against the gallery as it is now. Picking one uploaded since the site was built (still unpublished, saved in a proposal, or published without a rebuild) used to fail with "The gallery does not have an image at …" and refuse the save. In a proposal, Save now reads "Fix N" and goes to the validation errors instead of being refused by the server, as Publish does on the site.
+
+- [#867](https://github.com/valbuild/val/pull/867) [`04f81ba`](https://github.com/valbuild/val/commit/04f81baeee4a98054c0673ca9fdc34bc5cadacb9) Thanks [@freekh](https://github.com/freekh)! - When a publish breaks a page on a site with proposals, its changes are no longer
+  held back on the site: they move into a proposal of their own, with any later
+  changes to the same pages, so everyone else keeps publishing. The Studio says
+  so — "Publishing broke the site" — and offers **Open the proposal**, where the
+  changes can be fixed and published. Sites without proposals hold the changes
+  back as before.
+
+- [#867](https://github.com/valbuild/val/pull/867) [`04f81ba`](https://github.com/valbuild/val/commit/04f81baeee4a98054c0673ca9fdc34bc5cadacb9) Thanks [@freekh](https://github.com/freekh)! - Publish only some of your changes: tick them in Review and press **Publish
+  selected**. On a site with proposals, Val moves them into a proposal of their
+  own and publishes it straight away; everything else stays unpublished, as it
+  was.
+
+  Some changes cannot be published apart — two edits to the same list, say — so
+  the confirm says what comes with your selection and whose it is before anything
+  moves. If the site is published while yours is being prepared, nothing is
+  published and you are asked to press it again. If publishing stops after the
+  changes have moved, they are safe in their proposal, and Review offers to open
+  it as well as to try again.
+
+- Updated dependencies [[`e4913e1`](https://github.com/valbuild/val/commit/e4913e1f1178e09987a7c03fd540909ab4b499b0)]:
+  - @valbuild/core@0.146.2
+
 ## 0.146.0
 
 ### Minor Changes

package/client/dist/valbuild-shared-client.cjs.dev.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var getSitemapTree = require('../../dist/getSitemapTree-c732e09a.cjs.dev.js');
+var getSitemapTree = require('../../dist/getSitemapTree-95b00d3f.cjs.dev.js');
 require('@valbuild/core');
 
 

package/client/dist/valbuild-shared-client.cjs.prod.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var getSitemapTree = require('../../dist/getSitemapTree-0ed3deac.cjs.prod.js');
+var getSitemapTree = require('../../dist/getSitemapTree-b8dce0e2.cjs.prod.js');
 require('@valbuild/core');
 
 

package/client/dist/valbuild-shared-client.esm.js

@@ -1,2 +1,2 @@
-export { D as DEFAULT_CANVAS_SELECTION, e as DEFAULT_CANVAS_SELECTION_SOFT, b as VAL_AI_SESSION_STORAGE_KEY, d as VAL_CANVAS_MESSAGE, c as VAL_CANVAS_PARAM, V as VAL_CONFIG_SESSION_STORAGE_KEY, a as VAL_THEME_SESSION_STORAGE_KEY, h as getNextAppRouterSourceFolder, m as getPageRouterSitemapTree, k as getPageRouterSourceFolder, n as getPatternFromModuleFilePath, j as getTanStackRouterSourceFolder, l as isTanStackRoutesFolder, g as isValCanvasFrame, i as isValCanvasPageMessage, f as isValCanvasStudioMessage, p as parseRoutePattern, w as withValCanvasParam } from '../../dist/getSitemapTree-6fcdf745.esm.js';
+export { D as DEFAULT_CANVAS_SELECTION, e as DEFAULT_CANVAS_SELECTION_SOFT, b as VAL_AI_SESSION_STORAGE_KEY, d as VAL_CANVAS_MESSAGE, c as VAL_CANVAS_PARAM, V as VAL_CONFIG_SESSION_STORAGE_KEY, a as VAL_THEME_SESSION_STORAGE_KEY, h as getNextAppRouterSourceFolder, m as getPageRouterSitemapTree, k as getPageRouterSourceFolder, n as getPatternFromModuleFilePath, j as getTanStackRouterSourceFolder, l as isTanStackRoutesFolder, g as isValCanvasFrame, i as isValCanvasPageMessage, f as isValCanvasStudioMessage, p as parseRoutePattern, w as withValCanvasParam } from '../../dist/getSitemapTree-e65acefe.esm.js';
 import '@valbuild/core';

package/dist/declarations/src/internal/ApiRoutes.d.ts

@@ -1147,6 +1147,63 @@ export declare const Api: {
             }, z.core.$strip>]>;
         };
     };
+    /**
+     * Publish selected (`docs/plans/remove-patch-groups.md`, Phase 4), its first
+     * half, on the site's own server: the changes picked in Review, already
+     * closed into whole patch sets (`selectionClosure`), moved into a proposal
+     * of kind `publish` and saved there -- prepared over the site's head, which
+     * the proposal is based on, so a publish landing in between is refused
+     * rather than reverted. The second half is that proposal's Publish, pressed
+     * as any proposal's is (`publishProposal`); this server answers its checks
+     * and press with what the merge moves, as the proposal's own address would.
+     */
+    "/publish-selected": {
+        POST: {
+            req: {
+                body: z.ZodObject<{
+                    patchIds: z.ZodArray<z.ZodString & z.ZodType<PatchIdT, string, z.core.$ZodTypeInternals<PatchIdT, string>>>;
+                    displayName: z.ZodString;
+                    requestId: z.ZodString;
+                }, z.core.$strip>;
+                cookies: {
+                    val_session: z.ZodOptional<z.ZodString>;
+                };
+            };
+            res: z.ZodUnion<readonly [z.ZodObject<{
+                status: z.ZodLiteral<401>;
+                json: z.ZodObject<{
+                    message: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                status: z.ZodLiteral<400>;
+                json: z.ZodObject<{
+                    message: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                status: z.ZodLiteral<409>;
+                json: z.ZodObject<{
+                    message: z.ZodString;
+                    headMoved: z.ZodOptional<z.ZodLiteral<true>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                status: z.ZodLiteral<500>;
+                json: z.ZodObject<{
+                    message: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                status: z.ZodLiteral<502>;
+                json: z.ZodObject<{
+                    message: z.ZodString;
+                    proposal: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                status: z.ZodLiteral<200>;
+                json: z.ZodObject<{
+                    proposal: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>]>;
+        };
+    };
     "/save": {
         POST: {
             req: {

package/dist/declarations/src/internal/index.d.ts

@@ -38,5 +38,6 @@ export * from "./theme/accentRamp.js";
 export * from "./publish/contentApi.js";
 export * from "./publish/protocol.js";
 export * from "./patchSets/PatchSets.js";
+export * from "./patchSets/selectionClosure.js";
 export * from "./patchSets/schemaTypesOfPath.js";
 export * from "./proposalMerge/trees.js";

package/dist/declarations/src/internal/patchSets/selectionClosure.d.ts

@@ -0,0 +1,23 @@
+import type { PatchId } from "@valbuild/core";
+import type { SerializedPatchSet } from "./PatchSets.js";
+/**
+ * Patch sets that share a change become one: a change is never split.
+ *
+ * Shared by the two places that move changes between branches a whole set at
+ * a time -- the merge moving the site's conflicting pending changes
+ * (`changesToMove` in `@valbuild/server`) and Publish selected
+ * ({@link selectionClosure}) -- so that they agree on what "a whole set" is.
+ */
+export declare function joinSharedChanges(sets: PatchId[][]): Set<PatchId>[];
+/**
+ * What publishing `selected` publishes: every change in every patch set a
+ * selected change is in, sets that share a change joined
+ * (valbuild/val `docs/plans/remove-patch-groups.md`, Phase 4, rule 2).
+ *
+ * A patch set is changes that do not apply without each other, so a selection
+ * of part of one cannot be published on its own. What it pulls in is someone
+ * else's as often as not; the caller says whose, before anything moves.
+ *
+ * In the order of `patchIds` -- the chain's -- with nothing that is not in it.
+ */
+export declare function selectionClosure(patchSets: SerializedPatchSet, selected: Iterable<PatchId>, patchIds: readonly PatchId[]): PatchId[];

package/dist/declarations/src/internal/publish/contentApi.d.ts

@@ -431,6 +431,16 @@ export type PublishRequestStatus = {
     actions: ("try-again" | "discard" | "re-run-build")[];
     /** The job that failed: what Discard is pressed on. */
     job: string;
+    /**
+     * Where its changes went, on a project with proposals: off the site,
+     * into a proposal of their own, where they are fixed and published.
+     * `actions` is then empty -- that proposal's Publish is the Try again.
+     */
+    movedTo?: {
+        proposal: string;
+        displayName: string;
+        changes: number;
+    };
 } | {
     kind: "cancelled";
 } | {

package/dist/declarations/src/internal/resolveSchemaSourceFixes.d.ts

@@ -59,8 +59,9 @@ export declare const SCHEMA_SOURCE_FIXES: ValidationFix[];
 /** Whether an error is a marker only the whole project can answer. */
 export declare function isSchemaSourceFixError(error: ValidationError): boolean;
 /**
- * The record a `keyof:check-keys` error resolves against, or null for any other
- * error — including a malformed marker, which
+ * The record a `keyof:check-keys` error resolves against -- or a gallery
+ * marker's (`image:check-gallery` and the rest): its gallery module -- or null
+ * for any other error, including a malformed marker, which
  * {@link resolveSchemaSourceFixForError} reports and this has nothing to say
  * about.
  *

package/dist/declarations/src/internal/valCanvasProtocol.d.ts

@@ -261,12 +261,21 @@ export declare function isValCanvasPageMessage(data: unknown): data is ValCanvas
 /** Narrow an unknown `event.data` to a message from the studio. */
 export declare function isValCanvasStudioMessage(data: unknown): data is ValCanvasStudioMessage;
 /**
- * Whether this document was loaded as the studio's canvas frame.
+ * Whether this document is showing in the studio's canvas frame.
  *
- * Reads the location directly rather than taking it as an argument, because
- * every caller wants the answer for the document it is running in, and passing
- * it around is how one of them ends up asking about the wrong one.
+ * The parameter marks the document the studio LOADED, and that is not always
+ * the document the frame ends up holding. A frame navigates on its own: a site
+ * with a login of its own redirects a signed-out canvas to its sign-in page,
+ * and the sign-in sends it back to wherever the site chooses. Each of those is
+ * a new document without the parameter, and it used to render Val's whole
+ * overlay inside the canvas — a studio in the studio, which never told the
+ * canvas it was there, so the canvas never went live again until reloaded.
+ *
+ * So where the frame SITS answers too: a document whose parent is the studio
+ * is in the canvas, whatever its own address says. `parentPathname` is that
+ * parent's path: `null` for a top-level document, and for a parent on another
+ * origin, whose `location` cannot be read and which is not the studio anyway.
  */
-export declare function isValCanvasFrame(search: string): boolean;
+export declare function isValCanvasFrame(search: string, parentPathname?: string | null): boolean;
 /** Add the canvas marker to a page URL. */
 export declare function withValCanvasParam(url: string): string;

package/dist/{getSitemapTree-0ed3deac.cjs.prod.js → getSitemapTree-95b00d3f.cjs.dev.js}

@@ -121,13 +121,26 @@ function isValCanvasStudioMessage(data) {
 }
 
 /**
- * Whether this document was loaded as the studio's canvas frame.
+ * Whether this document is showing in the studio's canvas frame.
  *
- * Reads the location directly rather than taking it as an argument, because
- * every caller wants the answer for the document it is running in, and passing
- * it around is how one of them ends up asking about the wrong one.
+ * The parameter marks the document the studio LOADED, and that is not always
+ * the document the frame ends up holding. A frame navigates on its own: a site
+ * with a login of its own redirects a signed-out canvas to its sign-in page,
+ * and the sign-in sends it back to wherever the site chooses. Each of those is
+ * a new document without the parameter, and it used to render Val's whole
+ * overlay inside the canvas — a studio in the studio, which never told the
+ * canvas it was there, so the canvas never went live again until reloaded.
+ *
+ * So where the frame SITS answers too: a document whose parent is the studio
+ * is in the canvas, whatever its own address says. `parentPathname` is that
+ * parent's path: `null` for a top-level document, and for a parent on another
+ * origin, whose `location` cannot be read and which is not the studio anyway.
  */
 function isValCanvasFrame(search) {
+  var parentPathname = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  if (parentPathname !== null && isValStudioPathname(parentPathname)) {
+    return true;
+  }
   try {
     return new URLSearchParams(search).get(VAL_CANVAS_PARAM) !== null;
   } catch (_unused) {
@@ -135,6 +148,11 @@ function isValCanvasFrame(search) {
   }
 }
 
+/** Whether a path is the studio's own route, where the canvas lives. */
+function isValStudioPathname(pathname) {
+  return pathname === "/val" || pathname.startsWith("/val/");
+}
+
 /** Add the canvas marker to a page URL. */
 function withValCanvasParam(url) {
   var separator = url.includes("?") ? "&" : "?";

package/dist/{getSitemapTree-c732e09a.cjs.dev.js → getSitemapTree-b8dce0e2.cjs.prod.js}

@@ -121,13 +121,26 @@ function isValCanvasStudioMessage(data) {
 }
 
 /**
- * Whether this document was loaded as the studio's canvas frame.
+ * Whether this document is showing in the studio's canvas frame.
  *
- * Reads the location directly rather than taking it as an argument, because
- * every caller wants the answer for the document it is running in, and passing
- * it around is how one of them ends up asking about the wrong one.
+ * The parameter marks the document the studio LOADED, and that is not always
+ * the document the frame ends up holding. A frame navigates on its own: a site
+ * with a login of its own redirects a signed-out canvas to its sign-in page,
+ * and the sign-in sends it back to wherever the site chooses. Each of those is
+ * a new document without the parameter, and it used to render Val's whole
+ * overlay inside the canvas — a studio in the studio, which never told the
+ * canvas it was there, so the canvas never went live again until reloaded.
+ *
+ * So where the frame SITS answers too: a document whose parent is the studio
+ * is in the canvas, whatever its own address says. `parentPathname` is that
+ * parent's path: `null` for a top-level document, and for a parent on another
+ * origin, whose `location` cannot be read and which is not the studio anyway.
  */
 function isValCanvasFrame(search) {
+  var parentPathname = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  if (parentPathname !== null && isValStudioPathname(parentPathname)) {
+    return true;
+  }
   try {
     return new URLSearchParams(search).get(VAL_CANVAS_PARAM) !== null;
   } catch (_unused) {
@@ -135,6 +148,11 @@ function isValCanvasFrame(search) {
   }
 }
 
+/** Whether a path is the studio's own route, where the canvas lives. */
+function isValStudioPathname(pathname) {
+  return pathname === "/val" || pathname.startsWith("/val/");
+}
+
 /** Add the canvas marker to a page URL. */
 function withValCanvasParam(url) {
   var separator = url.includes("?") ? "&" : "?";

package/dist/{getSitemapTree-6fcdf745.esm.js → getSitemapTree-e65acefe.esm.js}

@@ -119,13 +119,26 @@ function isValCanvasStudioMessage(data) {
 }
 
 /**
- * Whether this document was loaded as the studio's canvas frame.
+ * Whether this document is showing in the studio's canvas frame.
  *
- * Reads the location directly rather than taking it as an argument, because
- * every caller wants the answer for the document it is running in, and passing
- * it around is how one of them ends up asking about the wrong one.
+ * The parameter marks the document the studio LOADED, and that is not always
+ * the document the frame ends up holding. A frame navigates on its own: a site
+ * with a login of its own redirects a signed-out canvas to its sign-in page,
+ * and the sign-in sends it back to wherever the site chooses. Each of those is
+ * a new document without the parameter, and it used to render Val's whole
+ * overlay inside the canvas — a studio in the studio, which never told the
+ * canvas it was there, so the canvas never went live again until reloaded.
+ *
+ * So where the frame SITS answers too: a document whose parent is the studio
+ * is in the canvas, whatever its own address says. `parentPathname` is that
+ * parent's path: `null` for a top-level document, and for a parent on another
+ * origin, whose `location` cannot be read and which is not the studio anyway.
  */
 function isValCanvasFrame(search) {
+  var parentPathname = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  if (parentPathname !== null && isValStudioPathname(parentPathname)) {
+    return true;
+  }
   try {
     return new URLSearchParams(search).get(VAL_CANVAS_PARAM) !== null;
   } catch (_unused) {
@@ -133,6 +146,11 @@ function isValCanvasFrame(search) {
   }
 }
 
+/** Whether a path is the studio's own route, where the canvas lives. */
+function isValStudioPathname(pathname) {
+  return pathname === "/val" || pathname.startsWith("/val/");
+}
+
 /** Add the canvas marker to a page URL. */
 function withValCanvasParam(url) {
   var separator = url.includes("?") ? "&" : "?";