@syncmatters/script-api 1.0.0

package/lib/utilities/utilities.d.ts

@@ -0,0 +1,105 @@
+import { RateLimiterRolling } from "./rate-limiter/rate-limiter-rolling.js";
+import { RateLimiterConcurrent } from "./rate-limiter/rate-limiter-concurrent.js";
+import { RateLimiterOptions } from "./rate-limiter/rate-limiter.js";
+import { htmlToText } from "./html-utils/html-utils.js";
+import { HttpClientOptions } from "./http-client/types.js";
+import { HttpClient } from "./http-client/types.js";
+import { fileProvider } from "./file-provider/file-provider.js";
+import { CsvReaderOptions } from "./csv-reader/index.js";
+import { CsvWriter, CsvWriterOptions } from "./csv-writer/csv-writer.js";
+import { XlsxReader, XlsxReaderOptions } from "./xlsx-reader/xlsx-reader.js";
+import { XlsxWriter, XlsxWriterOptions } from "./xlsx-writer/xlsx-writer.js";
+import { emailCleanse } from "./www-utils/www-utils.js";
+import { emailIsPublic } from "./www-utils/www-utils.js";
+import { domainParse } from "./www-utils/www-utils.js";
+import { nameParser } from "./name-parser/name-parser.js";
+import { tempDir, tempFile } from "./file-utils/file-utils.js";
+import { dateFormat, dateParse, dateTransform } from "./date-utils/date-utils.js";
+import { gunzipB64, gzipB64, zipExtract, zipCompress } from "./zip-utils/zip-utils.js";
+import * as TypeUtils from "./type-utils/type-utils.js";
+import * as JsonUtils from "./json-utils/index.js";
+import * as UpsertFlags from "./upsert-flags/upsert-flags.js";
+import { KvStore } from "@syncmatters/script-api";
+export declare const utilities: {
+    arrayOfStr: typeof arrayOfStrings;
+    arrayOfNum: typeof arrayOfNumbers;
+    clone: <T>(value: T) => T;
+    csvReader: (options: CsvReaderOptions) => import("./csv-reader/types.js").CsvReader;
+    csvWriter: (options: CsvWriterOptions) => CsvWriter;
+    dateFormat: typeof dateFormat;
+    dateParse: typeof dateParse;
+    dateTransform: typeof dateTransform;
+    emailCleanse: typeof emailCleanse;
+    emailIsPublic: typeof emailIsPublic;
+    domainParse: typeof domainParse;
+    fileProvider: typeof fileProvider;
+    gzip: {
+        compressB64: typeof gzipB64;
+        decompressB64: typeof gunzipB64;
+    };
+    htmlToText: typeof htmlToText;
+    httpClient: (options?: HttpClientOptions) => HttpClient;
+    json: {
+        stringsToLosslessNumbers: typeof JsonUtils.stringsToLosslessNumbers;
+        stringifyWithLosslessNumbers: typeof JsonUtils.stringifyWithLosslessNumbers;
+        parseWithLosslessNumbers: typeof JsonUtils.parseWithLosslessNumbers;
+        stringsFromLosslessNumbers: typeof JsonUtils.stringsFromLosslessNumbers;
+        valuesReader(options: {
+            paths: Array<JsonUtils.JsonValuePath>;
+            dontThrowOnInvalidParent?: boolean;
+        }): JsonUtils.JsonValuesReader;
+        valuesWriter(options: {
+            fields: Array<{
+                path: JsonUtils.JsonValuePath;
+                behaviour: JsonUtils.WriteBehaviour;
+            }>;
+        }): JsonUtils.JsonValuesWriter;
+        changesChecker: typeof JsonUtils.JsonChangedChecker;
+        stringToJsonValuePath: typeof JsonUtils.fieldPathToJsonValuePath;
+        stringsToJsonValuePaths: typeof JsonUtils.fieldsPathToJsonValuePaths;
+        fieldsToFieldPaths: typeof JsonUtils.fieldsToFieldPaths;
+    };
+    kvStore: () => KvStore;
+    nameParse: typeof nameParser;
+    rateLimiter: (options: RateLimiterOptions) => RateLimiterRolling | RateLimiterConcurrent;
+    setOfStr: typeof setOfStrings;
+    setOfNum: typeof setOfNumbers;
+    sleep: (ms: number) => Promise<void>;
+    tempDir: typeof tempDir;
+    tempFile: typeof tempFile;
+    tryGet: typeof tryGet;
+    types: {
+        isString: typeof TypeUtils.isString;
+        isNumber: typeof TypeUtils.isNumber;
+        isInteger: typeof TypeUtils.isInteger;
+        isBoolean: typeof TypeUtils.isBoolean;
+        isDate: typeof TypeUtils.isDate;
+        isBuffer: typeof TypeUtils.isBuffer;
+        isArray: typeof TypeUtils.isArray;
+        isFunction: typeof TypeUtils.isFunction;
+        isNull: typeof TypeUtils.isNull;
+        isUndefined: typeof TypeUtils.isUndefined;
+        isNullOrUndefined: typeof TypeUtils.isNullOrUndefined;
+    };
+    upsertFlags: {
+        set: typeof UpsertFlags.set;
+        get: typeof UpsertFlags.get;
+    };
+    xlsxReader: (options: XlsxReaderOptions) => XlsxReader;
+    xlsxWriter: (options: XlsxWriterOptions) => XlsxWriter;
+    xmlParse: (options: {
+        string: string;
+    }) => Promise<any>;
+    zip: {
+        compress: typeof zipCompress;
+        extract: typeof zipExtract;
+    };
+    zipExtract: typeof zipExtract;
+};
+declare function tryGet<T>(path: () => T | undefined): T | undefined;
+declare function arrayOfStrings(): string[];
+declare function arrayOfNumbers(): number[];
+declare function setOfStrings(): Set<string>;
+declare function setOfNumbers(): Set<number>;
+export declare function reset(): Promise<void>;
+export {};

package/lib/utilities/www-utils/www-utils.d.ts

@@ -0,0 +1,14 @@
+interface ParsedDomain {
+    domain: string;
+    subdomain: string;
+    tld: string;
+    tldListed: boolean;
+}
+export declare function domainParse(hostname: string): ParsedDomain;
+export declare function emailCleanse(email: string | undefined): string | undefined;
+export declare function emailIsPublic(email: string | undefined): boolean;
+export declare function tldCheck(tld: string | undefined): boolean;
+export declare function domainCheck(domain: string | undefined, options?: {
+    allowUnderscores?: boolean;
+}): boolean;
+export {};

package/lib/utilities/xlsx-reader/xlsx-reader.d.ts

@@ -0,0 +1,32 @@
+import { FileProvider } from "../file-provider/file-provider.js";
+export interface XlsxReaderOptions {
+    source: {
+        fileProvider?: FileProvider;
+        /** This is unlikely going to work. The string written will mangle the content b/o encoding in utf8 */
+        string?: string;
+    };
+    sheets: Array<{
+        name?: string;
+        noHeader?: boolean;
+        startRow?: number;
+        includeEmpty?: boolean;
+    }>;
+}
+/**
+ * XlsxReader parses an xlsx and emits an async iterator for accessing the next row. The row is an array
+ * allowing access to the columns by index or, if the csv has a header, by header name:
+ * for await (const row of reader.rows()) {
+ *   var field1ByName = row["my col name"];
+ *   var field1ByIndex = row[0];
+ *  }
+ */
+export declare class XlsxReader {
+    constructor(options: XlsxReaderOptions);
+    sheets(): Promise<string[]>;
+    header(sheet: string): Promise<string[]>;
+    jsDoc(sheet: string): Promise<string>;
+    verifyHeader(sheet: string, required: string[]): Promise<void>;
+    rows(sheet: string): AsyncIterableIterator<string[]>;
+    rowsWithProps<T>(sheet: string): AsyncIterableIterator<T>;
+    private _init;
+}

package/lib/utilities/xlsx-writer/xlsx-writer.d.ts

@@ -0,0 +1,23 @@
+import { FileProvider } from "../file-provider/file-provider.js";
+export interface XlsxWriterOptions {
+    target?: {
+        filePath?: string;
+    };
+    title?: string;
+    noHeader?: boolean;
+}
+export interface XlsxCellFormat {
+    number?: string;
+}
+/**
+ * XlsxWriter writes rows of data to an XLSX file.
+ */
+export declare class XlsxWriter {
+    constructor(options: XlsxWriterOptions);
+    write(sheetName: string, row: {
+        [col: string]: any;
+    } | any[], formatter?: {
+        [col: string]: XlsxCellFormat;
+    }): Promise<void>;
+    close(): Promise<FileProvider>;
+}

package/lib/utilities/xml-utils/xml-utils.d.ts

@@ -0,0 +1 @@
+export declare function xmlParse(source: string): Promise<any>;

package/lib/utilities/zip-utils/zip-utils.d.ts

@@ -0,0 +1,29 @@
+import { FileProvider } from "../file-provider/file-provider.js";
+import zlib from "zlib";
+export declare function zipExtract(options: {
+    source: FileProvider;
+    targetDir?: string;
+    password?: string;
+}): Promise<string>;
+/**
+ * Compress a directory into a zip file
+ * @param options - The options to pass to the zipCompress function
+ * @returns The result as a FileProvider
+ */
+export declare function zipCompress(options: {
+    sourceDir: string;
+}): Promise<FileProvider>;
+/**
+ * Gzip the input and return the result as a base64 string
+ * @param input - The input to gzip
+ * @param options - The options to pass to the gzip function
+ * @returns The result as a base64 string
+ */
+export declare function gzipB64(input: unknown, options?: zlib.ZlibOptions): Promise<string>;
+/**
+ * Gunzip the input and return the result as an JSON object
+ * @param input - The base64 encoded input to gunzip
+ * @param options - The options to pass to the gunzip function
+ * @returns The result as an JSON object
+ */
+export declare function gunzipB64(input: string, options?: zlib.ZlibOptions): Promise<unknown>;

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@syncmatters/script-api",
+  "version": "1.0.0",
+  "description": "TypeScript type definitions for the SyncMatters script API (types only - scripts execute on the SyncMatters platform)",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./sdk-test": {
+      "types": "./sdk-test.d.ts",
+      "default": "./index.js"
+    }
+  },
+  "license": "MIT",
+  "author": "SyncMatters",
+  "homepage": "https://syncmatters.com",
+  "typesContentHash": "143c303baa596be30ce78a3af1e88dbcd485a63237e15a553bd0fe74ce495dc7",
+  "dependencies": {
+    "@types/node": "*"
+  }
+}