@olenbetong/appframe-core 2.14.0 → 2.15.1

package/es/filter/index.d.ts

@@ -4,5 +4,5 @@ export { toFieldMetadata, toFieldMetadataList, toFilterFieldType, type ViewField
 export { getDefaultOperator, getDynamicValueLabel, getDynamicValuesForField, getOperatorArity, getOperatorLabel, getOperatorsForField, getValueType, normalizeOperator, type OperatorArity, RELATIVE_DATE_VALUES, } from "./operators.js";
 export { coerceToStandardLayout, isStandardLayout } from "./standardLayout.js";
 export { canDeleteSavedFilter, canEditSavedFilter, canRenameSavedFilter, canSetCrossDomain, canShareSavedFilter, findSavedFilter, NO_FILTER_ID, partitionSavedFilters, type SavedFilter, type SavedFilterRecord, toSavedFilter, toSavedFilters, } from "./savedFilters.js";
-export { addGroupAtPath, changeOperator, countExpressions, createEmptyFilter, createEmptyGroup, createExpression, type FilterNode, type FilterPath, getNodeAtPath, insertNodeAtPath, isCompleteExpression, isEmptyFilter, isExpression, isGroup, pruneFilter, removeNodeAtPath, setGroupMode, toFilterTree, updateNodeAtPath, } from "./tree.js";
+export { addGroupAtPath, changeOperator, countExpressions, createEmptyFilter, createEmptyGroup, createExpression, type FilterNode, type FilterPath, getNodeAtPath, insertNodeAtPath, isCompleteExpression, isEmptyFilter, isExpression, isGroup, pruneFilter, removeNodeAtPath, setGroupMode, toFilterTree, unwrapSingleAndGroup, updateNodeAtPath, } from "./tree.js";
 export type { DynamicValue, FieldMetadata, FilterAccessLevel, FilterExpression, FilterFieldType, FilterGroup, FilterOperator, FilterTree, FilterValueType, } from "./types.js";

package/es/filter/index.js

@@ -4,4 +4,4 @@ export { toFieldMetadata, toFieldMetadataList, toFilterFieldType } from "./field
 export { getDefaultOperator, getDynamicValueLabel, getDynamicValuesForField, getOperatorArity, getOperatorLabel, getOperatorsForField, getValueType, normalizeOperator, RELATIVE_DATE_VALUES, } from "./operators.js";
 export { coerceToStandardLayout, isStandardLayout } from "./standardLayout.js";
 export { canDeleteSavedFilter, canEditSavedFilter, canRenameSavedFilter, canSetCrossDomain, canShareSavedFilter, findSavedFilter, NO_FILTER_ID, partitionSavedFilters, toSavedFilter, toSavedFilters, } from "./savedFilters.js";
-export { addGroupAtPath, changeOperator, countExpressions, createEmptyFilter, createEmptyGroup, createExpression, getNodeAtPath, insertNodeAtPath, isCompleteExpression, isEmptyFilter, isExpression, isGroup, pruneFilter, removeNodeAtPath, setGroupMode, toFilterTree, updateNodeAtPath, } from "./tree.js";
+export { addGroupAtPath, changeOperator, countExpressions, createEmptyFilter, createEmptyGroup, createExpression, getNodeAtPath, insertNodeAtPath, isCompleteExpression, isEmptyFilter, isExpression, isGroup, pruneFilter, removeNodeAtPath, setGroupMode, toFilterTree, unwrapSingleAndGroup, updateNodeAtPath, } from "./tree.js";

package/es/filter/tree.d.ts

@@ -24,6 +24,15 @@ export declare function isExpression(item: FilterNode): item is FilterExpression
  * becomes the default layout.
  */
 export declare function toFilterTree(filter: FilterNode | null | undefined): FilterTree;
+/**
+ * Returns the `and` group alone when it is the only item of an `or` group.
+ *
+ * The server parses filter strings into the standard layout, which wraps even
+ * a plain list of conditions in an `or` group of one `and` group. That extra
+ * level means nothing, so the builder shows the `and` group on its own, as the
+ * Windows filter editor does.
+ */
+export declare function unwrapSingleAndGroup(filter: FilterTree): FilterTree;
 /**
  * True when the filter contains no expressions. An empty filter must not be
  * saved or applied.

package/es/filter/tree.js

@@ -26,6 +26,20 @@ export function toFilterTree(filter) {
         return { type: "group", mode: "and", items: [filter] };
     return filter;
 }
+/**
+ * Returns the `and` group alone when it is the only item of an `or` group.
+ *
+ * The server parses filter strings into the standard layout, which wraps even
+ * a plain list of conditions in an `or` group of one `and` group. That extra
+ * level means nothing, so the builder shows the `and` group on its own, as the
+ * Windows filter editor does.
+ */
+export function unwrapSingleAndGroup(filter) {
+    if (filter.mode !== "or" || filter.items.length !== 1)
+        return filter;
+    let [only] = filter.items;
+    return isGroup(only) && only.mode === "and" ? only : filter;
+}
 /**
  * True when the filter contains no expressions. An empty filter must not be
  * saved or applied.

package/es/filter/tree.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "vitest";
-import { addGroupAtPath, changeOperator, countExpressions, createEmptyFilter, createExpression, getNodeAtPath, insertNodeAtPath, isCompleteExpression, isEmptyFilter, pruneFilter, removeNodeAtPath, setGroupMode, toFilterTree, updateNodeAtPath, } from "./tree.js";
+import { addGroupAtPath, changeOperator, countExpressions, createEmptyFilter, createExpression, getNodeAtPath, insertNodeAtPath, isCompleteExpression, isEmptyFilter, pruneFilter, removeNodeAtPath, setGroupMode, toFilterTree, unwrapSingleAndGroup, updateNodeAtPath, } from "./tree.js";
 function expression(column, operator = "equals", value = "x") {
     return { type: "expression", column, operator, value, valueType: "string" };
 }
@@ -182,3 +182,25 @@ describe("path helpers", () => {
         expect(countExpressions(filter)).toBe(0);
     });
 });
+describe("unwrapSingleAndGroup", () => {
+    test("returns the and group when it is the only item of an or group", () => {
+        let inner = group("and", expression("A"), expression("B"));
+        expect(unwrapSingleAndGroup(group("or", inner))).toBe(inner);
+    });
+    test("keeps an or group with several items", () => {
+        let filter = group("or", group("and", expression("A")), group("and", expression("B")));
+        expect(unwrapSingleAndGroup(filter)).toBe(filter);
+    });
+    test("keeps an or group holding a single expression", () => {
+        let filter = group("or", expression("A"));
+        expect(unwrapSingleAndGroup(filter)).toBe(filter);
+    });
+    test("keeps an or group holding a single or group", () => {
+        let filter = group("or", group("or", expression("A"), expression("B")));
+        expect(unwrapSingleAndGroup(filter)).toBe(filter);
+    });
+    test("keeps an and group as it is", () => {
+        let filter = group("and", expression("A"));
+        expect(unwrapSingleAndGroup(filter)).toBe(filter);
+    });
+});

package/es/index.js

@@ -19,4 +19,4 @@ export { UserSession };
 export { alert, ConfirmButtons, confirm, openAlertDialog, waitForDialog } from "./alert.js";
 export { getSettings, saveSettings } from "./settings.js";
 // oxlint-disable-next-line no-use-before-define -- this is injected build time
-export const version = "2.14.0";
+export const version = "2.15.1";

package/es/report/render.js

@@ -151,11 +151,15 @@ export async function openReport(options) {
     // The route serves some formats as types a browser downloads rather than
     // displays; the format's own media type is what decides how it opens.
     let url = URL.createObjectURL(blob.type ? blob : new Blob([blob], { type: getReportMediaType(options.format) }));
-    let opened = globalThis.open(url, "_blank", "noopener");
+    // Not opened with the `noopener` feature: `open` then returns null even when
+    // the tab opens, which read as a blocked pop-up and revoked the URL before
+    // the tab could load it. The opener is cut off by hand instead.
+    let opened = globalThis.open(url, "_blank");
     if (!opened) {
         URL.revokeObjectURL(url);
         throw new Error("The report could not be opened. Allow pop-ups for this site and try again.");
     }
+    opened.opener = null;
     // Revoking immediately would cancel the load in some browsers, and never
     // revoking keeps the whole rendered report in memory.
     globalThis.setTimeout(() => URL.revokeObjectURL(url), 60_000);

package/es/report/render.test.js

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { fetchParameterDefault, resolveParameterDefaults } from "./parameterDefaults.js";
-import { getReportExtension, getReportFileName, getReportRequest, printReport, renderReport, } from "./render.js";
+import { getReportExtension, getReportFileName, getReportRequest, openReport, printReport, renderReport, } from "./render.js";
 function options(overrides = {}) {
     return { format: "PDF", reportId: "arpt_Test_Report", timezone: 2, ...overrides };
 }
@@ -100,7 +100,31 @@ describe("printReport", () => {
         vi.stubGlobal("fetch", vi.fn().mockResolvedValue(new Response("%PDF-", { headers: { "Content-Type": "application/pdf" } })));
         vi.stubGlobal("open", openMock);
         await printReport(options());
-        expect(openMock).toHaveBeenCalledWith(expect.stringContaining("blob:"), "_blank", "noopener");
+        expect(openMock).toHaveBeenCalledWith(expect.stringContaining("blob:"), "_blank");
+    });
+});
+describe("openReport", () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    function stubRender() {
+        vi.stubGlobal("fetch", vi.fn().mockResolvedValue(new Response("%PDF-", { headers: { "Content-Type": "application/pdf" } })));
+    }
+    it("keeps the file available to the tab it opened, and cuts the tab off from the opener", async () => {
+        let tab = { opener: {} };
+        let revoke = vi.spyOn(URL, "revokeObjectURL");
+        stubRender();
+        vi.stubGlobal("open", vi.fn().mockReturnValue(tab));
+        await openReport(options());
+        expect(revoke).not.toHaveBeenCalled();
+        expect(tab.opener).toBeNull();
+    });
+    it("reports a blocked pop-up and releases the file", async () => {
+        let revoke = vi.spyOn(URL, "revokeObjectURL");
+        stubRender();
+        vi.stubGlobal("open", vi.fn().mockReturnValue(null));
+        await expect(openReport(options())).rejects.toThrow("Allow pop-ups");
+        expect(revoke).toHaveBeenCalled();
     });
 });
 describe("fetchParameterDefault", () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olenbetong/appframe-core",
-  "version": "2.14.0",
+  "version": "2.15.1",
   "description": "Javascript libraries to utilize the Appframe framework",
   "type": "module",
   "sideEffects": [

package/src/filter/index.ts

@@ -47,6 +47,7 @@ export {
 	removeNodeAtPath,
 	setGroupMode,
 	toFilterTree,
+	unwrapSingleAndGroup,
 	updateNodeAtPath,
 } from "./tree.js";
 export type {

package/src/filter/tree.test.ts

@@ -15,6 +15,7 @@ import {
 	removeNodeAtPath,
 	setGroupMode,
 	toFilterTree,
+	unwrapSingleAndGroup,
 	updateNodeAtPath,
 } from "./tree.js";
 
@@ -256,3 +257,35 @@ describe("path helpers", () => {
 		expect(countExpressions(filter)).toBe(0);
 	});
 });
+
+describe("unwrapSingleAndGroup", () => {
+	test("returns the and group when it is the only item of an or group", () => {
+		let inner = group("and", expression("A"), expression("B"));
+
+		expect(unwrapSingleAndGroup(group("or", inner))).toBe(inner);
+	});
+
+	test("keeps an or group with several items", () => {
+		let filter = group("or", group("and", expression("A")), group("and", expression("B")));
+
+		expect(unwrapSingleAndGroup(filter)).toBe(filter);
+	});
+
+	test("keeps an or group holding a single expression", () => {
+		let filter = group("or", expression("A"));
+
+		expect(unwrapSingleAndGroup(filter)).toBe(filter);
+	});
+
+	test("keeps an or group holding a single or group", () => {
+		let filter = group("or", group("or", expression("A"), expression("B")));
+
+		expect(unwrapSingleAndGroup(filter)).toBe(filter);
+	});
+
+	test("keeps an and group as it is", () => {
+		let filter = group("and", expression("A"));
+
+		expect(unwrapSingleAndGroup(filter)).toBe(filter);
+	});
+});

package/src/filter/tree.ts

@@ -46,6 +46,22 @@ export function toFilterTree(filter: FilterNode | null | undefined): FilterTree
 	return filter;
 }
 
+/**
+ * Returns the `and` group alone when it is the only item of an `or` group.
+ *
+ * The server parses filter strings into the standard layout, which wraps even
+ * a plain list of conditions in an `or` group of one `and` group. That extra
+ * level means nothing, so the builder shows the `and` group on its own, as the
+ * Windows filter editor does.
+ */
+export function unwrapSingleAndGroup(filter: FilterTree): FilterTree {
+	if (filter.mode !== "or" || filter.items.length !== 1) return filter;
+
+	let [only] = filter.items;
+
+	return isGroup(only) && only.mode === "and" ? only : filter;
+}
+
 /**
  * True when the filter contains no expressions. An empty filter must not be
  * saved or applied.

package/src/report/render.test.ts

@@ -5,6 +5,7 @@ import {
 	getReportExtension,
 	getReportFileName,
 	getReportRequest,
+	openReport,
 	printReport,
 	type ReportRenderOptions,
 	renderReport,
@@ -145,7 +146,41 @@ describe("printReport", () => {
 
 		await printReport(options());
 
-		expect(openMock).toHaveBeenCalledWith(expect.stringContaining("blob:"), "_blank", "noopener");
+		expect(openMock).toHaveBeenCalledWith(expect.stringContaining("blob:"), "_blank");
+	});
+});
+
+describe("openReport", () => {
+	afterEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	function stubRender() {
+		vi.stubGlobal(
+			"fetch",
+			vi.fn().mockResolvedValue(new Response("%PDF-", { headers: { "Content-Type": "application/pdf" } })),
+		);
+	}
+
+	it("keeps the file available to the tab it opened, and cuts the tab off from the opener", async () => {
+		let tab = { opener: {} as unknown };
+		let revoke = vi.spyOn(URL, "revokeObjectURL");
+		stubRender();
+		vi.stubGlobal("open", vi.fn().mockReturnValue(tab));
+
+		await openReport(options());
+
+		expect(revoke).not.toHaveBeenCalled();
+		expect(tab.opener).toBeNull();
+	});
+
+	it("reports a blocked pop-up and releases the file", async () => {
+		let revoke = vi.spyOn(URL, "revokeObjectURL");
+		stubRender();
+		vi.stubGlobal("open", vi.fn().mockReturnValue(null));
+
+		await expect(openReport(options())).rejects.toThrow("Allow pop-ups");
+		expect(revoke).toHaveBeenCalled();
 	});
 });
 

package/src/report/render.ts

@@ -193,13 +193,18 @@ export async function openReport(options: ReportRenderOptions): Promise<void> {
 	// The route serves some formats as types a browser downloads rather than
 	// displays; the format's own media type is what decides how it opens.
 	let url = URL.createObjectURL(blob.type ? blob : new Blob([blob], { type: getReportMediaType(options.format) }));
-	let opened = globalThis.open(url, "_blank", "noopener");
+	// Not opened with the `noopener` feature: `open` then returns null even when
+	// the tab opens, which read as a blocked pop-up and revoked the URL before
+	// the tab could load it. The opener is cut off by hand instead.
+	let opened = globalThis.open(url, "_blank");
 
 	if (!opened) {
 		URL.revokeObjectURL(url);
 		throw new Error("The report could not be opened. Allow pop-ups for this site and try again.");
 	}
 
+	opened.opener = null;
+
 	// Revoking immediately would cancel the load in some browsers, and never
 	// revoking keeps the whole rendered report in memory.
 	globalThis.setTimeout(() => URL.revokeObjectURL(url), 60_000);