Rename AggregateWithAlias to AliasedAggregate

Author: MarkDuckworth

packages/firestore/lite/pipelines/pipelines.ts

@@ -166,7 +166,7 @@ export {
   FunctionExpression,
   Ordering,
   ExpressionType,
-  AggregateWithAlias,
+  AliasedAggregate,
   Selectable,
   BooleanExpression,
   AggregateFunction

packages/firestore/src/api_pipelines.ts

@@ -180,7 +180,7 @@ export {
 
 export type {
   ExpressionType,
-  AggregateWithAlias,
+  AliasedAggregate,
   Selectable
 } from './lite-api/expressions';
 

packages/firestore/src/lite-api/expressions.ts

@@ -2260,11 +2260,11 @@ export class AggregateFunction implements ProtoValueSerializable, UserData {
    * ```
    *
    * @param name The alias to assign to this AggregateFunction.
-   * @return A new {@link AggregateWithAlias} that wraps this
+   * @return A new {@link AliasedAggregate} that wraps this
    *     AggregateFunction and associates it with the provided alias.
    */
-  as(name: string): AggregateWithAlias {
-    return new AggregateWithAlias(this, name, 'as');
+  as(name: string): AliasedAggregate {
+    return new AliasedAggregate(this, name, 'as');
   }
 
   /**
@@ -2301,7 +2301,7 @@ export class AggregateFunction implements ProtoValueSerializable, UserData {
  *
  * An AggregateFunction with alias.
  */
-export class AggregateWithAlias implements UserData {
+export class AliasedAggregate implements UserData {
   constructor(
     readonly aggregate: AggregateFunction,
     readonly alias: string,
@@ -7702,8 +7702,8 @@ export function isOrdering(val: unknown): val is Ordering {
   );
 }
 
-export function isAliasedAggregate(val: unknown): val is AggregateWithAlias {
-  const candidate = val as AggregateWithAlias;
+export function isAliasedAggregate(val: unknown): val is AliasedAggregate {
+  const candidate = val as AliasedAggregate;
   return (
     isString(candidate.alias) &&
     candidate.aggregate instanceof AggregateFunction

packages/firestore/src/lite-api/pipeline.ts

@@ -33,7 +33,7 @@ import { Firestore } from './database';
 import {
   _mapValue,
   AggregateFunction,
-  AggregateWithAlias,
+  AliasedAggregate,
   BooleanExpression,
   _constant,
   Expression,
@@ -735,7 +735,7 @@ export class Pipeline implements ProtoSerializable<ProtoPipeline> {
    * Performs aggregation operations on the documents from previous stages.
    *
    * <p>This stage allows you to calculate aggregate values over a set of documents. You define the
-   * aggregations to perform using {@link AggregateWithAlias} expressions which are typically results of
+   * aggregations to perform using {@link AliasedAggregate} expressions which are typically results of
    * calling {@link Expression#as} on {@link AggregateFunction} instances.
    *
    * <p>Example:
@@ -749,15 +749,15 @@ export class Pipeline implements ProtoSerializable<ProtoPipeline> {
    *     );
    * ```
    *
-   * @param accumulator The first {@link AggregateWithAlias}, wrapping an {@link AggregateFunction}
+   * @param accumulator The first {@link AliasedAggregate}, wrapping an {@link AggregateFunction}
    *     and providing a name for the accumulated results.
-   * @param additionalAccumulators Optional additional {@link AggregateWithAlias}, each wrapping an {@link AggregateFunction}
+   * @param additionalAccumulators Optional additional {@link AliasedAggregate}, each wrapping an {@link AggregateFunction}
    *     and providing a name for the accumulated results.
    * @return A new Pipeline object with this stage appended to the stage list.
    */
   aggregate(
-    accumulator: AggregateWithAlias,
-    ...additionalAccumulators: AggregateWithAlias[]
+    accumulator: AliasedAggregate,
+    ...additionalAccumulators: AliasedAggregate[]
   ): Pipeline;
   /**
    * Performs optionally grouped aggregation operations on the documents from previous stages.
@@ -771,7 +771,7 @@ export class Pipeline implements ProtoSerializable<ProtoPipeline> {
    *       If no grouping fields are provided, a single group containing all documents is used. Not
    *       specifying groups is the same as putting the entire inputs into one group.</li>
    *   <li>**Accumulators:** One or more accumulation operations to perform within each group. These
-   *       are defined using {@link AggregateWithAlias} expressions, which are typically created by
+   *       are defined using {@link AliasedAggregate} expressions, which are typically created by
    *       calling {@link Expression#as} on {@link AggregateFunction} instances. Each aggregation
    *       calculates a value (e.g., sum, average, count) based on the documents within its group.</li>
    * </ul>
@@ -793,14 +793,12 @@ export class Pipeline implements ProtoSerializable<ProtoPipeline> {
    */
   aggregate(options: AggregateStageOptions): Pipeline;
   aggregate(
-    targetOrOptions: AggregateWithAlias | AggregateStageOptions,
-    ...rest: AggregateWithAlias[]
+    targetOrOptions: AliasedAggregate | AggregateStageOptions,
+    ...rest: AliasedAggregate[]
   ): Pipeline {
     // Process argument union(s) from method overloads
     const options = isAliasedAggregate(targetOrOptions) ? {} : targetOrOptions;
-    const accumulators: AggregateWithAlias[] = isAliasedAggregate(
-      targetOrOptions
-    )
+    const accumulators: AliasedAggregate[] = isAliasedAggregate(targetOrOptions)
       ? [targetOrOptions, ...rest]
       : targetOrOptions.accumulators;
     const groups: Array<Selectable | string> = isAliasedAggregate(

packages/firestore/src/lite-api/stage_options.ts

@@ -1,7 +1,7 @@
 import { OneOf } from '../util/types';
 
 import {
-  AggregateWithAlias,
+  AliasedAggregate,
   BooleanExpression,
   Expression,
   Field,
@@ -168,7 +168,7 @@ export type AggregateStageOptions = StageOptions & {
    * The {@link AliasedAggregate} values specifying aggregate operations to
    * perform on the input documents.
    */
-  accumulators: AggregateWithAlias[];
+  accumulators: AliasedAggregate[];
   /**
    * The {@link Selectable} expressions or field names to consider when determining
    * distinct value combinations (groups), which will be aggregated over.

packages/firestore/src/util/pipeline_util.ts

@@ -2,7 +2,7 @@ import { vector } from '../api';
 import {
   _constant,
   AggregateFunction,
-  AggregateWithAlias,
+  AliasedAggregate,
   array,
   constant,
   Expression,
@@ -35,10 +35,10 @@ export function selectablesToMap(
 }
 
 export function aliasedAggregateToMap(
-  aliasedAggregatees: AggregateWithAlias[]
+  aliasedAggregatees: AliasedAggregate[]
 ): Map<string, AggregateFunction> {
   return aliasedAggregatees.reduce(
-    (map: Map<string, AggregateFunction>, selectable: AggregateWithAlias) => {
+    (map: Map<string, AggregateFunction>, selectable: AliasedAggregate) => {
       map.set(selectable.alias, selectable.aggregate as AggregateFunction);
       return map;
     },