@apiverve/maze 1.1.12

package/examples/basic.js

@@ -0,0 +1,40 @@
+/**
+ * Basic Example - Maze Generator API
+ *
+ * This example demonstrates how to use the Maze Generator API.
+ * Make sure to set your API key in the .env file or replace '[YOUR_API_KEY]' below.
+ */
+
+require('dotenv').config();
+const mazeAPI = require('../index.js');
+
+// Initialize the API client
+const api = new mazeAPI({
+    api_key: process.env.API_KEY || '[YOUR_API_KEY]'
+});
+
+// Example query
+var query = {
+  width: 15,
+  height: 15,
+  difficulty: "medium"
+};
+
+// Make the API request using callback
+console.log('Making request to Maze Generator API...\n');
+
+api.execute(query, function (error, data) {
+    if (error) {
+        console.error('Error occurred:');
+        if (error.error) {
+            console.error('Message:', error.error);
+            console.error('Status:', error.status);
+        } else {
+            console.error(JSON.stringify(error, null, 2));
+        }
+        return;
+    }
+
+    console.log('Response:');
+    console.log(JSON.stringify(data, null, 2));
+});

package/index.d.ts

@@ -0,0 +1,46 @@
+declare module '@apiverve/maze' {
+  export interface mazeOptions {
+    api_key: string;
+    secure?: boolean;
+  }
+
+  export interface mazeResponse {
+    status: string;
+    error: string | null;
+    data: MazeGeneratorData;
+    code?: number;
+  }
+
+
+  interface MazeGeneratorData {
+      width:         number;
+      height:        number;
+      difficulty:    string;
+      start:         End;
+      end:           End;
+      grid:          Array<number[]>;
+      html:          string;
+      image:         Image;
+      solutionImage: Image;
+  }
+  
+  interface End {
+      x: number;
+      y: number;
+  }
+  
+  interface Image {
+      imageName:   string;
+      format:      string;
+      downloadURL: string;
+      expires:     number;
+  }
+
+  export default class mazeWrapper {
+    constructor(options: mazeOptions);
+
+    execute(callback: (error: any, data: mazeResponse | null) => void): Promise<mazeResponse>;
+    execute(query: Record<string, any>, callback: (error: any, data: mazeResponse | null) => void): Promise<mazeResponse>;
+    execute(query?: Record<string, any>): Promise<mazeResponse>;
+  }
+}

package/index.js

@@ -0,0 +1,124 @@
+const axios = require('axios');
+
+class mazeWrapper {
+
+    constructor(options) {
+        if (!options || typeof options !== 'object') {
+            throw new Error('Options object must be provided. See documentation: https://docs.apiverve.com/ref/maze');
+        }
+
+        const { api_key, secure = true } = options;
+
+        if (!api_key || typeof api_key !== 'string') {
+            throw new Error('API key must be provided as a non-empty string. Get your API key at: https://apiverve.com');
+        }
+
+        // Validate API key format (GUID or alphanumeric with hyphens)
+        const apiKeyPattern = /^[a-zA-Z0-9-]+$/;
+        if (!apiKeyPattern.test(api_key)) {
+            throw new Error('Invalid API key format. API key must be alphanumeric and may contain hyphens. Get your API key at: https://apiverve.com');
+        }
+
+        // Check minimum length (GUIDs are typically 36 chars with hyphens, or 32 without)
+        const trimmedKey = api_key.replace(/-/g, '');
+        if (trimmedKey.length < 32) {
+            throw new Error('Invalid API key. API key appears to be too short. Get your API key at: https://apiverve.com');
+        }
+
+        if (typeof secure !== 'boolean') {
+            throw new Error('Secure parameter must be a boolean value.');
+        }
+
+        this.APIKey = api_key;
+        this.IsSecure = secure;
+
+        // secure is deprecated, all requests must be made over HTTPS
+        this.baseURL = 'https://api.apiverve.com/v1/maze';
+    }
+
+    async execute(query, callback) {
+        // Handle different argument patterns
+        if(arguments.length === 0) {
+            // execute() - no args
+            query = {};
+            callback = null;
+        } else if(arguments.length === 1) {
+            if (typeof query === 'function') {
+                // execute(callback)
+                callback = query;
+                query = {};
+            } else {
+                // execute(query)
+                callback = null;
+            }
+        } else {
+            // execute(query, callback)
+            if (!query || typeof query !== 'object') {
+                throw new Error('Query parameters must be provided as an object.');
+            }
+        }
+
+        var requiredParams = [];
+        if (requiredParams.length > 0) {
+            for (var i = 0; i < requiredParams.length; i++) {
+                if (!query[requiredParams[i]]) {
+                    throw new Error(`Required parameter [${requiredParams[i]}] is missing. See documentation: https://docs.apiverve.com/ref/maze`);
+                }
+            }
+        }
+
+        const method = 'GET';
+        const url = method === 'POST' ? this.baseURL : this.constructURL(query);
+
+        try {
+            const response = await axios({
+                method,
+                url,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': this.APIKey,
+                    'auth-mode': 'npm-package'
+                },
+                data: method === 'POST' ? query : undefined
+            });
+
+            const data = response.data;
+            if (callback) callback(null, data);
+            return data;
+        } catch (error) {
+            let apiError;
+
+            if (error.response && error.response.data) {
+                apiError = error.response.data;
+            } else if (error.message) {
+                apiError = { error: error.message, status: 'error' };
+            } else {
+                apiError = { error: 'An unknown error occurred', status: 'error' };
+            }
+
+            if (callback) {
+                callback(apiError, null);
+                return; // Don't throw if callback is provided
+            }
+
+            throw apiError;
+        }
+    }
+
+    constructURL(query) {
+        let url = this.baseURL;
+
+        if(query && typeof query === 'object') 
+        {
+            if (Object.keys(query).length > 0) {
+                const queryString = Object.keys(query)
+                    .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(query[key])}`)
+                    .join('&');
+                url += `?${queryString}`;
+            }
+        }
+        return url;
+    }
+}
+
+module.exports = mazeWrapper;

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@apiverve/maze",
+  "version": "1.1.12",
+  "description": "Maze Generator creates random mazes using recursive backtracking algorithm with customizable size and difficulty.",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "test": "mocha",
+    "example": "node examples/basic.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/apiverve/maze-api.git",
+    "directory": "npm"
+  },
+  "keywords": [
+    "maze", "labyrinth", "puzzle generator", "printable maze", "pathfinding"
+  ],
+  "author": "APIVerve <hello@apiverve.com> (http://apiverve.com/)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/apiverve/maze-api/issues"
+  },
+  "homepage": "https://apiverve.com/marketplace/maze?utm_source=npm",
+  "devDependencies": {
+    "mocha": "^11.0.1",
+    "chai": "^5.1.2",
+    "dotenv": "^16.4.7"
+  },
+  "dependencies": {
+    "node-fetch": "^3.3.2",
+    "promise": "^8.3.0",
+    "axios": "1.13.2"
+  }
+}

package/tmp/build.dat

@@ -0,0 +1 @@
+#