@gooddata/sdk-model 11.62.0-alpha.2 → 11.62.0-alpha.4

package/esm/publisher/v2/structure.js

@@ -0,0 +1,533 @@
+// (C) 2026 GoodData Corporation
+import { isDateFilterGranularity } from "../../dateFilterConfig/index.js";
+import { arrayOf, describeValue, finiteNumber, id, isFiniteNumber, isLength, isNonEmptyString, isPlainObject, joinPath, nonEmptyString, numberIn, objRef, objectOf, oneOf, opacity, optional, positive, px, required, satisfying, trueOrFalse, } from "./checks.js";
+import { PublisherPageSizesV2 } from "./page.js";
+import { PublisherTextStyleNamesV2, } from "./style.js";
+const themeName = "[A-Za-z0-9_-]+";
+const hexColor = /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+const rgbColor = /^rgb\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d+(?:\.\d+)?|\.\d+)\s*)?\)$/;
+const themeColor = new RegExp(`^\\{theme\\.(?:colors\\.(?:backgrounds|texts|lines)\\.${themeName}|palette\\.(?:primary|success|error|warning))\\}$`);
+function isColor(value) {
+    if (!isNonEmptyString(value)) {
+        return false;
+    }
+    if (hexColor.test(value) || themeColor.test(value)) {
+        return true;
+    }
+    const rgb = rgbColor.exec(value);
+    if (rgb === null) {
+        return false;
+    }
+    const [, red, green, blue, alpha] = rgb;
+    return ([red, green, blue].every((channel) => Number(channel) <= 255) &&
+        (alpha === undefined || Number(alpha) <= 1));
+}
+const color = satisfying(isColor, "a theme color reference, #rgb, #rrggbb, #rrggbbaa, or rgb() with 3 or 4 arguments");
+const themeImage = new RegExp(`^\\{theme\\.(?:logo|coverImage|assets\\.(?:logos|images)\\.${themeName})\\}$`);
+const themeShadow = new RegExp(`^\\{theme\\.shadows\\.${themeName}\\}$`);
+const httpsUrl = /^https:\/\/\S+$/;
+const imageSource = satisfying((value) => isNonEmptyString(value) && (themeImage.test(value) || httpsUrl.test(value)), "a theme image reference or an https URL");
+const shadowValue = satisfying((value) => value === "none" || (isNonEmptyString(value) && themeShadow.test(value)), `"none" or a {theme.shadows.<name>} reference`);
+function themeStep(group, steps) {
+    const refs = steps.map((step) => `{theme.${group}.${step}}`);
+    return satisfying((value) => isLength(value) || refs.some((ref) => ref === value), `a length of 0 or more, or one of ${refs.join(", ")}`);
+}
+const gap = themeStep("spacing.gap", ["compact", "normal", "spacious"]);
+const padding = themeStep("spacing.padding", ["compact", "normal", "spacious"]);
+const radius = themeStep("corners", ["small", "medium", "large", "full"]);
+const horizontalAlign = oneOf(["left", "center", "right"]);
+const verticalAlign = oneOf(["top", "center", "bottom"]);
+const borderLineStyle = oneOf(["solid", "dashed", "dotted", "none"]);
+const backgroundKeys = {
+    backgroundColor: optional(color),
+    backgroundOpacity: optional(opacity),
+    backgroundImage: optional(imageSource),
+    backgroundImageOpacity: optional(opacity),
+    backgroundFit: optional(oneOf(["cover", "contain", "fill", "tile"])),
+    backgroundHorizontalAlign: optional(horizontalAlign),
+    backgroundVerticalAlign: optional(verticalAlign),
+    backgroundOffset: optional(px),
+    backgroundOffsetTop: optional(px),
+    backgroundOffsetRight: optional(px),
+    backgroundOffsetBottom: optional(px),
+    backgroundOffsetLeft: optional(px),
+};
+const paddingKeys = {
+    padding: optional(padding),
+    paddingTop: optional(padding),
+    paddingRight: optional(padding),
+    paddingBottom: optional(padding),
+    paddingLeft: optional(padding),
+};
+const borderKeys = {
+    borderWidth: optional(px),
+    borderStyle: optional(borderLineStyle),
+    borderColor: optional(color),
+    borderTopWidth: optional(px),
+    borderTopStyle: optional(borderLineStyle),
+    borderTopColor: optional(color),
+    borderRightWidth: optional(px),
+    borderRightStyle: optional(borderLineStyle),
+    borderRightColor: optional(color),
+    borderBottomWidth: optional(px),
+    borderBottomStyle: optional(borderLineStyle),
+    borderBottomColor: optional(color),
+    borderLeftWidth: optional(px),
+    borderLeftStyle: optional(borderLineStyle),
+    borderLeftColor: optional(color),
+};
+const cornerKeys = {
+    borderRadius: optional(radius),
+    borderTopLeftRadius: optional(radius),
+    borderTopRightRadius: optional(radius),
+    borderBottomRightRadius: optional(radius),
+    borderBottomLeftRadius: optional(radius),
+};
+const shadowKeys = {
+    shadow: optional(shadowValue),
+    shadowX: optional(finiteNumber),
+    shadowY: optional(finiteNumber),
+    shadowBlur: optional(px),
+    shadowSpread: optional(finiteNumber),
+    shadowColor: optional(color),
+    shadowOpacity: optional(opacity),
+};
+const boxKeys = {
+    ...backgroundKeys,
+    ...paddingKeys,
+    ...borderKeys,
+    ...cornerKeys,
+    ...shadowKeys,
+    opacity: optional(opacity),
+};
+const inheritedTextKeys = {
+    textStyle: optional(oneOf(PublisherTextStyleNamesV2)),
+    textColor: optional(color),
+    horizontalAlign: optional(oneOf(["left", "center", "right", "justify"])),
+    verticalAlign: optional(verticalAlign),
+};
+const textKeys = {
+    ...inheritedTextKeys,
+    fontSize: optional(px),
+    fontWeight: optional(numberIn(1, 1000)),
+    fontStyle: optional(oneOf(["normal", "italic"])),
+    lineHeight: optional(finiteNumber),
+    letterSpacing: optional(finiteNumber),
+    textTransform: optional(oneOf(["none", "uppercase", "lowercase", "capitalize"])),
+    textOverflow: optional(oneOf(["shrink", "clip", "ellipsis"])),
+};
+const pageStyle = objectOf()({
+    ...backgroundKeys,
+    ...paddingKeys,
+    ...inheritedTextKeys,
+    gap: optional(gap),
+});
+const containerStyle = objectOf()({
+    ...boxKeys,
+    ...inheritedTextKeys,
+    gap: optional(gap),
+});
+const textStyle = objectOf()(textKeys);
+const textWidgetStyle = objectOf()({ ...boxKeys, ...textKeys });
+const imageWidgetStyle = objectOf()({
+    ...boxKeys,
+    fit: optional(oneOf(["contain", "cover", "fill"])),
+    horizontalAlign: optional(horizontalAlign),
+    verticalAlign: optional(verticalAlign),
+});
+const chartStyle = objectOf()({
+    fontSize: optional(px),
+    textColor: optional(color),
+    axisLineColor: optional(color),
+    axisNameColor: optional(color),
+    axisNameSize: optional(px),
+    axisValueColor: optional(color),
+    axisValueSize: optional(px),
+    gridColor: optional(color),
+    plotLineColor: optional(color),
+    legendColor: optional(color),
+    legendSize: optional(px),
+    dataLabelColor: optional(color),
+    dataLabelSize: optional(px),
+});
+const tableStyle = objectOf()({
+    fontSize: optional(px),
+    rowHeight: optional(px),
+    gridColor: optional(color),
+    valueColor: optional(color),
+    nullValueColor: optional(color),
+    headerLabelColor: optional(color),
+    headerBackgroundColor: optional(color),
+    totalValueColor: optional(color),
+    totalBackgroundColor: optional(color),
+    subtotalBackgroundColor: optional(color),
+});
+const headlineStyle = objectOf()({
+    primaryValueColor: optional(color),
+    primaryValueSize: optional(px),
+    secondaryValueColor: optional(color),
+    secondaryValueSize: optional(px),
+    positiveColor: optional(color),
+    negativeColor: optional(color),
+});
+const visualizationStyle = objectOf()({
+    ...boxKeys,
+    chart: optional(chartStyle),
+    table: optional(tableStyle),
+    headline: optional(headlineStyle),
+});
+const plainObject = satisfying(isPlainObject, "an object");
+const objRefs = arrayOf(objRef);
+const plainObjects = arrayOf(plainObject);
+const attributeFilterSourceKeys = {
+    displayForm: required(objRef),
+    localIdentifier: optional(id),
+    title: optional(nonEmptyString),
+    filterElementsBy: optional(plainObjects),
+    filterElementsByDate: optional(plainObjects),
+    validateElementsBy: optional(objRefs),
+};
+const filterVariants = {
+    attributeFilter: objectOf()({
+        attributeFilter: required(objectOf()({
+            ...attributeFilterSourceKeys,
+            negativeSelection: required(trueOrFalse),
+            attributeElements: required(plainObject),
+            selectionMode: optional(oneOf(["single", "multi"])),
+        })),
+    }),
+    arbitraryAttributeFilter: objectOf()({
+        arbitraryAttributeFilter: required(objectOf()({
+            ...attributeFilterSourceKeys,
+            values: required(arrayOf(satisfying((value) => value === null || typeof value === "string", "a value"))),
+            negativeSelection: required(trueOrFalse),
+        })),
+    }),
+    matchAttributeFilter: objectOf()({
+        matchAttributeFilter: required(objectOf()({
+            displayForm: required(objRef),
+            operator: required(oneOf(["contains", "startsWith", "endsWith"])),
+            literal: required(nonEmptyString),
+            caseSensitive: optional(trueOrFalse),
+            negativeSelection: optional(trueOrFalse),
+            localIdentifier: optional(id),
+            title: optional(nonEmptyString),
+        })),
+    }),
+    dateFilter: objectOf()({
+        dateFilter: required(objectOf()({
+            type: required(oneOf(["relative", "absolute"])),
+            granularity: required(satisfying(isDateFilterGranularity, "a date filter granularity")),
+            from: optional(satisfying((value) => isNonEmptyString(value) || isFiniteNumber(value), "a date or an offset")),
+            to: optional(satisfying((value) => isNonEmptyString(value) || isFiniteNumber(value), "a date or an offset")),
+            dataSet: optional(objRef),
+            attribute: optional(objRef),
+            localIdentifier: optional(id),
+            boundedFilter: optional(plainObject),
+            emptyValueHandling: optional(oneOf(["include", "exclude", "only"])),
+        })),
+    }),
+    dashboardMeasureValueFilter: objectOf()({
+        dashboardMeasureValueFilter: required(objectOf()({
+            measure: required(objRef),
+            localIdentifier: required(id),
+            conditions: optional(plainObjects),
+            dimensionality: optional(objRefs),
+            title: optional(nonEmptyString),
+        })),
+    }),
+};
+function filterItem(value, path, issues) {
+    const variant = isPlainObject(value)
+        ? Object.keys(filterVariants).find((key) => Object.hasOwn(value, key))
+        : undefined;
+    if (variant === undefined) {
+        issues.push({ path, message: `Expected a dashboard filter, got ${describeValue(value)}.` });
+        return;
+    }
+    filterVariants[variant](value, path, issues);
+}
+const filters = arrayOf(filterItem);
+const filterReferenceVariants = {
+    attributeFilterReference: objectOf()({
+        type: required(oneOf(["attributeFilterReference"])),
+        displayForm: required(objRef),
+    }),
+    dateFilterReference: objectOf()({
+        type: required(oneOf(["dateFilterReference"])),
+        dataSet: required(objRef),
+    }),
+    measureValueFilterReference: objectOf()({
+        type: required(oneOf(["measureValueFilterReference"])),
+        measure: required(objRef),
+    }),
+};
+function filterReference(value, path, issues) {
+    const type = isPlainObject(value) ? value["type"] : undefined;
+    if (typeof type === "string" && Object.hasOwn(filterReferenceVariants, type)) {
+        filterReferenceVariants[type](value, path, issues);
+    }
+    else {
+        issues.push({ path, message: `Expected a dashboard filter reference, got ${describeValue(value)}.` });
+    }
+}
+const attributeFilterConfig = objectOf()({
+    localIdentifier: required(id),
+    mode: optional(oneOf(["readonly", "hidden", "active"])),
+    displayAsLabel: optional(objRef),
+    selectionType: optional(oneOf(["list", "text", "listOrText"])),
+});
+const placeholder = objectOf()({
+    hint: optional(nonEmptyString),
+    required: optional(trueOrFalse),
+});
+const widgetKeys = {
+    id: required(id),
+    proportion: optional(positive),
+    placeholder: optional(placeholder),
+    locked: optional(trueOrFalse),
+};
+const widgetTitle = objectOf()({
+    visible: optional(trueOrFalse),
+    text: optional(nonEmptyString),
+    style: optional(textStyle),
+});
+const visibility = objectOf()({ visible: optional(trueOrFalse) });
+const autoVisibility = objectOf()({
+    visible: optional(oneOf([true, false, "auto"])),
+});
+const axisDisplay = objectOf()({
+    visible: optional(trueOrFalse),
+    name: optional(objectOf()({
+        visible: optional(trueOrFalse),
+        position: optional(oneOf(["low", "middle", "high"])),
+    })),
+    values: optional(objectOf()({
+        visible: optional(trueOrFalse),
+        rotation: optional(numberIn(-90, 90)),
+    })),
+    min: optional(finiteNumber),
+    max: optional(finiteNumber),
+});
+const visualizationDisplay = objectOf()({
+    legend: optional(objectOf()({
+        visible: optional(trueOrFalse),
+        position: optional(oneOf(["auto", "top", "bottom", "left", "right"])),
+    })),
+    xAxis: optional(axisDisplay),
+    yAxis: optional(axisDisplay),
+    secondaryYAxis: optional(axisDisplay),
+    gridlines: optional(visibility),
+    dataLabels: optional(autoVisibility),
+    dataPoints: optional(autoVisibility),
+});
+const takeawayGeneration = objectOf()({
+    instructions: optional(nonEmptyString),
+    context: optional(objectOf()({
+        widgets: optional(arrayOf(id)),
+        pageTitle: optional(trueOrFalse),
+        filters: optional(trueOrFalse),
+        otherPages: optional(trueOrFalse),
+    })),
+});
+const widgets = {
+    title: objectOf()({
+        ...widgetKeys,
+        type: required(oneOf(["title"])),
+        markdown: optional(nonEmptyString),
+        style: optional(textWidgetStyle),
+    }),
+    heading: objectOf()({
+        ...widgetKeys,
+        type: required(oneOf(["heading"])),
+        markdown: optional(nonEmptyString),
+        level: optional(oneOf([1, 2, 3, 4, 5, 6])),
+        style: optional(textWidgetStyle),
+    }),
+    text: objectOf()({
+        ...widgetKeys,
+        type: required(oneOf(["text"])),
+        markdown: optional(nonEmptyString),
+        decorative: optional(trueOrFalse),
+        style: optional(textWidgetStyle),
+    }),
+    image: objectOf()({
+        ...widgetKeys,
+        type: required(oneOf(["image"])),
+        source: optional(imageSource),
+        altText: optional(nonEmptyString),
+        decorative: optional(trueOrFalse),
+        style: optional(imageWidgetStyle),
+    }),
+    visualization: objectOf()({
+        ...widgetKeys,
+        type: required(oneOf(["visualization"])),
+        visualization: optional(objectOf()({
+            identifier: required(nonEmptyString),
+            type: required(oneOf(["insight"])),
+        })),
+        title: optional(widgetTitle),
+        altText: optional(nonEmptyString),
+        dateDataSet: optional(objectOf()({
+            identifier: required(nonEmptyString),
+            type: required(oneOf(["dataSet"])),
+        })),
+        ignoreDocumentPeriod: optional(trueOrFalse),
+        filters: optional(filters),
+        ignoreDocumentFilters: optional(arrayOf(filterReference)),
+        display: optional(visualizationDisplay),
+        style: optional(visualizationStyle),
+    }),
+    takeaway: objectOf()({
+        ...widgetKeys,
+        type: required(oneOf(["takeaway"])),
+        title: optional(widgetTitle),
+        markdown: optional(nonEmptyString),
+        generation: optional(takeawayGeneration),
+        style: optional(textWidgetStyle),
+    }),
+};
+const container = objectOf()({
+    type: required(oneOf(["row", "column"])),
+    id: optional(id),
+    children: required(arrayOf(layoutNode)),
+    proportion: optional(positive),
+    locked: optional(trueOrFalse),
+    style: optional(containerStyle),
+});
+function layoutNode(value, path, issues) {
+    const type = isPlainObject(value) ? value["type"] : undefined;
+    if (type === "row" || type === "column") {
+        container(value, path, issues);
+    }
+    else if (typeof type === "string" && Object.hasOwn(widgets, type)) {
+        widgets[type](value, path, issues);
+    }
+    else if (isPlainObject(value)) {
+        issues.push({ path: joinPath(path, "type"), message: `Unknown node type ${describeValue(type)}.` });
+    }
+    else {
+        issues.push({ path, message: `Expected a layout node, got ${describeValue(value)}.` });
+    }
+}
+const pageBodyKeys = {
+    kind: optional(oneOf(["cover", "section", "content"])),
+    pageSize: optional(oneOf(PublisherPageSizesV2)),
+    notes: optional(nonEmptyString),
+    style: optional(pageStyle),
+    layout: required(layoutNode),
+    filters: optional(filters),
+};
+export const checkPageBody = objectOf()(pageBodyKeys);
+const documentPage = objectOf()({
+    ...pageBodyKeys,
+    id: required(id),
+    visible: optional(trueOrFalse),
+});
+function isCalendarDate(value) {
+    const parts = isNonEmptyString(value) ? /^(\d{4})-(\d{2})-(\d{2})$/.exec(value) : null;
+    if (parts === null) {
+        return false;
+    }
+    const [year, month, day] = parts.slice(1).map(Number);
+    const date = new Date(0);
+    date.setUTCFullYear(year, month - 1, day);
+    return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}
+const date = satisfying(isCalendarDate, "a date as YYYY-MM-DD");
+const periodVariants = {
+    absolute: objectOf()({
+        type: required(oneOf(["absolute"])),
+        granularity: required(oneOf(["GDC.time.date"])),
+        from: required(date),
+        to: required(date),
+    }),
+    relative: objectOf()({
+        type: required(oneOf(["relative"])),
+        granularity: required(satisfying(isDateFilterGranularity, "a date filter granularity")),
+        from: required(satisfying(Number.isInteger, "an integer")),
+        to: required(satisfying(Number.isInteger, "an integer")),
+    }),
+};
+function period(value, path, issues) {
+    if (!isPlainObject(value)) {
+        issues.push({ path, message: `Expected a period, got ${describeValue(value)}.` });
+        return;
+    }
+    const { type } = value;
+    if (type === "absolute" || type === "relative") {
+        periodVariants[type](value, path, issues);
+    }
+    else {
+        issues.push({
+            path: joinPath(path, "type"),
+            message: `Expected "absolute" or "relative", got ${describeValue(type)}.`,
+        });
+    }
+}
+const defaults = objectOf()({
+    pageSize: optional(oneOf(PublisherPageSizesV2)),
+    takeaway: optional(objectOf()({
+        generation: optional(takeawayGeneration),
+    })),
+    period: optional(period),
+});
+const section = objectOf()({
+    id: required(id),
+    title: optional(nonEmptyString),
+    description: optional(nonEmptyString),
+    pages: required(arrayOf(documentPage)),
+});
+export const checkDocumentContent = objectOf()({
+    defaults: optional(defaults),
+    filters: optional(filters),
+    attributeFilterConfigs: optional(arrayOf(attributeFilterConfig)),
+    style: optional(objectOf()({ ...backgroundKeys, gap: optional(gap) })),
+    locale: optional(nonEmptyString),
+    formatLocale: optional(nonEmptyString),
+    pages: optional(arrayOf(documentPage)),
+    sections: optional(arrayOf(section)),
+});
+const entityKeys = {
+    ref: optional(objRef),
+    title: required(nonEmptyString),
+    description: optional(nonEmptyString),
+    tags: optional(arrayOf(nonEmptyString)),
+    version: required(oneOf(["2"])),
+    created: optional(nonEmptyString),
+    updated: optional(nonEmptyString),
+    createdBy: optional(satisfying(isPlainObject, "a user")),
+    updatedBy: optional(satisfying(isPlainObject, "a user")),
+    isLocked: optional(trueOrFalse),
+};
+const entities = {
+    document: objectOf()({
+        ...entityKeys,
+        type: required(oneOf(["document"])),
+        period: required(period),
+        content: required(checkDocumentContent),
+    }),
+    documentTemplate: objectOf()({
+        ...entityKeys,
+        type: required(oneOf(["documentTemplate"])),
+        content: required(checkDocumentContent),
+    }),
+    pageTemplate: objectOf()({
+        ...entityKeys,
+        type: required(oneOf(["pageTemplate"])),
+        content: required(checkPageBody),
+        isDefault: optional(trueOrFalse),
+    }),
+};
+export function checkEntity(value, path, issues) {
+    const type = isPlainObject(value) ? value["type"] : undefined;
+    if (type === "document" || type === "documentTemplate" || type === "pageTemplate") {
+        entities[type](value, path, issues);
+    }
+    else {
+        issues.push({
+            path: joinPath(path, "type"),
+            message: `Expected "document", "documentTemplate" or "pageTemplate", got ${describeValue(type)}.`,
+        });
+    }
+}