@8ms/helpers 2.0.0 → 2.0.2

package/googleAds/GoogleAdsNamespace.d.ts

@@ -0,0 +1,11 @@
+import { BaseNamespace } from "../_class";
+import type { GoogleAdsApi } from "google-ads-api";
+import { Config } from "./index";
+export declare class GoogleAdsNamespace extends BaseNamespace {
+    client: GoogleAdsApi | null;
+    config: Config | null;
+    mccAccountId: string;
+    refreshToken: string;
+    ensureInit: () => Promise<void>;
+    getCustomer: (customerId: string) => Promise<import("google-ads-api").Customer>;
+}

package/googleAds/GoogleAdsNamespace.js

@@ -0,0 +1,73 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleAdsNamespace = void 0;
+const _class_1 = require("../_class");
+class GoogleAdsNamespace extends _class_1.BaseNamespace {
+    constructor() {
+        super(...arguments);
+        this.client = null;
+        this.config = null;
+        this.mccAccountId = "";
+        this.refreshToken = "";
+        this.ensureInit = async () => {
+            if (!this.client) {
+                try {
+                    const { GoogleAdsApi } = await Promise.resolve().then(() => __importStar(require("google-ads-api")));
+                    this.client = new GoogleAdsApi({
+                        client_id: this.config.client.clientId,
+                        client_secret: this.config.client.clientSecret,
+                        developer_token: this.config.client.developerToken,
+                    });
+                    this.mccAccountId = this.config.mccAccountId;
+                    this.refreshToken = this.config.refreshToken;
+                }
+                catch (e) {
+                    throw new Error("Google Sheets Client not installed");
+                }
+            }
+        };
+        this.getCustomer = async (customerId) => {
+            await this.ensureInit();
+            const customer = this.client.Customer({
+                customer_id: customerId,
+                login_customer_id: global.googleAdsClient.mccAccountId,
+                refresh_token: global.googleAdsClient.refreshToken,
+            });
+            return customer;
+        };
+    }
+}
+exports.GoogleAdsNamespace = GoogleAdsNamespace;

package/googleAds/index.d.ts

@@ -0,0 +1,11 @@
+import { GoogleAdsNamespace } from "./GoogleAdsNamespace";
+export type Config = {
+    client: {
+        clientId: string;
+        clientSecret: string;
+        developerToken: string;
+    };
+    mccAccountId: string;
+    refreshToken: string;
+};
+export declare const googleAdsClient: (key?: string, config?: Config, vaultId?: string, itemId?: string) => Promise<GoogleAdsNamespace>;

package/googleAds/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.googleAdsClient = void 0;
+const GoogleAdsNamespace_1 = require("./GoogleAdsNamespace");
+const onePassword_1 = require("../onePassword");
+const googleAdsNamespaces = new Map();
+const googleAdsClient = async (key = "default", config, vaultId, itemId) => {
+    if (googleAdsNamespaces.has(key)) {
+        return googleAdsNamespaces.get(key);
+    }
+    let instanceConfig;
+    if (config) {
+        instanceConfig = config;
+    }
+    else if (vaultId && itemId) {
+        instanceConfig = await (await (0, onePassword_1.onePasswordClient)())
+            .getJsonNote(vaultId, itemId);
+    }
+    else if ("default" === key && process.env.GOOGLE_ADS_VAULT_ID && process.env.GOOGLE_ADS_ITEM_ID) {
+        instanceConfig = await (await (0, onePassword_1.onePasswordClient)())
+            .getJsonNote(process.env.GOOGLE_ADS_VAULT_ID, process.env.GOOGLE_ADS_ITEM_ID);
+    }
+    else {
+        throw new Error(`Config required for namespace '${key}'`);
+    }
+    const namespace = new GoogleAdsNamespace_1.GoogleAdsNamespace(key, instanceConfig);
+    googleAdsNamespaces.set(key, namespace);
+    return namespace;
+};
+exports.googleAdsClient = googleAdsClient;

package/googleAds/keywordPlanner/index.d.ts

@@ -0,0 +1,40 @@
+import { z } from "zod/v4";
+export declare enum Network {
+    GOOGLE_SEARCH_ONLY = 2,
+    GOOGLE_SEARCH_AND_PARTNERS = 3
+}
+export declare const requestSchema: z.ZodObject<{
+    countries: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    customerId: z.ZodOptional<z.ZodString>;
+    historicalMetricsOptions: z.ZodOptional<z.ZodObject<{
+        startMonth: z.ZodString;
+        startYear: z.ZodNumber;
+        endMonth: z.ZodString;
+        endYear: z.ZodNumber;
+    }, z.core.$strip>>;
+    includeAdultKeywords: z.ZodOptional<z.ZodBoolean>;
+    keywordPlanNetwork: z.ZodOptional<z.ZodNumber>;
+    queries: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    language: z.ZodOptional<z.ZodNumber>;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type RequestSchemaType = z.infer<typeof requestSchema>;
+export declare const defaultRequest: RequestSchemaType;
+export declare const responseSchema: z.ZodObject<{
+    payload: z.ZodObject<{}, z.core.$strip>;
+    keyword: z.ZodString;
+    avgCpc: z.ZodNumber;
+    avgSearchVolume: z.ZodNumber;
+    competition: z.ZodNumber;
+    competitionIndex: z.ZodNumber;
+    months: z.ZodArray<z.ZodObject<{
+        date: z.ZodString;
+        month: z.ZodNumber;
+        searchVolume: z.ZodNumber;
+        year: z.ZodNumber;
+    }, z.core.$strip>>;
+    topOfPageBidHigh: z.ZodNumber;
+    topOfPageBidLow: z.ZodNumber;
+    totalSearchVolume: z.ZodNumber;
+}, z.core.$strip>;
+export type ResponseSchemaType = z.infer<typeof responseSchema>;

package/googleAds/keywordPlanner/index.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.responseSchema = exports.defaultRequest = exports.requestSchema = exports.Network = void 0;
+const v4_1 = require("zod/v4");
+var Network;
+(function (Network) {
+    Network[Network["GOOGLE_SEARCH_ONLY"] = 2] = "GOOGLE_SEARCH_ONLY";
+    Network[Network["GOOGLE_SEARCH_AND_PARTNERS"] = 3] = "GOOGLE_SEARCH_AND_PARTNERS";
+})(Network || (exports.Network = Network = {}));
+exports.requestSchema = v4_1.z.object({
+    countries: v4_1.z.array(v4_1.z.number())
+        .optional(),
+    customerId: v4_1.z.string()
+        .optional(),
+    historicalMetricsOptions: v4_1.z.object({
+        startMonth: v4_1.z.string(),
+        startYear: v4_1.z.number(),
+        endMonth: v4_1.z.string(),
+        endYear: v4_1.z.number(),
+    })
+        .optional(),
+    includeAdultKeywords: v4_1.z.boolean()
+        .optional(),
+    keywordPlanNetwork: v4_1.z.number()
+        .optional(),
+    queries: v4_1.z.array(v4_1.z.string())
+        .optional(),
+    language: v4_1.z.number()
+        .optional(),
+    url: v4_1.z.string()
+        .optional(),
+});
+exports.defaultRequest = {
+    countries: [],
+    customerId: "",
+    historicalMetricsOptions: null,
+    includeAdultKeywords: false,
+    keywordPlanNetwork: Network.GOOGLE_SEARCH_ONLY,
+    queries: [],
+    language: null,
+};
+exports.responseSchema = v4_1.z.object({
+    payload: v4_1.z.object(),
+    keyword: v4_1.z.string(),
+    avgCpc: v4_1.z.number(),
+    avgSearchVolume: v4_1.z.number(),
+    competition: v4_1.z.number(),
+    competitionIndex: v4_1.z.number(),
+    months: v4_1.z.object({
+        date: v4_1.z.string(),
+        month: v4_1.z.number(),
+        searchVolume: v4_1.z.number(),
+        year: v4_1.z.number(),
+    })
+        .array(),
+    topOfPageBidHigh: v4_1.z.number(),
+    topOfPageBidLow: v4_1.z.number(),
+    totalSearchVolume: v4_1.z.number(),
+});

package/googlePageSpeed/GooglePageSpeedNamespace.d.ts

@@ -0,0 +1,11 @@
+import { BaseNamespace } from "../_class";
+import { Category, GooglePageSpeedConfig, Strategy } from "./index";
+/**
+ * Based on https://developers.google.com/speed/docs/insights/rest/v5/pagespeedapi/runpagespeed
+ */
+export declare class GooglePageSpeedNamespace extends BaseNamespace {
+    client: boolean | null;
+    config: GooglePageSpeedConfig;
+    ensureInit: () => Promise<void>;
+    getReport: (url: string, category?: Category, strategy?: Strategy) => Promise<any>;
+}

package/googlePageSpeed/GooglePageSpeedNamespace.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GooglePageSpeedNamespace = void 0;
+const _class_1 = require("../_class");
+const index_1 = require("./index");
+const axios_1 = require("../axios");
+/**
+ * Based on https://developers.google.com/speed/docs/insights/rest/v5/pagespeedapi/runpagespeed
+ */
+class GooglePageSpeedNamespace extends _class_1.BaseNamespace {
+    constructor() {
+        super(...arguments);
+        this.client = null;
+        this.ensureInit = async () => {
+            if (!this.client) {
+                try {
+                    // There is not API client but potentially multiple keys to manage instances
+                    this.client = true;
+                }
+                catch (e) {
+                    throw new Error("Google PageSpeed Client not installed");
+                }
+            }
+        };
+        this.getReport = async (url, category = index_1.Category.PERFORMANCE, strategy = index_1.Strategy.MOBILE) => {
+            const requestUrl = `https://www.googleapis.com/pagespeedonline/v5/runPagespeed?url=${url}&strategy=${strategy}&category=${category}&key=${this.config.apiKey}`;
+            const apiResponse = await (0, axios_1.get)(requestUrl);
+            if (apiResponse.isSuccess()) {
+                return apiResponse.getBody();
+            }
+            return null;
+        };
+    }
+}
+exports.GooglePageSpeedNamespace = GooglePageSpeedNamespace;

package/googlePageSpeed/index.d.ts

@@ -0,0 +1,17 @@
+import { GooglePageSpeedNamespace } from "./GooglePageSpeedNamespace";
+export type GooglePageSpeedConfig = {
+    apiKey: string;
+};
+export declare const googlePageSpeedClient: (key?: string, config?: GooglePageSpeedConfig, vaultId?: string, itemId?: string) => Promise<GooglePageSpeedNamespace>;
+export declare enum Category {
+    CATEGORY_UNSPECIFIED = "CATEGORY_UNSPECIFIED",
+    ACCESSIBILITY = "ACCESSIBILITY",
+    BEST_PRACTICES = "BEST_PRACTICES",
+    PERFORMANCE = "PERFORMANCE",
+    SEO = "SEO"
+}
+export declare enum Strategy {
+    STRATEGY_UNSPECIFIED = "STRATEGY_UNSPECIFIED",
+    DESKTOP = "DESKTOP",
+    MOBILE = "MOBILE"
+}

package/googlePageSpeed/index.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Strategy = exports.Category = exports.googlePageSpeedClient = void 0;
+const GooglePageSpeedNamespace_1 = require("./GooglePageSpeedNamespace");
+const onePassword_1 = require("../onePassword");
+const googlePageSpeedNamespaces = new Map();
+const googlePageSpeedClient = async (key = "default", config, vaultId, itemId) => {
+    if (googlePageSpeedNamespaces.has(key)) {
+        return googlePageSpeedNamespaces.get(key);
+    }
+    let instanceConfig;
+    if (config) {
+        instanceConfig = config;
+    }
+    else if (vaultId && itemId) {
+        instanceConfig = await (await (0, onePassword_1.onePasswordClient)())
+            .getJsonNote(vaultId, itemId);
+    }
+    else if ("default" === key && process.env.GOOGLE_PAGE_SPEED_VAULT_ID && process.env.GOOGLE_PAGE_SPEED_ITEM_ID) {
+        instanceConfig = await (await (0, onePassword_1.onePasswordClient)())
+            .getJsonNote(process.env.GOOGLE_PAGE_SPEED_VAULT_ID, process.env.GOOGLE_PAGE_SPEED_ITEM_ID);
+    }
+    else {
+        throw new Error(`Config required for namespace '${key}'`);
+    }
+    const namespace = new GooglePageSpeedNamespace_1.GooglePageSpeedNamespace(key, instanceConfig);
+    googlePageSpeedNamespaces.set(key, namespace);
+    return namespace;
+};
+exports.googlePageSpeedClient = googlePageSpeedClient;
+var Category;
+(function (Category) {
+    Category["CATEGORY_UNSPECIFIED"] = "CATEGORY_UNSPECIFIED";
+    Category["ACCESSIBILITY"] = "ACCESSIBILITY";
+    Category["BEST_PRACTICES"] = "BEST_PRACTICES";
+    Category["PERFORMANCE"] = "PERFORMANCE";
+    Category["SEO"] = "SEO";
+})(Category || (exports.Category = Category = {}));
+var Strategy;
+(function (Strategy) {
+    Strategy["STRATEGY_UNSPECIFIED"] = "STRATEGY_UNSPECIFIED";
+    Strategy["DESKTOP"] = "DESKTOP";
+    Strategy["MOBILE"] = "MOBILE";
+})(Strategy || (exports.Strategy = Strategy = {}));

package/googleSearchIncidents/index.d.ts

@@ -0,0 +1,69 @@
+import { z } from "zod/v4";
+/**
+ * https://status.search.google.com/summary
+ */
+export declare const getReport: () => Promise<any>;
+export declare const updateSchema: z.ZodObject<{
+    created: z.ZodString;
+    modified: z.ZodString;
+    when: z.ZodString;
+    text: z.ZodString;
+    status: z.ZodEnum<{
+        AVAILABLE: "AVAILABLE";
+        SERVICE_DISRUPTION: "SERVICE_DISRUPTION";
+        SERVICE_INFORMATION: "SERVICE_INFORMATION";
+    }>;
+}, z.core.$strip>;
+export type UpdateSchemaType = z.infer<typeof updateSchema>;
+export declare const incidentSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    number: z.ZodString;
+    begin: z.ZodString;
+    created: z.ZodString;
+    end: z.ZodOptional<z.ZodString>;
+    modified: z.ZodString;
+    external_desc: z.ZodString;
+    updates: z.ZodArray<z.ZodObject<{
+        created: z.ZodString;
+        modified: z.ZodString;
+        when: z.ZodString;
+        text: z.ZodString;
+        status: z.ZodEnum<{
+            AVAILABLE: "AVAILABLE";
+            SERVICE_DISRUPTION: "SERVICE_DISRUPTION";
+            SERVICE_INFORMATION: "SERVICE_INFORMATION";
+        }>;
+    }, z.core.$strip>>;
+    most_recent_update: z.ZodObject<{
+        created: z.ZodString;
+        modified: z.ZodString;
+        when: z.ZodString;
+        text: z.ZodString;
+        status: z.ZodEnum<{
+            AVAILABLE: "AVAILABLE";
+            SERVICE_DISRUPTION: "SERVICE_DISRUPTION";
+            SERVICE_INFORMATION: "SERVICE_INFORMATION";
+        }>;
+    }, z.core.$strip>;
+    status_impact: z.ZodEnum<{
+        SERVICE_DISRUPTION: "SERVICE_DISRUPTION";
+        SERVICE_INFORMATION: "SERVICE_INFORMATION";
+    }>;
+    severity: z.ZodEnum<{
+        high: "high";
+        low: "low";
+        medium: "medium";
+    }>;
+    service_key: z.ZodString;
+    service_name: z.ZodEnum<{
+        Indexing: "Indexing";
+        Ranking: "Ranking";
+        Serving: "Serving";
+    }>;
+    affected_products: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strip>>;
+    uri: z.ZodString;
+}, z.core.$strip>>;
+export type IncidentSchemaType = z.infer<typeof incidentSchema>;

package/googleSearchIncidents/index.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.incidentSchema = exports.updateSchema = exports.getReport = void 0;
+const axios_1 = require("../axios");
+const v4_1 = require("zod/v4");
+/**
+ * https://status.search.google.com/summary
+ */
+const getReport = async () => {
+    const url = "https://status.search.google.com/incidents.json";
+    const apiResponse = await (0, axios_1.get)(url);
+    if (apiResponse.isSuccess()) {
+        return apiResponse.getBody();
+    }
+    return null;
+};
+exports.getReport = getReport;
+exports.updateSchema = v4_1.z.object({
+    created: v4_1.z.string(),
+    modified: v4_1.z.string(),
+    when: v4_1.z.string(),
+    text: v4_1.z.string(),
+    status: v4_1.z.enum(["AVAILABLE", "SERVICE_DISRUPTION", "SERVICE_INFORMATION"]),
+});
+exports.incidentSchema = v4_1.z.object({
+    id: v4_1.z.string(),
+    number: v4_1.z.string(),
+    begin: v4_1.z.string(),
+    created: v4_1.z.string(),
+    end: v4_1.z.string().optional(),
+    modified: v4_1.z.string(),
+    external_desc: v4_1.z.string(),
+    updates: exports.updateSchema.array(),
+    most_recent_update: exports.updateSchema,
+    status_impact: v4_1.z.enum(["SERVICE_DISRUPTION", "SERVICE_INFORMATION"]),
+    severity: v4_1.z.enum(["low", "medium", "high"]),
+    service_key: v4_1.z.string(),
+    service_name: v4_1.z.enum(["Indexing", "Ranking", "Serving"]),
+    affected_products: v4_1.z.object({
+        title: v4_1.z.string(),
+        id: v4_1.z.string(),
+    })
+        .array(),
+    uri: v4_1.z.string(),
+})
+    .array();

package/greenDomain/index.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod/v4";
+/**
+ * https://developers.thegreenwebfoundation.org/api/greencheck/v3/check-single-domain/
+ */
+export declare const getSingleReport: (domain: string) => Promise<any>;
+export declare const greenDomainSchema: z.ZodObject<{
+    green: z.ZodBoolean;
+    url: z.ZodString;
+    data: z.ZodOptional<z.ZodBoolean>;
+    hosted_by: z.ZodOptional<z.ZodString>;
+    hosted_by_website: z.ZodOptional<z.ZodString>;
+    partner: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    hosted_by_id: z.ZodOptional<z.ZodNumber>;
+    modified: z.ZodOptional<z.ZodString>;
+    supporting_documents: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        title: z.ZodString;
+        link: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type GreenDomainSchemaType = z.infer<typeof greenDomainSchema>;

package/greenDomain/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.greenDomainSchema = exports.getSingleReport = void 0;
+const axios_1 = require("../axios");
+const v4_1 = require("zod/v4");
+/**
+ * https://developers.thegreenwebfoundation.org/api/greencheck/v3/check-single-domain/
+ */
+const getSingleReport = async (domain) => {
+    const url = `https://api.thegreenwebfoundation.org/greencheck/${domain}`;
+    const apiResponse = await (0, axios_1.get)(url);
+    if (apiResponse.isSuccess()) {
+        return apiResponse.getBody();
+    }
+    return null;
+};
+exports.getSingleReport = getSingleReport;
+exports.greenDomainSchema = v4_1.z.object({
+    green: v4_1.z.boolean(),
+    url: v4_1.z.string(),
+    data: v4_1.z.boolean()
+        .optional(),
+    hosted_by: v4_1.z.string()
+        .optional(),
+    hosted_by_website: v4_1.z.string()
+        .optional(),
+    partner: v4_1.z.string()
+        .nullable()
+        .optional(),
+    hosted_by_id: v4_1.z.number()
+        .optional(),
+    modified: v4_1.z.string()
+        .optional(),
+    supporting_documents: v4_1.z.object({
+        id: v4_1.z.number(),
+        title: v4_1.z.string(),
+        link: v4_1.z.string(),
+    })
+        .array()
+        .optional(),
+});

package/inngest/index.d.ts

@@ -0,0 +1,6 @@
+export declare enum InngestState {
+    RUNNING = "Running",
+    COMPLETED = "Completed",
+    FAILED = "Failed",
+    CANCELLED = "Cancelled"
+}

package/inngest/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InngestState = void 0;
+var InngestState;
+(function (InngestState) {
+    InngestState["RUNNING"] = "Running";
+    InngestState["COMPLETED"] = "Completed";
+    InngestState["FAILED"] = "Failed";
+    InngestState["CANCELLED"] = "Cancelled";
+})(InngestState || (exports.InngestState = InngestState = {}));

package/json/getJsonNewline.d.ts

@@ -0,0 +1 @@
+export declare const getJsonNewline: (data: any) => string;

package/json/getJsonNewline.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJsonNewline = void 0;
+const array_1 = require("../array");
+const getJsonNewline = (data) => {
+    // Must be an array
+    const inputArray = (0, array_1.getArray)(data);
+    // For each array row convert the row
+    const stringRows = inputArray.map(row => JSON.stringify(row));
+    // Combine each row with a line separator
+    return stringRows.join("\n");
+};
+exports.getJsonNewline = getJsonNewline;

package/json/index.d.ts

@@ -0,0 +1,2 @@
+export { getJsonNewline } from "./getJsonNewline";
+export { isJson } from "./isJson";

package/json/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isJson = exports.getJsonNewline = void 0;
+var getJsonNewline_1 = require("./getJsonNewline");
+Object.defineProperty(exports, "getJsonNewline", { enumerable: true, get: function () { return getJsonNewline_1.getJsonNewline; } });
+var isJson_1 = require("./isJson");
+Object.defineProperty(exports, "isJson", { enumerable: true, get: function () { return isJson_1.isJson; } });

package/json/isJson.d.ts

@@ -0,0 +1 @@
+export declare const isJson: (input: any) => boolean;

package/json/isJson.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isJson = void 0;
+const isJson = (input) => {
+    // If input is already an object/array/primitive that's not a string,
+    // it's considered valid JSON if it can be stringified and re-parsed
+    if (typeof input !== "string") {
+        try {
+            const stringified = JSON.stringify(input);
+            JSON.parse(stringified);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    // For string inputs, try to parse them as JSON
+    try {
+        const parsed = JSON.parse(input);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+exports.isJson = isJson;

package/littleWarden/LittleWardenNamespace.d.ts

@@ -0,0 +1,11 @@
+import { BaseNamespace } from "../_class";
+import { LittleWardenConfig } from "./index";
+/**
+ * Based on https://developers.google.com/speed/docs/insights/rest/v5/pagespeedapi/runpagespeed
+ */
+export declare class LittleWardenNamespace extends BaseNamespace {
+    client: boolean | null;
+    config: LittleWardenConfig;
+    ensureInit: () => Promise<void>;
+    getReport: (urlId: string) => Promise<any>;
+}

package/littleWarden/LittleWardenNamespace.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LittleWardenNamespace = void 0;
+const _class_1 = require("../_class");
+const axios_1 = require("../axios");
+/**
+ * Based on https://developers.google.com/speed/docs/insights/rest/v5/pagespeedapi/runpagespeed
+ */
+class LittleWardenNamespace extends _class_1.BaseNamespace {
+    constructor() {
+        super(...arguments);
+        this.client = null;
+        this.ensureInit = async () => {
+            if (!this.client) {
+                try {
+                    // There is not API client but potentially multiple keys to manage instances
+                    this.client = true;
+                }
+                catch (e) {
+                    throw new Error("Google PageSpeed Client not installed");
+                }
+            }
+        };
+        this.getReport = async (urlId) => {
+            const url = `https://littlewarden.com/api/sites/${urlId}`;
+            const apiResponse = await (0, axios_1.get)(url, {
+                headers: {
+                    "Authorization": `Token token="${this.config.apiKey}"`,
+                },
+            });
+            if (apiResponse.isSuccess()) {
+                return apiResponse.getBody();
+            }
+            return null;
+        };
+    }
+}
+exports.LittleWardenNamespace = LittleWardenNamespace;

package/littleWarden/getUrlStatus.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Get the URL Status for a given URL ID from Little Warden.
+ */
+export declare const getUrlStatus: (apiKey: string, urlId: string) => Promise<any>;