@scalar/snippetz 0.9.26 → 0.9.28

package/dist/clients/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/clients/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AA2CpD;;GAEG;AACH,eAAO,MAAM,OAAO,EAAE,MAAM,EA+H3B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/clients/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AA4CpD;;GAEG;AACH,eAAO,MAAM,OAAO,EAAE,MAAM,EAqI3B,CAAA"}

package/dist/clients/index.js

@@ -15,6 +15,7 @@ import { jsFetch } from '../plugins/js/fetch/index.js';
 import { jsJquery } from '../plugins/js/jquery/index.js';
 import { jsOfetch } from '../plugins/js/ofetch/index.js';
 import { jsXhr } from '../plugins/js/xhr/index.js';
+import { juliaHttp } from '../plugins/julia/http/index.js';
 import { kotlinOkhttp } from '../plugins/kotlin/okhttp/index.js';
 import { nodeAxios } from '../plugins/node/axios/index.js';
 import { nodeFetch } from '../plugins/node/fetch/index.js';
@@ -96,6 +97,12 @@ export const clients = [
         default: 'fetch',
         clients: [jsFetch, jsAxios, jsOfetch, jsJquery, jsXhr],
     },
+    {
+        key: 'julia',
+        title: 'Julia',
+        default: 'http',
+        clients: [juliaHttp],
+    },
     {
         key: 'kotlin',
         title: 'Kotlin',

package/dist/libs/julia.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Wraps a string in double quotes, escaped and ready to be inserted into Julia source code.
+ */
+export declare const wrapInDoubleQuotes: (str: string) => string;
+/**
+ * Produces an indented string using 4 spaces per level, following the Julia style guide.
+ */
+export declare const indent: (level: number, text: string) => string;
+/**
+ * Renders a collection (a vector, a `Dict`, a `HTTP.Form`, …) from already formatted entries.
+ *
+ * Short collections stay on a single line, everything else gets one entry per
+ * line so that generated snippets remain readable.
+ *
+ * @param entries - The formatted entries, without trailing commas
+ * @param open - The opening token, for example `[` or `Dict(`
+ * @param close - The closing token, for example `]` or `)`
+ * @param level - The indentation level the collection itself sits at
+ */
+export declare const formatCollection: (entries: string[], open: string, close: string, level: number) => string;
+/**
+ * Formats `name => value` pairs as a Julia vector of pairs, which is what HTTP.jl
+ * expects for headers and query parameters.
+ */
+export declare const formatPairVector: (pairs: {
+    name: string;
+    value: string;
+}[], level: number) => string;
+/**
+ * Formats `name => value` pairs as a Julia `Dict`.
+ */
+export declare const formatDict: (pairs: {
+    name: string;
+    value: string;
+}[], level: number) => string;
+/**
+ * Converts a parsed JSON value into the equivalent Julia literal.
+ *
+ * Objects become `Dict`s and arrays become vectors, so the snippet can be edited
+ * with plain Julia syntax before it is serialized with `JSON.json`.
+ */
+export declare const formatValue: (value: unknown, level: number) => string;
+//# sourceMappingURL=julia.d.ts.map

package/dist/libs/julia.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"julia.d.ts","sourceRoot":"","sources":["../../src/libs/julia.ts"],"names":[],"mappings":"AAeA;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAAI,KAAK,MAAM,KAAG,MAAkC,CAAA;AAEnF;;GAEG;AACH,eAAO,MAAM,MAAM,GAAI,OAAO,MAAM,EAAE,MAAM,MAAM,KAAG,MAA2C,CAAA;AAEhG;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,GAAI,SAAS,MAAM,EAAE,EAAE,MAAM,MAAM,EAAE,OAAO,MAAM,EAAE,OAAO,MAAM,KAAG,MAchG,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAAE,EAAE,OAAO,MAAM,KAAG,MAMxF,CAAA;AAEH;;GAEG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAAE,EAAE,OAAO,MAAM,KAAG,MAMlF,CAAA;AAEH;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,OAAO,EAAE,OAAO,MAAM,KAAG,MAsC3D,CAAA"}

package/dist/libs/julia.js

@@ -0,0 +1,79 @@
+/**
+ * Escapes a string for use in a Julia double-quoted string literal.
+ *
+ * Julia interpolates `$` inside string literals, so it has to be escaped as
+ * well, otherwise `"$foo"` would be evaluated instead of sent literally.
+ */
+const escapeString = (str) => str
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .replace(/\$/g, '\\$')
+    .replace(/\n/g, '\\n')
+    .replace(/\r/g, '\\r')
+    .replace(/\t/g, '\\t');
+/**
+ * Wraps a string in double quotes, escaped and ready to be inserted into Julia source code.
+ */
+export const wrapInDoubleQuotes = (str) => `"${escapeString(str)}"`;
+/**
+ * Produces an indented string using 4 spaces per level, following the Julia style guide.
+ */
+export const indent = (level, text) => `${' '.repeat(level * 4)}${text}`;
+/**
+ * Renders a collection (a vector, a `Dict`, a `HTTP.Form`, …) from already formatted entries.
+ *
+ * Short collections stay on a single line, everything else gets one entry per
+ * line so that generated snippets remain readable.
+ *
+ * @param entries - The formatted entries, without trailing commas
+ * @param open - The opening token, for example `[` or `Dict(`
+ * @param close - The closing token, for example `]` or `)`
+ * @param level - The indentation level the collection itself sits at
+ */
+export const formatCollection = (entries, open, close, level) => {
+    if (entries.length === 0) {
+        return `${open}${close}`;
+    }
+    const [first] = entries;
+    if (entries.length === 1 && first && !first.includes('\n')) {
+        return `${open}${first}${close}`;
+    }
+    const lines = entries.map((entry) => indent(level + 1, entry)).join(',\n');
+    return `${open}\n${lines}\n${indent(level, close)}`;
+};
+/**
+ * Formats `name => value` pairs as a Julia vector of pairs, which is what HTTP.jl
+ * expects for headers and query parameters.
+ */
+export const formatPairVector = (pairs, level) => formatCollection(pairs.map(({ name, value }) => `${wrapInDoubleQuotes(name)} => ${wrapInDoubleQuotes(value)}`), '[', ']', level);
+/**
+ * Formats `name => value` pairs as a Julia `Dict`.
+ */
+export const formatDict = (pairs, level) => formatCollection(pairs.map(({ name, value }) => `${wrapInDoubleQuotes(name)} => ${wrapInDoubleQuotes(value)}`), 'Dict(', ')', level);
+/**
+ * Converts a parsed JSON value into the equivalent Julia literal.
+ *
+ * Objects become `Dict`s and arrays become vectors, so the snippet can be edited
+ * with plain Julia syntax before it is serialized with `JSON.json`.
+ */
+export const formatValue = (value, level) => {
+    if (value === null || value === undefined) {
+        return 'nothing';
+    }
+    if (typeof value === 'boolean') {
+        return value ? 'true' : 'false';
+    }
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? String(value) : 'nothing';
+    }
+    if (typeof value === 'string') {
+        return wrapInDoubleQuotes(value);
+    }
+    if (Array.isArray(value)) {
+        return formatCollection(value.map((item) => formatValue(item, level + 1)), '[', ']', level);
+    }
+    if (typeof value === 'object') {
+        return formatCollection(Object.entries(value).map(([key, item]) => `${wrapInDoubleQuotes(key)} => ${formatValue(item, level + 1)}`), 'Dict(', ')', level);
+    }
+    return wrapInDoubleQuotes(String(value));
+};

package/dist/plugins/julia/http/http.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from '@scalar/types/snippetz';
+/**
+ * julia/http
+ */
+export declare const juliaHttp: Plugin;
+//# sourceMappingURL=http.d.ts.map

package/dist/plugins/julia/http/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../../../src/plugins/julia/http/http.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,MAAM,EAAuB,MAAM,wBAAwB,CAAA;AAsIrF;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,MAgFvB,CAAA"}

package/dist/plugins/julia/http/http.js

@@ -0,0 +1,154 @@
+import { normalizeMethod } from '../../../libs/http.js';
+import { formatCollection, formatDict, formatPairVector, formatValue, indent, wrapInDoubleQuotes } from '../../../libs/julia.js';
+/** Verbs HTTP.jl exposes as `HTTP.<verb>(url, headers, body)` helpers. */
+const VERBS_WITH_BODY = ['POST', 'PUT', 'PATCH', 'DELETE', 'QUERY'];
+/** Verbs HTTP.jl exposes as `HTTP.<verb>(url, headers)` helpers, without a body argument. */
+const VERBS_WITHOUT_BODY = ['GET', 'HEAD', 'OPTIONS'];
+/** The indentation level of the arguments inside a multi-line request call. */
+const ARGUMENT_LEVEL = 1;
+/**
+ * Builds the Julia expression for a multipart part, using `HTTP.Multipart` for
+ * file uploads and a plain string for everything else.
+ */
+const formatMultipartPart = (param) => {
+    const name = wrapInDoubleQuotes(param.name);
+    if (param.fileName === undefined) {
+        return `${name} => ${wrapInDoubleQuotes(param.value ?? '')}`;
+    }
+    const file = wrapInDoubleQuotes(param.fileName);
+    const args = [file, `open(${file})`];
+    if (param.contentType) {
+        args.push(wrapInDoubleQuotes(param.contentType));
+    }
+    return `${name} => HTTP.Multipart(${args.join(', ')})`;
+};
+/**
+ * Turns the request body into a Julia expression.
+ *
+ * JSON payloads are rendered as `Dict`s so they can be edited without touching
+ * the raw JSON, form bodies use the native types HTTP.jl knows how to encode
+ * (`Dict` for url-encoded, `HTTP.Form` for multipart) and anything else is sent
+ * as a plain string.
+ */
+const getBody = (postData) => {
+    if (!postData) {
+        return undefined;
+    }
+    const { mimeType, text, params } = postData;
+    if (mimeType === 'application/json' && text) {
+        try {
+            return {
+                value: `JSON.json(${formatValue(JSON.parse(text), ARGUMENT_LEVEL)})`,
+                packages: ['JSON'],
+                omitContentType: false,
+            };
+        }
+        catch {
+            // Not valid JSON, fall through and send the raw text
+        }
+    }
+    if (mimeType === 'multipart/form-data' && params?.length) {
+        return {
+            value: formatCollection(params.map(formatMultipartPart), 'HTTP.Form([', '])', ARGUMENT_LEVEL),
+            packages: [],
+            omitContentType: true,
+        };
+    }
+    if (mimeType === 'application/x-www-form-urlencoded' && params?.length) {
+        return {
+            value: formatDict(params.map((param) => ({ name: param.name, value: param.value ?? '' })), ARGUMENT_LEVEL),
+            packages: [],
+            omitContentType: false,
+        };
+    }
+    if (!text) {
+        return undefined;
+    }
+    return { value: wrapInDoubleQuotes(text), packages: [], omitContentType: false };
+};
+/**
+ * Assembles the request call, keeping it on a single line when the URL is the
+ * only argument and spreading it over multiple lines otherwise.
+ */
+const buildCall = (callee, required, optional, keywords) => {
+    const positional = [...required, ...optional];
+    if (optional.length === 0 && keywords.length === 0) {
+        return [`response = ${callee}(${positional.join(', ')})`];
+    }
+    const lines = [`response = ${callee}(`];
+    positional.forEach((argument, index) => {
+        const isLast = index === positional.length - 1;
+        const separator = isLast ? (keywords.length ? ';' : '') : ',';
+        lines.push(`${indent(ARGUMENT_LEVEL, argument)}${separator}`);
+    });
+    keywords.forEach((keyword, index) => {
+        lines.push(`${indent(ARGUMENT_LEVEL, keyword)}${index === keywords.length - 1 ? '' : ','}`);
+    });
+    lines.push(')');
+    return lines;
+};
+/**
+ * julia/http
+ */
+export const juliaHttp = {
+    target: 'julia',
+    client: 'http',
+    title: 'HTTP.jl',
+    generate(request, configuration) {
+        const normalizedRequest = {
+            url: 'https://example.com',
+            ...request,
+        };
+        const method = normalizeMethod(normalizedRequest.method);
+        const body = getBody(normalizedRequest.postData);
+        // Deduplicate headers, dropping the content type when HTTP.jl generates it
+        const headers = new Map();
+        for (const header of normalizedRequest.headers ?? []) {
+            if (!header.name || (body?.omitContentType && header.name.toLowerCase() === 'content-type')) {
+                continue;
+            }
+            headers.set(header.name, header.value ?? '');
+        }
+        const verb = [...VERBS_WITH_BODY, ...VERBS_WITHOUT_BODY].includes(method) ? method.toLowerCase() : undefined;
+        const callee = verb ? `HTTP.${verb}` : 'HTTP.request';
+        const url = wrapInDoubleQuotes(normalizedRequest.url);
+        const required = verb ? [url] : [wrapInDoubleQuotes(method), url];
+        const optional = [];
+        const keywords = [];
+        if (headers.size) {
+            optional.push(formatPairVector([...headers].map(([name, value]) => ({ name, value })), ARGUMENT_LEVEL));
+        }
+        if (body) {
+            // The first positional argument after the URL is always the headers, both
+            // for the verb helpers (`HTTP.post(url, headers, body)`) and for
+            // `HTTP.request(method, url, headers, body)`. A body passed positionally
+            // without headers in front of it would therefore be read as the headers
+            // argument, so it has to go through the `body =` keyword instead.
+            // `HTTP.get`, `HTTP.head` and `HTTP.options` never take a positional body.
+            if (VERBS_WITHOUT_BODY.includes(method) || headers.size === 0) {
+                keywords.push(`body = ${body.value}`);
+            }
+            else {
+                optional.push(body.value);
+            }
+        }
+        if (normalizedRequest.queryString?.length) {
+            keywords.push(`query = ${formatPairVector(normalizedRequest.queryString, ARGUMENT_LEVEL)}`);
+        }
+        if (normalizedRequest.cookies?.length) {
+            keywords.push(`cookies = ${formatDict(normalizedRequest.cookies, ARGUMENT_LEVEL)}`);
+        }
+        if (configuration?.auth?.username && configuration?.auth?.password) {
+            const { username, password } = configuration.auth;
+            keywords.push(`basicauth = (${wrapInDoubleQuotes(username)}, ${wrapInDoubleQuotes(password)})`);
+        }
+        const packages = ['HTTP', ...(body?.packages ?? [])];
+        return [
+            ...packages.map((name) => `using ${name}`),
+            '',
+            ...buildCall(callee, required, optional, keywords),
+            '',
+            'println(String(response.body))',
+        ].join('\n');
+    },
+};

package/dist/plugins/julia/http/index.d.ts

@@ -0,0 +1,2 @@
+export { juliaHttp } from './http.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/julia/http/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/julia/http/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA"}

package/dist/plugins/julia/http/index.js

@@ -0,0 +1 @@
+export { juliaHttp } from './http.js';

package/dist/snippetz.d.ts

@@ -6,7 +6,7 @@ export declare function snippetz(): {
     print<T extends TargetId>(target: T, client: ClientId<T>, request: Partial<HarRequest>): string | undefined;
     clients(): import("@scalar/types/snippetz").Target[];
     plugins(): {
-        target: "c" | "clojure" | "csharp" | "dart" | "fsharp" | "go" | "http" | "java" | "js" | "kotlin" | "node" | "objc" | "ocaml" | "php" | "powershell" | "python" | "r" | "ruby" | "rust" | "shell" | "swift";
+        target: "c" | "clojure" | "csharp" | "dart" | "fsharp" | "go" | "http" | "java" | "js" | "julia" | "kotlin" | "node" | "objc" | "ocaml" | "php" | "powershell" | "python" | "r" | "ruby" | "rust" | "shell" | "swift";
         client: "http" | "libcurl" | "clj_http" | "httpclient" | "restsharp" | "native" | "http1.1" | "asynchttp" | "nethttp" | "okhttp" | "unirest" | "axios" | "fetch" | "jquery" | "ofetch" | "xhr" | "undici" | "nsurlsession" | "cohttp" | "curl" | "guzzle" | "laravel" | "restmethod" | "webrequest" | "python3" | "requests" | "aiohttp" | "httpx_sync" | "httpx_async" | "httr2" | "reqwest" | "httpie" | "wget";
     }[];
     findPlugin: <T extends TargetId>(target: T | string, client: ClientId<T> | string) => import("@scalar/types/snippetz").Plugin | undefined;

package/package.json

@@ -9,7 +9,7 @@
     "url": "git+https://github.com/scalar/scalar.git",
     "directory": "packages/snippetz"
   },
-  "version": "0.9.26",
+  "version": "0.9.28",
   "engines": {
     "node": ">=22"
   },
@@ -112,6 +112,11 @@
       "types": "./dist/plugins/js/xhr/index.d.ts",
       "default": "./dist/plugins/js/xhr/index.js"
     },
+    "./plugins/julia/http": {
+      "import": "./dist/plugins/julia/http/index.js",
+      "types": "./dist/plugins/julia/http/index.d.ts",
+      "default": "./dist/plugins/julia/http/index.js"
+    },
     "./plugins/kotlin/okhttp": {
       "import": "./dist/plugins/kotlin/okhttp/index.js",
       "types": "./dist/plugins/kotlin/okhttp/index.d.ts",
@@ -238,10 +243,10 @@
     "CHANGELOG"
   ],
   "dependencies": {
-    "js-base64": "^3.7.8",
+    "js-base64": "^3.9.2",
     "stringify-object": "^6.0.0",
-    "@scalar/helpers": "0.10.0",
-    "@scalar/types": "0.18.0"
+    "@scalar/helpers": "0.11.1",
+    "@scalar/types": "0.18.2"
   },
   "devDependencies": {
     "@types/stringify-object": "^4.0.5",