स्क्रिप्ट API संदर्भ
Hodor आपकी स्क्रिप्ट के बिल्ट-इन JavaScript इंजन में चलाता है। स्क्रिप्ट के टाइप के आधार पर Hodor सही समय पर नीचे दिए गए एंट्री फंक्शन में से एक को कॉल करता है — आप केवल आवश्यक लॉजिक लागू करते हैं। अगर कुछ भी संशोधित नहीं कर रहे हैं, तो अनावश्यक कॉल से बचने के लिए अप्रयुक्त एंट्री फंक्शन हटा दें।
उपलब्ध ग्लोबल ऑब्जेक्ट और क्लास:
| श्रेणी | नाम |
|---|---|
| एंट्री फंक्शन | onRequest, onResponse, onSessionCompleted, onSchedule, abort() |
नेटिव $ मॉड्यूल | $codec, $hash, $hmac, $crypto, $jwt, $format, $fs, $env, $uuid, $log |
| वेब स्टैंडर्ड API | fetch, HTTPClient, setTimeout / setInterval, btoa / atob / sleep / require / TextEncoder / crypto, console |
| HTTP क्लास | Request, Response, Body, Headers, URLSearchParams |
| स्टोरेज | SharedPreferences, sdk वेरिएबल |
| कॉन्टेक्स्ट | RewriteContext, CompletedContext, ScheduleContext |
स्क्रिप्ट में कहीं भी मानों की जाँच के लिए console.log(...) का उपयोग करें — आउटपुट स्क्रिप्ट के लॉग व्यू में दिखता है।
एंट्री फंक्शन
स्क्रिप्ट का पता async function डिक्लरेशन स्कैन करके लगाया जाता है — प्रत्येक एंट्री फंक्शन का पैरामीटर काउंट निश्चित है (onRequest/onResponse 3 लेते हैं, onSessionCompleted 4 लेता है, onSchedule 1 लेता है)। ऐरो-फंक्शन असाइनमेंट (let onRequest = async (...) => {}) का पता नहीं चलता। पैरामीटर नाम स्वतंत्र है ं।
onRequest(context, url, request)
Rewrite Script और Quick Request के प्री-सेंड स्क्रिप्ट के लिए बनाया गया। यह फंक्शन HTTP रिक्वेस्ट के सर्वर को भेजे जाने से पहले कॉल होता है। (संभवतः संशोधित) request रिटर्न करें।
| पैरामीटर | टाइप | विवरण |
|---|---|---|
context | RewriteContext | कॉन्टेक्स्ट ऑब्जेक्ट। |
url | string | HTTP रिक्वेस्ट का URL। |
request | Request | HTTP रिक्वेस्ट ऑब्जेक्ट। |
// modify request body
async function onRequest(context, url, request) {
// parse to Text
var text = request.body.parseText()
console.log(text)
request.body = "this is a replaced request text"
// parse to JSON
var json = request.body.parseJSON()
json["script_json"] = "JSONValue"
request.body = json
// parse to URLSearchParams
var urlencoded = request.body.parseURLSearchParams()
urlencoded.append("script", "parseURLSearchParams")
request.body = urlencoded
// Done
return request;
}
// redirect, modify path / queries / headers
async function onRequest(context, url, request) {
console.log(url);
// set a parameter, you can get it in onResponse
context.parameters["custom"] = "custom parameter on request"
// redirect
request.scheme = "http"
request.path = "/upload/json"
request.host = "192.168.3.30"
request.port = 6000
// change method
request.method = "POST"
// queries operation
request.queries.append("name", "value1") // add query
request.queries.set("name", "value2") // replace or add query
request.queries.get("name") // get query by name
request.queries.delete("name") // delete query by name
// headers operation
request.headers.delete("accept") // delete header by name
request.headers.append("hodor", "custom value") // add name-value pair
request.headers.forEach((value, name) => {
console.log(name + ":" + value)
});
// Done
return request;
}
onResponse(context, url, response)
Rewrite Script और Quick Request के पोस्ट-रिस्पॉन्स स्क्रिप्ट के लिए बनाया गया। यह फंक्शन HTTP रिस्पॉन्स के क्लाइंट को भेजे जाने से पहले कॉल होता है। (संभवतः संशोधित) response रिटर्न करें।
| पैरामीटर | टाइप | विवरण |
|---|---|---|
context | RewriteContext | कॉन्टेक्स्ट ऑब्जेक्ट। |
url | string | HTTP रिस्पॉन्स का URL। |
response | Response | HTTP रिस्पॉन्स ऑब्जेक्ट। |
// response body
async function onResponse(context, url, response) {
// parse to Text
var text = response.body.parseText()
console.log(text)
response.body = "this is a replaced response text"
// parse to JSON
var json = response.body.parseJSON()
json["script_json"] = "JSONValue"
response.body = json
// parse to URLSearchParams
var urlencoded = response.body.parseURLSearchParams()
urlencoded.append("script", "parseURLSearchParams")
response.body = urlencoded
// Done
return response;
}
// change status code and headers
async function onResponse(context, url, response) {
// get parameters set in onRequest
console.log(context.parameters["custom"]) // Output "custom parameter on request"
response.statusCode = 200 // change status code
response.statusPhrase = "OK" // change status phrase
response.headers.delete("accept")
response.headers.append("hodor", "custom value")
response.headers.forEach((value, name) => {
console.log(name + ":" + value)
});
// Done
return response
}
onSessionCompleted(context, url, request, response)
HTTP Completed Script के लिए बनाया गया। HTTP रिस्पॉन्स के लौटने के बाद असिंक्रोनस रूप से कॉल होता है, ऐप और सर्वर के बीच डेटा ट्रांसमिशन को प्रभावित नहीं करता। डेटा संग्रह और फॉरवर्डिंग के लिए उपयोगी।
| पैरामीटर | टाइप | विवरण |
|---|---|---|
context | CompletedContext | कॉन्टेक्स्ट ऑब्जेक्ट। |
url | string | HTTP रिक्वेस्ट का URL। |
request | Request | HTTP रिक्वेस्ट ऑब्जेक्ट। |
response | Response | HTTP रिस्पॉन्स ऑब्जेक्ट। |
// sample: pass session data to your own server
async function onSessionCompleted(context, url, request, response) {
try {
var reqText = request.body.parseText();
var rspText = response.body.parseText()
var params = {
"body": { // HTTPClient post body data
"url": url, // request url
"reqHeader": request.headers.encode(), // request headers
"reqText": reqText, // request body
"rspHeader": response.headers.encode(), // response headers
"rspText": rspText, // response body
},
"headers": { // HTTPClient headers
"from": "onSessionCompleted"
},
}
const rsp = await HTTPClient.post("http://192.168.3.30:8000/upload", params)
let text = rsp.body.parseText()
console.log(text)
} catch(error) {
console.log(error)
}
}
onSchedule(context)
Schedule Script के लिए बनाया गया। निर्धारित ट्रिगर स मय पर कॉल होता है (5 या 6-भाग के cron एक्सप्रेशन समर्थित हैं)। शेड्यूल लूप रोकने के लिए abort() का उपयोग करें।
| पैरामीटर | टाइप | विवरण |
|---|---|---|
context | ScheduleContext | कॉन्टेक्स्ट ऑब्जेक्ट। |
async function onSchedule(context) {
// set custom parameters for next runloop
context.parameters["custom"] = "custom parameters for next runloop";
// repeated count
console.log(`repeatedCount ${context.repeatedCount}`);
// if repeatedCount is 2, abort schedule
if (context.repeatedCount == 2) {
abort()
}
// you can also use HTTPClient to send requests
const rsp = await HTTPClient.get("https://www.apple.com")
let text = rsp.body.parseText()
console.log(text)
}
abort()
चैनल स्क्रिप्ट (onRequest / onResponse / onSchedule) के अंदर, स्क्रिप्ट रोकने और वर्तमान निष्पादन को तुरंत रद्द करने के लिए abort() कॉल करें — यह एक AbortError थ्रो करता है जिसे Hodor आपको रिपोर्ट करता है।
// ✅ correct — abort() is injected into the script scope
async function onRequest(context, url, request) {
if (url.includes("/tracking")) abort();
return request;
}
चौथे पैरामीटर के साथ onRequest(context, url, request, aborter) डिक्लेयर न करें। एंट्री फंक्शन का पैरामीटर काउंट निश्चित है — चौथा पैरामीटर एंट्री को अनडिटेक्टेबल बना देता है।
नेटिव मॉड्यूल
$-प्रीफ़िक्स वाले सभी मॉड्यूल रनटाइम सक्रिय होने पर इंजेक्ट होते हैं। वे नेटिव रूप से लागू होते हैं, (जब तक उल्लेख न हो) सिंक्रोनस रिटर्न करते हैं और स्ट्रिंग इनपुट को UTF-8 मानते हैं।
$codec — एनकोड और डिकोड
प्रोटोकॉल रूपांतरण और डेटा ट्रांसफर के लिए Base64 / Hex / URL परसेंट एनकोडिंग।
| मेथड | रिटर्न |
|---|---|
$codec.base64Encode(str) | Base64 स्ट्रिंग। |
$codec.base64Decode(str) | डिकोड की गई स्ट्रिंग; अमान्य इनपुट "" रिटर्न करता है (थ्रो नहीं करता)। |
$codec.hexEncode(str) | लोअरकेस hex स्ट्रिंग। |
$codec.hexDecode(str) | डिकोड की गई स्ट्रिंग; अमान्य वर्ण छोड़ दिए जाते हैं। |
$codec.urlEncode(str) | परसेंट-एनकोडेड स्ट्रिंग। |
$codec.urlDecode(str) | डिकोड की गई स्ट्रिंग; अमान्य सीक्वेंस जैसे हैं वैसे रिटर्न होते हैं। |
$codec.base64Encode("Hello, World!"); // "SGVsbG8sIFdvcmxkIQ=="
$codec.base64Decode("SGVsbG8sIFdvcmxkIQ=="); // "Hello, World!"
$codec.hexEncode("ABC"); // "414243"
$codec.hexDecode("414243"); // "ABC"
$codec.urlEncode("hello world&foo=bar"); // "hello%20world%26foo%3Dbar"
$hash — हैशिंग
अखंडता जाँच, कंटेंट एड्रेसिंग और अनामीकरण के लिए डाइजेस्ट गणना। लोअरकेस hex रिटर्न करता है।
| मेथड | आउटपुट लंबाई |
|---|---|
$hash.md5(str) | 32 hex वर्ण |
$hash.sha1(str) | 40 hex वर्ण |
$hash.sha256(str) | 64 hex वर्ण |
$hash.sha384(str) | 96 hex वर्ण |
$hash.sha512(str) | 128 hex वर्ण |
$hash.md5("hello"); // "5d41402abc4b2a76b9719d911017c592"
$hash.sha256("hello"); // "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
// integrity check
const checksum = $hash.sha256(JSON.stringify({user: "admin"}));
$hmac — मैसेज ऑथेंटिकेशन कोड
API साइनिंग और छेड़छाड़ पहचान के लिए कीड हैशिंग। (data, key) दोनों UTF-8 एनकोडेड हैं; लोअरकेस hex रिटर्न करता है।
| मेथड | एल्गोरिथम |
|---|---|
$hmac.md5(data, key) | HMAC-MD5 |
$hmac.sha1(data, key) | HMAC-SHA1 |
$hmac.sha256(data, key) | HMAC-SHA256 |
$hmac.sha384(data, key) | HMAC-SHA384 |
$hmac.sha512(data, key) | HMAC-SHA512 |
const signature = $hmac.sha256("important data", "my-secret-key");
const isValid = (signature === $hmac.sha256("important data", "my-secret-key")); // true
$crypto — सिमेट्रिक एन्क्रिप्शन
AES-GCM ऑथेंटिकेटेड एन्क्रिप्शन (अनुशंसित) और DES (लीगेसी संगत)।
| मेथड | रिटर्न |
|---|---|
$crypto.encryptAES(plaintext, password, options?) | Base64 साइफरटेक्स्ट; विफलता पर "Error: <reason>" स्ट्रिंग रिटर्न करता है। |
$crypto.decryptAES(ciphertext, password, options?) | प्लेनटेक्स्ट; अमान्य साइफरटेक्स्ट "Error: Invalid ciphertext" रिटर्न करता है। |
$crypto.encryptDES(plaintext, key) | DES-ECB + PKCS7, कुंजी 8 बाइट तक छोटी होती है → Base64। |
$crypto.decryptDES(ciphertext, key) | प्लेनटेक्स्ट; गैर-Base64 इनपुट "" रिटर्न करता है। |
options: { keySize: 128 \| 192 \| 256 } (डिफ़ॉल्ट 256)। AES साइफरटेक्स्ट फॉर्मेट base64(nonce[12] + ciphertext + tag[16]) है — इसे decryptAES से मैच करें; अन्य भाषाओं के साथ इंटरऑपरेट करते समय आपको यह फॉर्मेट स्वयं अनपैक करना होगा।
const encrypted = $crypto.encryptAES("sensitive data", "my-password");
$crypto.decryptAES(encrypted, "my-password"); // "sensitive data"
// 128-bit key
const e128 = $crypto.encryptAES("data", "pass", { keySize: 128 });
// errors are returned as strings, not thrown — check the prefix
const out = $crypto.decryptAES("not-base64!!", "p");
if (out.startsWith("Error:")) { /* handle error */ }
$jwt — JSON Web Token
ऑथेंटिकेशन फ्लो स्क्रिप्ट के लिए JWT निर्माण, पार्सिंग और सिग्नेचर सत्यापन (HMAC परिवार)।
| मेथड | रिटर्न |
|---|---|
$jwt.sign(payload, secret, algorithm?) | JWT स्ट्रिंग; डिफ़ॉल्ट HS256। |
$jwt.decode(token) | {header, payload} ऑब्जेक्ट (सिग्नेचर सत्यापित नहीं होता); दूषित टोकन पर null रिटर्न करता है। |
$jwt.verify(token, secret, algorithm?) | boolean — सिग्नेचर सत्यापन परिणाम। |
algorithm: "HS256" | "HS384" | "HS512"।
// sign
const payload = JSON.stringify({ sub: "user123", exp: Math.floor(Date.now() / 1000) + 3600 });
const token = $jwt.sign(payload, "my-secret", "HS256");
// decode — returns an object directly, no JSON.parse needed
const decoded = $jwt.decode(token);
decoded.header.alg; // "HS256"
decoded.payload.sub; // "user123"
// verify
$jwt.verify(token, "my-secret", "HS256"); // true
$jwt.verify(token, "wrong-secret", "HS256"); // false
// expiry check
const exp = $jwt.decode(token).payload.exp;
const expired = exp * 1000 < Date.now();
$format — डेटा फॉर्मेटिंग
लॉगिंग और डिबगिंग के लिए JSON/XML प्रिटी-प्रिंटिंग और मिनिफिकेशन। आउटपुट में JSON कुंजियाँ वर्णानुक्रम में सॉर्ट होती हैं।
| मेथड | रिटर्न |
|---|---|
$format.json(str, indent?) | प्रिटी-प्रिंटेड JSON; इंडेंट 1–8 तक सीमित (डिफ़ॉल्ट 2); अमान्य इनपुट "Error: Invalid JSON" रिटर्न करता है। |
$format.minify(str) | मिनिफाइड JSON (सॉर्टेड कुंजियाँ, बिना व्हाइटस्पेस); अमान्य इनपुट "Error: Invalid JSON" रिटर्न करता है। |
$format.xml(str) | सरल इंडेंटेड XML। |
$format.json('{"b":1,"a":2}');
// {
// "a": 2,
// "b": 1
// }
$format.json('{"a":2}', 4); // 4-space indent
$format.minify('{ "a": 2 }'); // '{"a":2}'
$format.xml('<root><child>t</child></root>');
// <root>
// <child>t</child>
// </root>
$fs — फाइल सिस्टम
स्क्रिप्ट के अंदर हल्की फाइल रीड/राइट (कॉन्फ़िग, कैश, एक्सपोर्ट)। पाथ ~ एक्सपैंशन का समर्थन करते हैं; write गायब पैरेंट डायरेक्टरी अपने आप बनाता है।
| मेथड | रिटर्न |
|---|---|
$fs.read(path) | UTF-8 कंटेंट; विफलता पर "Error: Cannot read file at <path>" रिटर्न करता है। |
$fs.readBinary(path) | Base64 के रूप में बाइट; विफलता पर "" रिटर्न करता है। |
$fs.write(path, content) | boolean — सफलता। |
$fs.exists(path) | boolean। |
$fs.delete(path) | boolean; गायब फाइलें false रिटर्न करती हैं। |
$fs.list(path) | डायरेक्टरी एंट्री की string[]; विफलता पर [] रिटर्न करता है। |
$fs.info(path) | JSON स्ट्रिंग {size, modified, isDirectory, path}; गायब पाथ undefined रिटर्न करते हैं। |
const file = $env.tmpDir() + "/hodor-test.txt";
$fs.write(file, "Hello from Hodor!");
$fs.read(file); // "Hello from Hodor!"
$fs.exists(file); // true
$fs.list($env.tmpDir()); // ["hodor-test.txt", ...]
const info = JSON.parse($fs.info(file));
info.size; // byte count
info.isDirectory; // false
$fs.delete(file); // true
विफलता के रूप प्रत्येक मेथड में अलग हैं: read "Error: ..." स्ट्रिंग रिटर्न करता है, readBinary "" रिटर्न करता है, list [] रिटर्न करता है और info undefined रिटर्न करता है — प्रत्येक को तदनुसार हैंडल करें।
$env — एनवायरनमेंट वेरिएबल
प्रोसेस एनवायरनमेंट वेरिएबल और सिस्टम पाथ। नोट: $env प्रोसेस एनवायरनमेंट है (निष्पादन के बीच साझा, प्रोसेस के साथ रहता है)। उपयोगकर्ता-सामना वाले वेरिएबल को परसिस्ट करने के लिए इसके बजाय sdk.setEnvVar या SharedPreferences का उपयोग करें।
| मेथड | रिटर्न |
|---|---|
$env.get(key) | मान; गायब कुंजियाँ "" रिटर्न करती हैं। |
$env.set(key, value) | boolean — setenv परिणाम। |
$env.all() | सभी एनवायरनमेंट वेरिएबल की JSON स्ट्रिंग। |
$env.cwd() | वर्तमान वर्किंग डायरेक्टरी। |
$env.tmpDir() | अस्थायी डायरेक्टरी। |
$env.homeDir() | उपयोगकर्ता होम डायरेक्टरी। |
$env.set("APP_VERSION", "1.0.0");
$env.get("APP_VERSION"); // "1.0.0"
const all = JSON.parse($env.all());
$uuid — UUID
UUID जनरेशन और सत्यापन (रिक्वेस्ट ID, इडेम्पोटेंसी कुंजियाँ)।
| मेथड | रिटर्न |
|---|---|
$uuid.v4() | स्टैंडर्ड v4 UUID (अपरकेस, हाइफ़नयुक्त), जैसे "550e8400-E29B-41D4-A716-446655440000"। |
$uuid.compact() | हाइफ़न-रहित, लोअरकेस रूप। |
$uuid.validate(str) | स्ट्रिंग का मान्य UUID होना। |
const id = $uuid.v4();
$uuid.compact(); // "550e8400e29b41d4a716446655440000"
$uuid.validate($uuid.v4()); // true
$uuid.validate("not-uuid"); // false
validate केवल हाइफ़नयुक्त फॉर्मेट स्वीकार करता है — validate($uuid.compact()) false रिटर्न करता है। कॉम्पैक्ट स्ट्रिंग को सत्यापित करने से पहले हाइफ़न दोबारा जोड़ें।
$log — स्ट्रक्चर्ड लॉगिंग
टाइमस्टैंप वाली, लेवल वाली लॉग लाइनें; इंजन के कंसोल सिस्टम से रूट होती हैं (स्क्रिप्ट के लॉग व्यू में संग्रहित)।
| मेथड | रिटर्न |
|---|---|
$log.log(level, message, tag?) | फॉर्मेटेड लॉग लाइन (प्रिंट भी होती है)। |
$log.debug / info / warn / error(message) | सुविधा लेवल मेथड, केवल आउटपुट। |
लॉग लाइन फॉर्मेट: [yyyy-MM-dd'T'HH:mm:ss.SSSZ] [LEVEL] [tag] message (टैग न देने पर [tag] सेगमेंट छोड़ दिया जाता है)।
$log.info("Server started on port 8080");
// [2025-07-24T01:11:45.548+0800] [INFO] Server started on port 8080
$log.log("info", "Request processed", "API");
// [2025-07-24T01:11:45.548+0800] [INFO] [API] Request processed
वेब API
fetch
स्क्रिप्ट से असली HTTP रिक्वेस्ट भेजें — Postman-स्टाइल वर्कफ़्लो का मुख्य चैनल।
fetch(url: string, options?: object) → Promise<response>
options:
| फ़ील्ड | टाइप | डिफ़ॉल्ट | विवरण |
|---|---|---|---|
method | string | "GET" | केस-असंवेदनशील; अज्ञात मान GET पर गिरते हैं। |
timeoutInterval | number | 30 | सेकंड में। |
headers | [[k, v]] या [{k: v}] | [] | दोनों रूप स्वीकार किए जाते हैं। |
textBody | string | — | रिक्वेस्ट बॉडी टेक्स्ट। |
encoding | string | — | "hex" का मतलब textBody एक hex स्ट्रिंग है। |
रिज़ॉल्व हुआ मान एक प्लेन ऑब्जेक्ट है: statusCode (नंबर), headers (सिंगल-की ऑब्जेक्ट की सरणी, डुप्लिकेट कुंजियाँ संरक्षित) और textBody() — स्वचालित कैरेक्टर-सेट पहचान के साथ {text, encoding} रिटर्न करने वाला फंक्शन (अनडिकोड करने योग्य न होने पर बॉडी {text: <hex>, encoding: "hex"} पर गिरती है)। अस्वीकृत मान एक त्रुटि संदेश स्ट्रिंग है।
// GET
const rsp = await fetch("https://httpbin.org/get");
if (rsp.statusCode === 200) {
const body = rsp.textBody(); // {text: "...", encoding: "utf-8"}
const json = JSON.parse(body.text);
}
// POST JSON
const rsp2 = await fetch("https://httpbin.org/post", {
method: "POST",
headers: [["Content-Type", "application/json"]],
textBody: JSON.stringify({a: 1}),
timeoutInterval: 10,
});
HTTPClient
HTTPClient क्लास किसी भी स्क्रिप्ट से HTTP रिक्वेस्ट भेजती है (fetch पर लागू)। सभी मेथड async हैं और statusCode, headers और textBody() वाला रिस्पॉन्स ऑब्जेक्ट रिटर्न करती हैं।
| मेथड | विवरण |
|---|---|
HTTPClient.get(url, params?) | GET रिक्वेस्ट भेजें। |
HTTPClient.post(url, params?) | POST रिक्वेस्ट भेजें। |
HTTPClient.put(url, params?) | PUT रिक्वेस्ट भेजें। |
HTTPClient.update(url, params?) | UPDATE रिक्वेस्ट भेजें। |
HTTPClient.delete(url, params?) | DELETE रिक्वेस्ट भेजें। |
HTTPClient.request(url, method, params?) | कस्टम मेथड से रिक्वेस्ट भेजें। |
params एक वैकल्पिक ऑब्जेक्ट है जिसमें:
headers: रिक्वेस्ट हेडर ऑब्जेक्ट, जैसे{"key1": "value1"}body: रिक्वेस्ट बॉडी — स्ट्रिंग, JSON ऑब्जेक्ट (स्वचालित सीरियलाइज़) या URLSearchParamstimeoutInterval: सेकंड में टाइमआउट (डिफ़ॉल्ट 60)
try {
var params = {
"headers": {"key1": "value1"},
"body": {"a": "a1", "b": "b1"},
};
const response = await HTTPClient.post("https://dummyjson.com/products/1", params);
console.log(response.textBody().text);
} catch(error) {
console.log(error);
}
टाइमर
setTimeout / setInterval / clearTimeout / clearInterval ब्राउज़रों की तरह काम करते हैं। कॉलबैक एक सीरियल इंजन क्यू पर डिस्पैच होते हैं, इसलिए टाइमर होस्ट थ्रेड से स्वतंत्र रूप से विश्वसनीय रूप से फायर होते हैं।
| फंक्शन | रिटर्न |
|---|---|
setTimeout(callback, ms) | टाइमर आईडी (स्ट्रिंग), एक बार फायर होता है। |
setInterval(callback, ms) | टाइमर आईडी, बार-बार फायर होता है। |
clearTimeout(id) / clearInterval(id) | रद्द (इडेम्पोटेंट, अज्ञात आईडी नजरअंदाज की जाती हैं)। |
await new Promise(resolve => setTimeout(resolve, 500)); // wait 0.5s
const timer = setInterval(() => console.log("tick"), 1000);
setTimeout(() => clearInterval(timer), 3500);
ग्लोबल फंक्शन
| नाम | सिग्नेचर | विवरण |
|---|---|---|
btoa(str) | (string) → string | Base64 एनकोड — UTF-8 सममित सिमेंटिक्स (ब्राउज़रों के विपरीत गैर-Latin1 स्ट्रिंग की अनुमति)। |
atob(str) | (string) → string | Base64 डिकोड; अमान् य इनपुट "" रिटर्न करता है। |
performance.now() | () → number | एपॉक के बाद के मिलीसेकंड (पेज लोड नहीं)। |
sleep(ms) | (number) → Promise | ms के बाद रिज़ॉल्व; await sleep(1000) का उपयोग करें। |
require(id) | (string) → any | CommonJS सिमेंटिक्स (module.exports) से स्क्रिप्ट लाइब्रेरी लोड करता है; कुंजी @libs/<key> है, स्क्रिप्ट-लाइब्रेरी पहचानकर्ता → स्क्रिप्ट-लाइब्रेरी नाम (अद्वितीय) → बिल्ट-इन लाइब्रेरी के क्रम में रिज़ॉल्व होती है; न मिलने पर थ्रो करता है। |
TextEncoder | new TextEncoder().encode(str) | UTF-8 एनकोड Uint8Array में (encoding हमेशा "utf-8")। |
crypto.getRandomValues(n) | (Array) → number[] | n यादृच्छिक UInt32 मानों से भरता है। |
crypto.randomUUID() | () → string | यादृच्छिक UUID (अपरकेस, हाइफ़नयुक्त)। |
btoa("Hello"); // "SGVsbG8="
atob("SGVsbG8="); // "Hello"
btoa("中文"); // works — UTF-8 bytes are encoded
performance.now(); // 1760000000000.123
await sleep(100);
const { encode } = require("@libs/base64"); // built-in lib
const { sign } = require("@libs/sign-lib"); // your script library
new TextEncoder().encode("hi"); // Uint8Array [104, 105]
लाइब्रेरी स्क्रिप्ट मॉड्यूल मैनेजर में प्रबंधित होती हैं। Require कुंजी हमेशा @libs/<key> होती है: आपकी स्क्रिप्ट लाइब्रेरी पहले पहचानकर्ता (नाम बदलने पर स्थिर) से, फिर नाम (अद्वितीय मैच) से, फिर बिल्ट-इन लाइब्रेरी @libs/base64 / @libs/hex से रिज़ॉल्व होती हैं। लाइब्रेरी module.exports से एक्सपोर्ट करती हैं, अन्य लाइब्रेरी require कर सकती हैं, और गायब कुंजी थ्रो करती है (प्री-सेंड विफलताएँ रिक्वेस्ट रद्द करती हैं, पोस्ट-रिस्पॉन्स विफलताएँ मूल रिस्पॉन्स रखती हैं)। पूरी गाइड के लिए Quick Request scripting, require() से स्क्रिप्ट लाइब्रेरी लोड करना देखें।
console
console.log / info / warn / error मान स्क्रिप्ट के लॉग व्यू में प्रिंट करता है। कई आर्ग्युमेंट सीरियलाइज़ होते हैं, इसलिए ऑब्जेक्ट और सरणी सीधे लॉग कर सकते हैं:
console.log("headers", {Accept: "application/json"}, [1, 2, 3]);
$log स्ट्रक्चर्ड, लेवल वाला आउटपुट देता है (देखें $log) — दोनों चैनल Hodor के स्क्रिप्ट लॉग व्यू में दिखते हैं।
HTTP क्लास
Request
Request क्लास onRequest / onSessionCompleted को पास की गई पैकेज्ड HTTP रिक्वेस्ट है।
| मेंबर | टाइप | विवरण |
|---|---|---|
scheme | string (get / set) | रिक्वेस्ट की स्कीम, जैसे https। |
host | string (get / set) | रिक्वेस्ट का होस्ट। |
port | number (get / set) | रिक्वेस्ट का पोर्ट। |
path | string (get / set) | रिक्वेस्ट का पाथ। |
method | string (get / set) | HTTP मेथड, जैसे GET। |
queries | URLSearchParams (get) | रिक्वेस्ट के क्वेरी पैरामीटर। |
headers | Headers (get) | रिक्वेस ्ट के हेडर। |
body | Body (get) / string | Map | Array | URLSearchParams (set) | रिक्वेस्ट की बॉडी। |
हेडर .set() / .append() से संशोधित होने चाहिए — इंडेक्स असाइनमेंट (जैसे headers["X-Key"] = v) नजरअंदाज किया जाता है।
आप स्वयं भी रिक्वेस्ट बना सकते हैं:
const request = new Request({
scheme: 'https',
host: 'example.com',
port: 8080,
path: '/api',
method: 'GET',
queries: 'param1=value1¶m2=value2',
headers: [
['Content-Type', 'application/json'],
['Authorization', 'Bearer token']
],
textBody: '{"key": "value"}'
});
console.log(request.encode());
Response
Response क्लास onResponse / onSessionCompleted को पास की गई HTTP रिस्पॉन्स का प्रतिनिधित्व करती है।
| मेंबर | टाइप | विवरण |
|---|---|---|
statusCode | number (get / set) | रिस्पॉन्स का स्टेटस कोड। |
statusPhrase | string (get / set) | रिस्पॉन्स का स्टेटस फ्रेज, जैसे OK। |
headers | Headers (get) | रिस्पॉन्स के हेडर। |
body | Body (get) / string | Map | Array | URLSearchParams (set) | रिस्पॉन्स की बॉडी। |
const response = new Response({
statusCode: 404,
statusPhrase: 'Not Found',
headers: {
'Content-Type': 'application/json',
'Cache-Control': 'no-cache'
},
textBody: '{"error": "Resource not found"}'
});
console.log(response.encode());