@pipedream/google_slides 0.4.0 → 0.6.0

package/actions/position-element/position-element.mjs

@@ -0,0 +1,219 @@
+import { ConfigurationError } from "@pipedream/platform";
+import googleSlides from "../../google_slides.app.mjs";
+import {
+  EMU, EMU_PER_POINT, POINTS, Z_ORDER_OPERATIONS,
+} from "../../common/constants.mjs";
+
+export default {
+  key: "google_slides-position-element",
+  name: "Position Element",
+  description: "Move, scale, rotate, or restack a page element in a Google Slides presentation. Unspecified properties keep their current values. Use **Get Presentation** to find the element's object ID. [See the documentation](https://developers.google.com/workspace/slides/api/reference/rest/v1/presentations/request#UpdatePageElementTransformRequest)",
+  version: "0.0.1",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: false,
+  },
+  type: "action",
+  props: {
+    googleSlides,
+    presentationId: {
+      propDefinition: [
+        googleSlides,
+        "staticPresentationId",
+      ],
+    },
+    objectId: {
+      propDefinition: [
+        googleSlides,
+        "pageElementId",
+      ],
+    },
+    translateX: {
+      type: "integer",
+      label: "X Position",
+      description: "Horizontal position in points, measured from the top-left of the slide.",
+      optional: true,
+    },
+    translateY: {
+      type: "integer",
+      label: "Y Position",
+      description: "Vertical position in points, measured from the top-left of the slide.",
+      optional: true,
+    },
+    scaleXPercent: {
+      type: "integer",
+      label: "Horizontal Scale",
+      description: "Horizontal scale as a percentage of the element's intrinsic size (100 = unscaled). Range 1-1000.",
+      min: 1,
+      max: 1000,
+      optional: true,
+    },
+    scaleYPercent: {
+      type: "integer",
+      label: "Vertical Scale",
+      description: "Vertical scale as a percentage of the element's intrinsic size (100 = unscaled). Range 1-1000.",
+      min: 1,
+      max: 1000,
+      optional: true,
+    },
+    rotation: {
+      type: "integer",
+      label: "Rotation",
+      description: "Clockwise rotation in degrees (-360 to 360).",
+      min: -360,
+      max: 360,
+      optional: true,
+    },
+    zOrderOperation: {
+      type: "string",
+      label: "Z-Order",
+      description: "Restack the element relative to the other elements on its slide.",
+      options: Z_ORDER_OPERATIONS,
+      optional: true,
+    },
+  },
+  async run({ $ }) {
+    const {
+      googleSlides,
+      presentationId,
+      objectId,
+      translateX,
+      translateY,
+      scaleXPercent,
+      scaleYPercent,
+      rotation,
+      zOrderOperation,
+    } = this;
+
+    const movesElement = [
+      translateX,
+      translateY,
+      scaleXPercent,
+      scaleYPercent,
+      rotation,
+    ].some((value) => value != null);
+
+    if (!movesElement && !zOrderOperation) {
+      throw new ConfigurationError("Provide at least one of X Position, Y Position, Horizontal Scale, Vertical Scale, Rotation, or Z-Order.");
+    }
+
+    const id = googleSlides.getPresentationId(presentationId);
+    const requests = [];
+
+    const {
+      element, groupId,
+    } = await googleSlides.getPageElement(id, objectId);
+
+    // A grouped child's transform is relative to its group, so the slide-space
+    // X/Y props would not mean what they say, and the API rejects grouped IDs
+    // for z-order outright.
+    if (groupId) {
+      throw new ConfigurationError(`Page element "${objectId}" is inside group "${groupId}". Its position is relative to that group, and z-order cannot target a grouped element. Target the group itself, or ungroup it first.`);
+    }
+
+    if (movesElement) {
+      const current = element.transform || {};
+      const unit = current.unit || POINTS;
+      const toUnit = (points) => (unit === EMU
+        ? points * EMU_PER_POINT
+        : points);
+
+      // A move alone leaves the matrix untouched. When scale or rotation is
+      // set, the matrix is decomposed so that reflection (carried by the signed
+      // scaleY) and shear survive the rebuild.
+      let matrix = {
+        scaleX: current.scaleX ?? 1,
+        scaleY: current.scaleY ?? 1,
+        shearX: current.shearX ?? 0,
+        shearY: current.shearY ?? 0,
+      };
+
+      if (scaleXPercent != null || scaleYPercent != null || rotation != null) {
+        // Factor any reflection onto the axis that already carries it before
+        // decomposing, so changing the rotation cannot move a horizontal flip
+        // onto the vertical axis and leave the element 180 degrees out.
+        const determinant = (matrix.scaleX * matrix.scaleY) - (matrix.shearY * matrix.shearX);
+        const flipX = determinant < 0 && matrix.scaleX < 0
+          ? -1
+          : 1;
+        const flipY = determinant < 0 && flipX === 1
+          ? -1
+          : 1;
+
+        const columnX = matrix.scaleX * flipX;
+        const columnXShear = matrix.shearY * flipX;
+        const columnY = matrix.shearX * flipY;
+        const columnYScale = matrix.scaleY * flipY;
+
+        const currentAngle = Math.atan2(columnXShear, columnX);
+        const cos = Math.cos(currentAngle);
+        const sin = Math.sin(currentAngle);
+
+        const currentScaleX = Math.hypot(columnX, columnXShear) || 1;
+        const shear = (columnY * cos) + (columnYScale * sin);
+        const currentScaleY = (columnYScale * cos) - (columnY * sin);
+
+        const scaleX = scaleXPercent != null
+          ? scaleXPercent / 100
+          : currentScaleX;
+        const scaleY = scaleYPercent != null
+          ? (scaleYPercent / 100) * (currentScaleY < 0
+            ? -1
+            : 1)
+          : currentScaleY;
+        const angle = rotation != null
+          ? rotation * Math.PI / 180
+          : currentAngle;
+
+        const newCos = Math.cos(angle);
+        const newSin = Math.sin(angle);
+
+        matrix = {
+          scaleX: scaleX * newCos * flipX,
+          shearY: scaleX * newSin * flipX,
+          shearX: ((shear * newCos) - (scaleY * newSin)) * flipY,
+          scaleY: ((shear * newSin) + (scaleY * newCos)) * flipY,
+        };
+      }
+
+      requests.push({
+        updatePageElementTransform: {
+          objectId,
+          applyMode: "ABSOLUTE",
+          transform: {
+            ...matrix,
+            translateX: translateX != null
+              ? toUnit(translateX)
+              : current.translateX ?? 0,
+            translateY: translateY != null
+              ? toUnit(translateY)
+              : current.translateY ?? 0,
+            unit,
+          },
+        },
+      });
+    }
+
+    if (zOrderOperation) {
+      requests.push({
+        updatePageElementsZOrder: {
+          pageElementObjectIds: [
+            objectId,
+          ],
+          operation: zOrderOperation,
+        },
+      });
+    }
+
+    await googleSlides.batchUpdate(id, requests);
+
+    $.export("$summary", `Repositioned element ${objectId}`);
+
+    return {
+      presentationId,
+      objectId,
+      requestsApplied: requests.map((request) => Object.keys(request)[0]),
+    };
+  },
+};

package/actions/refresh-chart/refresh-chart.mjs

@@ -4,7 +4,7 @@ export default {
   key: "google_slides-refresh-chart",
   name: "Refresh a chart",
   description: "Refresh a chart from Sheets. [See the docs here](https://developers.google.com/slides/api/samples/elements#refresh_a_chart_from_sheets)",
-  version: "0.0.7",
+  version: "0.0.9",
   annotations: {
     destructiveHint: false,
     openWorldHint: true,

package/actions/replace-all-text/replace-all-text.mjs

@@ -4,7 +4,7 @@ export default {
   key: "google_slides-replace-all-text",
   name: "Replace All Text",
   description: "Replace all text in a presentation. [See the documentation](https://developers.google.com/workspace/slides/api/reference/rest/v1/presentations/request#ReplaceAllTextRequest)",
-  version: "0.0.3",
+  version: "0.0.5",
   annotations: {
     destructiveHint: true,
     openWorldHint: true,

package/common/constants.mjs

@@ -141,3 +141,113 @@ export const SHAPE_TYPES = [
   "ELLIPSE_RIBBON_2",
   "CLOUD_CALLOUT",
 ];
+
+// Enum values used by the styling requests, checked against the current API
+// reference. https://developers.google.com/workspace/slides/api/reference/rest/v1/presentations/request
+
+export const ALIGNMENTS = [
+  "START",
+  "CENTER",
+  "END",
+  "JUSTIFIED",
+];
+
+export const CONTENT_ALIGNMENTS = [
+  "TOP",
+  "MIDDLE",
+  "BOTTOM",
+];
+
+export const DASH_STYLES = [
+  "SOLID",
+  "DOT",
+  "DASH",
+  "DASH_DOT",
+  "LONG_DASH",
+  "LONG_DASH_DOT",
+];
+
+export const Z_ORDER_OPERATIONS = [
+  "BRING_TO_FRONT",
+  "BRING_FORWARD",
+  "SEND_BACKWARD",
+  "SEND_TO_BACK",
+];
+
+// Theme colors resolve against the deck's own ColorScheme, so a caller can style
+// with the presentation's palette instead of hardcoding hex values.
+export const THEME_COLORS = [
+  "DARK1",
+  "LIGHT1",
+  "DARK2",
+  "LIGHT2",
+  "ACCENT1",
+  "ACCENT2",
+  "ACCENT3",
+  "ACCENT4",
+  "ACCENT5",
+  "ACCENT6",
+  "HYPERLINK",
+  "FOLLOWED_HYPERLINK",
+  "TEXT1",
+  "BACKGROUND1",
+  "TEXT2",
+  "BACKGROUND2",
+];
+
+// Dimension.unit - points, rather than the API's other unit (EMU).
+export const POINTS = "PT";
+export const EMU = "EMU";
+
+// 1 inch = 72 pt = 914400 EMU. A transform carries a single unit for all six
+// matrix elements, so caller-supplied points must be converted into whatever
+// unit the element already uses rather than mixed in.
+export const EMU_PER_POINT = 12700;
+
+// Range.type. The API expresses the three range shapes as distinct types rather
+// than as optional bounds, and rejects FIXED_RANGE that carries no end index.
+export const TEXT_RANGE_ALL = "ALL";
+export const TEXT_RANGE_FROM_START_INDEX = "FROM_START_INDEX";
+export const TEXT_RANGE_FIXED_RANGE = "FIXED_RANGE";
+
+// BulletGlyphPreset. NOTE: these are NOT the same spellings the Google Docs API
+// uses - Slides says DIGIT where Docs says DECIMAL - so they cannot be shared
+// with the google_docs connector.
+export const BULLET_PRESETS = [
+  "BULLET_DISC_CIRCLE_SQUARE",
+  "BULLET_DIAMONDX_ARROW3D_SQUARE",
+  "BULLET_CHECKBOX",
+  "BULLET_ARROW_DIAMOND_DISC",
+  "BULLET_STAR_CIRCLE_SQUARE",
+  "BULLET_ARROW3D_CIRCLE_SQUARE",
+  "BULLET_LEFTTRIANGLE_DIAMOND_DISC",
+  "BULLET_DIAMONDX_HOLLOWDIAMOND_SQUARE",
+  "BULLET_DIAMOND_CIRCLE_SQUARE",
+  "NUMBERED_DIGIT_ALPHA_ROMAN",
+  "NUMBERED_DIGIT_ALPHA_ROMAN_PARENS",
+  "NUMBERED_DIGIT_NESTED",
+  "NUMBERED_UPPERALPHA_ALPHA_ROMAN",
+  "NUMBERED_UPPERROMAN_UPPERALPHA_DIGIT",
+  "NUMBERED_ZERODIGIT_ALPHA_ROMAN",
+];
+
+// Sentinel for the Bullets prop meaning "strip existing bullets".
+export const BULLETS_NONE = "NONE";
+
+export const BASELINE_OFFSETS = [
+  "NONE",
+  "SUPERSCRIPT",
+  "SUBSCRIPT",
+];
+
+export const TEXT_DIRECTIONS = [
+  "LEFT_TO_RIGHT",
+  "RIGHT_TO_LEFT",
+];
+
+export const SPACING_MODES = [
+  "NEVER_COLLAPSE",
+  "COLLAPSE_LISTS",
+];
+
+export const OPACITY_SCALE = 100;

package/common/utils.mjs

@@ -0,0 +1,115 @@
+import { ConfigurationError } from "@pipedream/platform";
+import {
+  TEXT_RANGE_ALL,
+  TEXT_RANGE_FIXED_RANGE,
+  OPACITY_SCALE,
+  POINTS,
+  TEXT_RANGE_FROM_START_INDEX,
+  THEME_COLORS,
+} from "./constants.mjs";
+
+function toOpaqueColor(value) {
+  const trimmed = String(value).trim();
+  const themeColor = trimmed.toUpperCase();
+  if (THEME_COLORS.includes(themeColor)) {
+    return {
+      themeColor,
+    };
+  }
+
+  const hex = trimmed.replace(/^#/, "");
+  if (!/^[0-9a-fA-F]{6}$/.test(hex)) {
+    return null;
+  }
+  const channel = (start) => parseInt(hex.slice(start, start + 2), 16) / 255;
+  return {
+    rgbColor: {
+      red: channel(0),
+      green: channel(2),
+      blue: channel(4),
+    },
+  };
+}
+
+function toSolidFill(value, opacityPercent) {
+  const color = value == null || value === ""
+    ? null
+    : toOpaqueColor(value);
+  if (value && !color) {
+    return null;
+  }
+  const fill = {};
+  if (color) {
+    fill.color = color;
+  }
+  if (opacityPercent != null) {
+    fill.alpha = opacityPercent / OPACITY_SCALE;
+  }
+  return Object.keys(fill).length
+    ? fill
+    : null;
+}
+
+function buildTextRange(startIndex, endIndex) {
+  if (startIndex == null && endIndex == null) {
+    return {
+      type: TEXT_RANGE_ALL,
+    };
+  }
+  if (startIndex == null) {
+    throw new ConfigurationError("End Index needs a Start Index. Provide both to style a fixed span, Start Index on its own to style from there to the end, or neither to style all of the text.");
+  }
+  if (endIndex == null) {
+    return {
+      type: TEXT_RANGE_FROM_START_INDEX,
+      startIndex,
+    };
+  }
+  if (endIndex <= startIndex) {
+    throw new ConfigurationError(`End Index (${endIndex}) must be greater than Start Index (${startIndex}).`);
+  }
+  return {
+    type: TEXT_RANGE_FIXED_RANGE,
+    startIndex,
+    endIndex,
+  };
+}
+
+function styleBuilder() {
+  const style = {};
+  const fields = [];
+
+  return {
+    style,
+    fields,
+    set(name, value) {
+      if (value == null) {
+        return;
+      }
+      style[name] = value;
+      fields.push(name);
+    },
+    setDimension(name, magnitude, unit = POINTS) {
+      if (magnitude == null) {
+        return;
+      }
+      this.set(name, {
+        magnitude,
+        unit,
+      });
+    },
+    get isEmpty() {
+      return !fields.length;
+    },
+    get mask() {
+      return fields.join(",");
+    },
+  };
+}
+
+export default {
+  styleBuilder,
+  toOpaqueColor,
+  toSolidFill,
+  buildTextRange,
+};

package/google_slides.app.mjs

@@ -1,5 +1,7 @@
+import { ConfigurationError } from "@pipedream/platform";
 import slides from "@googleapis/slides";
 import googleDrive from "@pipedream/google_drive";
+import { CONTENT_ALIGNMENTS } from "./common/constants.mjs";
 
 export default {
   ...googleDrive,
@@ -19,6 +21,72 @@ export default {
         return this.listPresentationsOptions(driveId, nextPageToken);
       },
     },
+    staticPresentationId: {
+      type: "string",
+      label: "Presentation ID",
+      description: "The ID of the presentation. This is the long string in the URL: `https://docs.google.com/presentation/d/{PRESENTATION_ID}/edit`. A full presentation URL is also accepted. Use **Find Presentation** to resolve a name to its ID.",
+    },
+    staticSlideId: {
+      type: "string",
+      label: "Slide ID",
+      description: "The object ID of the slide (e.g. `p1` or `g1a2b3c4d5`). Use **Get Presentation** and read `slides[].objectId`.",
+    },
+    pageElementId: {
+      type: "string",
+      label: "Page Element ID",
+      description: "The object ID of the shape, image, table, or other page element to act on. Use **Get Presentation** and read `slides[].pageElements[].objectId`.",
+    },
+    // Shared by the styling actions; individual actions override the label or
+    // description where their wording differs.
+    rowIndex: {
+      type: "integer",
+      label: "Row Index",
+      description: "The 0-based row of the target table cell.",
+      min: 0,
+      optional: true,
+    },
+    columnIndex: {
+      type: "integer",
+      label: "Column Index",
+      description: "The 0-based column of the target table cell.",
+      min: 0,
+      optional: true,
+    },
+    startIndex: {
+      type: "integer",
+      label: "Start Index",
+      description: "Character index to style from, inclusive. On its own, styles from here to the end of the text. Omit both indices to style all of it.",
+      min: 0,
+      optional: true,
+    },
+    endIndex: {
+      type: "integer",
+      label: "End Index",
+      description: "Character index to style up to, exclusive. Requires **Start Index**, and must be greater than it.",
+      min: 0,
+      optional: true,
+    },
+    backgroundColor: {
+      type: "string",
+      label: "Background Color",
+      description: "A hex code (e.g. `#EEEEEE`) or one of the deck's theme colors (e.g. `ACCENT1`).",
+      optional: true,
+    },
+    backgroundOpacity: {
+      type: "integer",
+      label: "Background Opacity",
+      description: "Opacity as a whole percentage, from `0` (fully transparent) to `100` (fully opaque). Can be set on its own to change an existing fill's opacity without restating its color.",
+      min: 0,
+      max: 100,
+      optional: true,
+    },
+    contentAlignment: {
+      type: "string",
+      label: "Content Alignment",
+      description: "Vertical alignment of the text within the element. One of `TOP`, `MIDDLE` or `BOTTOM` - e.g. `MIDDLE` to centre the text vertically.",
+      options: CONTENT_ALIGNMENTS,
+      optional: true,
+    },
     layoutId: {
       type: "string",
       label: "Layout ID",
@@ -251,13 +319,68 @@ export default {
       }
       return this.listFilesOptions(pageToken, request);
     },
-    async getPresentation(presentationId) {
+    getPresentationId(idOrUrl) {
+      const input = String(idOrUrl).trim();
+      if (!input) {
+        throw new ConfigurationError("Presentation ID is required.");
+      }
+      // Published presentations use /presentation/d/e/{token}/pub and have no
+      // editable ID that presentations.get accepts, so reject them explicitly
+      // rather than extracting the literal "e" segment as the ID.
+      if (/\/presentation\/d\/e\//.test(input)) {
+        throw new ConfigurationError("Published presentation URLs (`/presentation/d/e/...`) are not supported. Provide the presentation's ID or its editable URL (`https://docs.google.com/presentation/d/{ID}/edit`).");
+      }
+      // Accept a plain presentation ID or a full Slides URL
+      // (e.g. https://docs.google.com/presentation/d/{ID}/edit).
+      const match = input.match(/\/presentation\/d\/([a-zA-Z0-9-_]+)/);
+      return match
+        ? match[1]
+        : input;
+    },
+    async getPresentation(presentationId, fields) {
       const slides = this.slides();
       const request = {
         presentationId,
+        ...fields && {
+          fields,
+        },
       };
       return (await slides.presentations.get(request)).data;
     },
+    _findPageElement(presentation, objectId) {
+      const walk = (elements, slideId, groupId) => {
+        for (const element of elements || []) {
+          if (element.objectId === objectId) {
+            return {
+              element,
+              slideId,
+              groupId,
+            };
+          }
+          const found = walk(element.elementGroup?.children, slideId, element.objectId);
+          if (found) {
+            return found;
+          }
+        }
+        return null;
+      };
+
+      for (const slide of presentation.slides || []) {
+        const found = walk(slide.pageElements, slide.objectId);
+        if (found) {
+          return found;
+        }
+      }
+      return null;
+    },
+    async getPageElement(presentationId, objectId) {
+      const presentation = await this.getPresentation(presentationId);
+      const found = this._findPageElement(presentation, objectId);
+      if (!found) {
+        throw new ConfigurationError(`No page element with ID "${objectId}" was found in presentation ${presentationId}. Use Get Presentation to list slides[].pageElements[].objectId.`);
+      }
+      return found;
+    },
     async getSlide(presentationId, slideId) {
       const slides = this.slides();
       const request = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipedream/google_slides",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Pipedream Google Slides Components",
   "main": "google_slides.app.mjs",
   "keywords": [

package/sources/new-presentation/new-presentation.mjs

@@ -7,7 +7,7 @@ export default {
   type: "source",
   name: "New Presentation (Instant)",
   description: "Emit new event each time a new presentation is created in a drive.",
-  version: "0.0.5",
+  version: "0.0.7",
   hooks: {
     ...newFilesInstant.hooks,
     async deploy() {