@adobe/data 0.1.2 → 0.2.0

package/src/schema.test.ts

@@ -0,0 +1,55 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import { type FromSchema, type Schema } from "./schema/index.js";
+import { type Extends, type False, type True } from "./types/types.js";
+import { describe, it } from "vitest";
+
+describe("Schema", () => {
+  it("should provide compile time and runtime type validation", () => {
+    const mySchema = {
+      type: "object",
+      required: ["name", "aspect"],
+      properties: {
+        name: { type: "string" },
+        age: { type: "integer", minimum: 0 },
+        aspect: { enum: ["landscape", "portrait"] },
+      },
+      additionalProperties: false,
+    } as const satisfies Schema;
+    type MyType = FromSchema<typeof mySchema>;
+
+    //  compile time type checking.
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars -- compile time type check
+    type ShouldBeValid = True<
+      Extends<{ name: "foo"; aspect: "landscape" }, MyType>
+    >;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars -- compile time type check
+    type WrongAspect = False<Extends<{ name: "foo"; aspect: "wrong" }, MyType>>;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars -- compile time type check
+    type MissingAspect = False<Extends<{ name: "foo" }, MyType>>;
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars -- compile time type check
+    type ExtraPropertyCannotBeTypescriptTypeChecked = True<
+      Extends<{ name: "foo"; aspect: "landscape"; agewrong: 1 }, MyType>
+    >;
+  });
+});

package/src/service/add-observable-actions.ts

@@ -0,0 +1,207 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+
+import { Service } from './service.js';
+import { isService } from "./is-service.js";
+import { Observe, createObservableEvent } from '../observe/index.js';
+import { EquivalentTypes, Expand, IsVoid, NoNever, True } from '../types/index.js';
+import { isPromise } from '../internal/promise/is-promise.js';
+
+const NESTED_SERVICE_SEPARATOR = '_';
+
+// Type that extends a Service with an observable actions property
+export type WithObservableActions<T extends Service> = T & { actions: Observe<ServiceActionMessages<T>> };
+
+/**
+ * Returns true if this function return value is from an action function.
+ * Action functions are only allowed to return void, BUT some action function implementations
+ * may be async and return a Promise<void>. This is convenient for authoring and since
+ * no other service functions are allowed to return Promises then we will assume this is an action.
+ */
+function isActionReturnValue(result: unknown) {
+  return result === undefined || isPromise(result);
+}
+
+/**
+ * Intercepts actions on a service and notifies via a callback.
+ *
+ * This function creates a proxy around the given service object. It intercepts
+ * action calls and sends back action messages after each call.
+ * It also wraps any child services within their own namespaced interceptActions Proxy.
+ *
+ * @template T - The type of the service object.
+ * @param {T} service - The service object to be proxied.
+ * @param {string} prefix - A prefix to be added to action names for nested services.
+ * @param {(...args: unknown[]) => void} callback - A callback function to be called after an action is executed.
+ * @returns {T} - The proxied service object.
+ */
+function interceptActions<T extends object>(service: T, prefix: string, callback: (...args: unknown[]) => void): T {
+  const propertyCache = new Map<string | symbol, unknown>();
+  const serviceCache = new Map<string | symbol, Service>();
+
+  return new Proxy(service, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      const cached = propertyCache.get(prop);
+      if (cached) {
+        return cached;
+      }
+      let returnValue: unknown = value;
+      if (typeof prop === 'string') {
+        if (typeof value === 'function') {
+          returnValue = (...args: unknown[]) => {
+            // Call the original function with the same arguments
+            // the binding to the target as `this` shouldn't be necessary but
+            // we'll add it out of an abundance of caution.
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- calling with same args.
+            const result = (value as any).call(target, ...args);
+            const executeCallback = () => {
+              // this is an action, as actions always return void.
+              callback({ action: prefix + prop, args });
+            };
+
+            // Notify via callback if the function returns void
+            if (isActionReturnValue(result)) {
+              if (isPromise(result)) {
+                result.finally(executeCallback);
+              } else {
+                executeCallback();
+              }
+            }
+
+            return result;
+          };
+        } else if (isService(value)) {
+          // Wrap nested services in the same way
+          const cachedService = serviceCache.get(prop);
+          if (cachedService) {
+            return cachedService;
+          }
+          const wrappedService = interceptActions(value, prefix + prop + NESTED_SERVICE_SEPARATOR, callback);
+          serviceCache.set(prop, wrappedService);
+          return wrappedService;
+        }
+      }
+      propertyCache.set(prop, returnValue);
+      return returnValue;
+    },
+  }) as unknown as T;
+}
+
+// Function to add observable actions to a service
+export function addObservableActions<T extends Service>(service: T): WithObservableActions<T> {
+  const [actions, notifyActions] = createObservableEvent<ServiceActionMessages<T>>();
+  //  eslint-disable-next-line @typescript-eslint/no-explicit-any -- the compiler is complaining about type recursion for no discernable reason.
+  return (interceptActions as any)({ ...service, actions }, '', notifyActions);
+}
+
+// Type to map service functions to action messages
+type FunctionsToMessages<T, Prefix extends string = ''> = {
+  [K in keyof T]: K extends string
+  ? // eslint-disable-next-line @typescript-eslint/no-explicit-any -- needed for Parameters<T[K]> to work correctly in this context
+  T[K] extends (...args: any[]) => unknown
+  ? { action: `${Prefix}${K}`; args: Parameters<T[K]> }
+  : never
+  : never;
+};
+
+// Type to extract sub-services from a service
+type SubServices<T> = NoNever<{
+  [K in keyof T]: T[K] extends Service ? T[K] : never;
+}>;
+
+// Type to map sub-service actions to messages with a prefix
+type SubServiceActionMessages<T, ParentPrefix extends string = ''> = {
+  [K in keyof T]: K extends string ? ServiceActionMessagesWithPrefix<T[K], `${ParentPrefix}${K}${typeof NESTED_SERVICE_SEPARATOR}`> : never;
+};
+
+type IsPromiseOrVoid<T> = T extends Promise<unknown> ? true : IsVoid<T>;
+
+type PromiseOrVoidFunctions<T> = NoNever<{
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- needed for the infer R pattern to work correctly with IsPromiseOrVoid
+  [K in keyof T]: T[K] extends (...args: any[]) => infer R ? (IsPromiseOrVoid<R> extends true ? T[K] : never) : never;
+}>;
+
+// Type to map service actions and sub-service actions to messages with a prefix
+type ServiceActionMessagesWithPrefix<T, Prefix extends string = ''> =
+  | FunctionsToMessages<PromiseOrVoidFunctions<T>, Prefix>[keyof FunctionsToMessages<PromiseOrVoidFunctions<T>, Prefix>]
+  | (T extends Service
+    ? Expand<SubServiceActionMessages<SubServices<T>, Prefix>[keyof SubServiceActionMessages<SubServices<T>, Prefix>]>
+    : never);
+
+// Type to map service actions to messages
+export type ServiceActionMessages<T> = Extract<ServiceActionMessagesWithPrefix<T>, { action: string }>;
+
+// Compile-time type unit tests
+{
+  interface GrandChildService extends Service {
+    doFive(z: number): void;
+    doSix(): void;
+  }
+  interface ChildService extends Service {
+    k: Observe<number>;
+    r: Observe<string>;
+    doThree(z: number): void;
+    doFour(): void;
+    grandChild: GrandChildService;
+  }
+
+  interface MyService extends Service {
+    a: Observe<number>;
+    b: Observe<string>;
+    doOne(x: number, y: number): void;
+    doTwo(): void;
+    child: ChildService;
+  }
+
+  type MyServiceActionMessages = ServiceActionMessages<MyService>;
+
+  type ExpectedActionMessages =
+    | {
+      action: 'doOne';
+      args: [x: number, y: number];
+    }
+    | {
+      action: 'doTwo';
+      args: [];
+    }
+    | {
+      action: 'child_doThree';
+      args: [z: number];
+    }
+    | {
+      action: 'child_doFour';
+      args: [];
+    }
+    | {
+      action: 'child_grandChild_doFive';
+      args: [z: number];
+    }
+    | {
+      action: 'child_grandChild_doSix';
+      args: [];
+    };
+
+  // Compile-time type check
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars -- this is a compile time type check.
+  type CheckType = True<EquivalentTypes<MyServiceActionMessages, ExpectedActionMessages>>;
+}

package/{service/index.js → src/service/index.ts}

@@ -19,8 +19,8 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.*/
-export * from './service.js';
-export * from './add-observable-actions.js';
-export * from './sequential-action.js';
+
+export { type Service } from './service.js';
+export { isService } from './is-service.js';
+export { type WithObservableActions, type ServiceActionMessages, addObservableActions } from './add-observable-actions.js';
 export * from './progressive-result.js';
-//# sourceMappingURL=index.js.map

package/src/service/is-service.ts

@@ -0,0 +1,7 @@
+import { Service } from "./service.js";
+
+
+export function isService(value: unknown): value is Service {
+  const maybeService = value as null | undefined | Partial<Service>;
+  return typeof maybeService?.serviceName === 'string';
+}

package/src/service/progressive-result.ts

@@ -0,0 +1,141 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+
+import { Schema } from "../schema/schema.js";
+
+export type ErrorResult<Result, Error> = Partial<Result> & {
+  readonly error: Error;
+  readonly progress?: number;
+}
+
+export type IntermediateResult<Result> = Partial<Result> & {
+  readonly error?: never;
+  readonly progress: number;
+}
+
+export type SuccessResult<Result> = Result & {
+  readonly error?: never;
+  readonly progress: 1.0;
+}
+
+export type ProgressiveResult<Result, Error> = IntermediateResult<Result> | SuccessResult<Result> | ErrorResult<Result, Error>;
+
+/**
+ * Results must be objects as we are going to add error and progress properties to them.
+ */
+type ResultSchema = Schema & { properties: {}, required: string[] };
+
+/**
+ * Returns a json schema for an final result with the specified value schema.
+ */
+export function SuccessResultSchema<T extends ResultSchema>(valueSchema: T) {
+  const { properties, required, ...rest } = valueSchema;
+  return {
+    ...rest,
+    type: 'object',
+    properties: {
+      ...properties,
+      progress: { const: 1.0 },
+    },
+    required: [...required, 'progress'],
+  } as const;
+}
+
+/**
+ * Returns a json schema for an intermediate result with the specified result schema.
+ */
+export function IntermediateResultSchema<T extends ResultSchema>(valueSchema: T) {
+  const { properties, required, ...rest } = valueSchema;
+  return {
+    ...rest,
+    type: 'object',
+    properties: {
+      ...properties,
+      error: valueSchema,
+    },
+    required: ['progress'],
+  } as const;
+}
+
+/**
+ * Returns a json schema for an error result with the specified result schema.
+ */
+export function ErrorResultSchema<T extends ResultSchema, E extends ResultSchema>(valueSchema: T, errorSchema: E) {
+  const { properties, required, ...rest } = valueSchema;
+  return {
+    ...rest,
+    type: 'object',
+    properties: {
+      ...properties,
+      error: errorSchema,
+    },
+    required: ['error'],
+  } as const;
+}
+
+/**
+ * Returns a json schema for a progressive result with the specified result schemas.
+ */
+export function ProgressiveResultSchema<T extends ResultSchema, E extends ResultSchema>(
+  successSchema: T,
+  errorSchema: E,
+) {
+  return {
+    oneOf: [IntermediateResultSchema(successSchema), SuccessResultSchema(successSchema), ErrorResultSchema(successSchema, errorSchema)],
+  } as const;
+}
+
+/**
+ * Checks if the result is an error result.
+ */
+export function isErrorResult<FinalValue extends ResultSchema, ErrorValue>(
+  result: ProgressiveResult<FinalValue, ErrorValue>
+): result is ErrorResult<FinalValue, ErrorValue> {
+  return result.error !== null && result.error !== undefined;
+}
+
+/**
+ * Checks if the result is not started. We check progress < 0.0 to mean not started.
+ */
+export function isNotStarted<FinalValue extends ResultSchema, ErrorValue>(
+  result: ProgressiveResult<FinalValue, ErrorValue>
+): result is IntermediateResult<FinalValue> {
+  return !isErrorResult(result) && result.progress < 0.0;
+}
+
+/**
+ * Checks if the result is an intermediate result.
+ */
+export function isIntermediateResult<FinalValue extends ResultSchema, ErrorValue>(
+  result: ProgressiveResult<FinalValue, ErrorValue>
+): result is IntermediateResult<FinalValue> {
+  return !isErrorResult(result) && result.progress !== 1.0;
+}
+
+/**
+ * Checks if the result is a final result.
+ */
+export function isSuccessResult<FinalValue extends ResultSchema, ErrorValue>(
+  result: ProgressiveResult<FinalValue, ErrorValue>
+): result is SuccessResult<FinalValue> {
+  return !isErrorResult(result) && result.progress === 1.0;
+}

package/src/service/service.ts

@@ -0,0 +1,27 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+
+export interface Service {
+  readonly serviceName: string;
+  dispose?(): void;
+}
+

package/src/table/add-row.ts

@@ -0,0 +1,42 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import { ensureCapacity } from "./ensure-capacity.js";
+import { RowIndex } from "./row-index.js";
+import { Table } from "./table.js";
+
+/**
+ * Adds a row to the end of the Table.
+ * @param Table 
+ * @param rowData 
+ */
+export const addRow = <C>(table: Table<C>, rowData: C): RowIndex => {
+    ensureCapacity(table, table.rows + 1);
+    const rowIndex = table.rows;
+    for (const name in rowData) {
+        const column = table.columns[name];
+        if (column) {
+            column.set(rowIndex, rowData[name]);
+        }
+    }
+    table.rows++;
+    return rowIndex;
+}

package/src/table/create-table.ts

@@ -0,0 +1,36 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import { createTypedBuffer, TypedBuffer } from "../typed-buffer/index.js";
+import { FromSchema, Schema } from "../schema/schema.js";
+import { Table } from "./table.js";
+
+export const createTable = <C extends Record<string, Schema>>(schemas: C) : Table<{ [K in keyof C]: FromSchema<C[K]> }> => {
+    const columns = {} as { [K in keyof C]: TypedBuffer<FromSchema<C[K]>> };
+    for (const name in schemas) {
+        columns[name] = createTypedBuffer({schema: schemas[name]});
+    }
+
+    return {
+        columns,
+        rows: 0,
+    };
+}

package/src/table/delete-row.ts

@@ -0,0 +1,42 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import { RowIndex } from "./row-index.js";
+import { Table } from "./table.js";
+
+/**
+ * Deletes a row from the Table, replacing it with the last row in the Table.
+ * @returns true if a row was moved into the deleted row's position, false if the row was the last row in the Table.
+ *  @param Table 
+ * @param rowIndex 
+ */
+export const deleteRow = <C>(table: Table<C>, rowIndex: RowIndex): boolean => {
+    const lastRowIndex = --table.rows;
+    if (rowIndex === lastRowIndex) {
+        return false;
+    }
+
+    for (const name in table.columns) {
+        const column = table.columns[name];
+        column.copyWithin(rowIndex, lastRowIndex, lastRowIndex + 1);
+    }
+    return true;
+}

package/src/table/ensure-capacity.ts

@@ -0,0 +1,37 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import { Table } from "./table.js";
+
+export const ensureCapacity = <C>(table: Table<C>, minimumCapacity: number, growthFactor = 2) => {
+    // we don't actually loop, we just need to check the first columns length.
+    for (const name in table.columns) {
+        const currentCapacity = table.columns[name].size;
+        if (currentCapacity < minimumCapacity) {
+            const newCapacity = Math.max(minimumCapacity, currentCapacity * growthFactor);
+            for (const name in table.columns) {
+                const column = table.columns[name];
+                column.size = newCapacity;
+            }
+        }
+        return;
+    }
+}

package/src/table/get-row-data.ts

@@ -0,0 +1,31 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import { RowIndex } from "./row-index.js";
+import { Table } from "./table.js";
+
+export const getRowData = <C>(table: Table<C>, rowIndex: RowIndex): C => {
+    const rowData: C = {} as C;
+    for (const name in table.columns) {
+        rowData[name] = table.columns[name].get(rowIndex);
+    }
+    return rowData;
+}

package/src/table/index.ts

@@ -0,0 +1,29 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+export * from "./table.js";
+export * from "./create-table.js";
+export * from "./get-row-data.js";
+export * from "./update-row.js";
+export * from "./add-row.js";
+export * from "./delete-row.js";
+export * from "./get-row-data.js";
+export * from "./ensure-capacity.js";