@scalar/snippetz 0.7.4 → 0.7.6

package/dist/libs/php.js

@@ -1,57 +1,67 @@
+/**
+ * Generates a consistent indentation string based on the specified indentation level.
+ */
 function indent(level) {
-  return " ".repeat(level * 2);
+    return ' '.repeat(level * 2);
 }
-class Raw {
-  constructor(value) {
-    this.value = value;
-  }
+/**
+ * Represents a raw PHP code that should not be quoted, e.g. `fopen('test.txt', 'r')`.
+ * If it consists of multiple lines, they will be indented properly.
+ */
+export class Raw {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
 }
-function objectToString(data, level = 0) {
-  if (data === null || data === void 0) {
-    return "null";
-  }
-  if (data instanceof Raw) {
-    const lines = data.value.split("\n");
-    if (lines.length > 1) {
-      const innerIndentation = indent(level + 1);
-      return lines.map((line, index) => {
-        if (index === 0) {
-          return line;
+/**
+ * Converts a JavaScript object or value into a PHP array or scalar string representation.
+ * Handles nested arrays and objects, proper string escaping, and preserves indentation for readability.
+ *
+ * @example
+ * objectToString({ foo: 'bar', baz: 'qux' }) // => "['foo' => 'bar', 'baz' => 'qux']"
+ */
+export function objectToString(data, level = 0) {
+    if (data === null || data === undefined) {
+        return 'null';
+    }
+    if (data instanceof Raw) {
+        const lines = data.value.split('\n');
+        if (lines.length > 1) {
+            const innerIndentation = indent(level + 1);
+            return lines
+                .map((line, index) => {
+                if (index === 0) {
+                    return line;
+                }
+                return `${innerIndentation}${line}`;
+            })
+                .join('\n');
         }
-        return `${innerIndentation}${line}`;
-      }).join("\n");
+        return data.value;
+    }
+    if (typeof data === 'string') {
+        return `'${data.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
     }
-    return data.value;
-  }
-  if (typeof data === "string") {
-    return `'${data.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
-  }
-  if (typeof data === "number" || typeof data === "boolean") {
-    return String(data);
-  }
-  if (Array.isArray(data)) {
-    if (data.length === 0) {
-      return "[]";
+    if (typeof data === 'number' || typeof data === 'boolean') {
+        return String(data);
     }
-    const items = data.map((item) => objectToString(item, level + 1)).join(",\n" + indent(level + 1));
-    return `[
-${indent(level + 1)}${items}
-${indent(level)}]`;
-  }
-  if (typeof data === "object") {
-    const entries = Object.entries(data);
-    if (entries.length === 0) {
-      return "[]";
+    if (Array.isArray(data)) {
+        if (data.length === 0) {
+            return '[]';
+        }
+        const items = data.map((item) => objectToString(item, level + 1)).join(',\n' + indent(level + 1));
+        return `[\n${indent(level + 1)}${items}\n${indent(level)}]`;
+    }
+    if (typeof data === 'object') {
+        const entries = Object.entries(data);
+        if (entries.length === 0) {
+            return '[]';
+        }
+        const items = entries
+            .map(([key, value]) => `'${key}' => ${objectToString(value, level + 1)}`)
+            .join(',\n' + indent(level + 1));
+        return `[\n${indent(level + 1)}${items}\n${indent(level)}]`;
     }
-    const items = entries.map(([key, value]) => `'${key}' => ${objectToString(value, level + 1)}`).join(",\n" + indent(level + 1));
-    return `[
-${indent(level + 1)}${items}
-${indent(level)}]`;
-  }
-  return "null";
+    return 'null';
 }
-export {
-  Raw,
-  objectToString
-};
-//# sourceMappingURL=php.js.map

package/dist/libs/rust.js

@@ -1,39 +1,66 @@
+/**
+ * Escapes a string for use in Rust string literals
+ * Handles quotes, backslashes, newlines, and other special characters
+ */
 function escapeString(str) {
-  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/\0/g, "\\0");
+    return str
+        .replace(/\\/g, '\\\\') // Escape backslashes first
+        .replace(/"/g, '\\"') // Escape double quotes
+        .replace(/\n/g, '\\n') // Escape newlines
+        .replace(/\r/g, '\\r') // Escape carriage returns
+        .replace(/\t/g, '\\t') // Escape tabs
+        .replace(/\0/g, '\\0'); // Escape null bytes
 }
-function wrapInDoubleQuotes(str) {
-  return `"${escapeString(str)}"`;
+/**
+ * Formats and escapes a string safely for use in Rust string literals.
+ * The returned value is the escaped string, surrounded by double quotes,
+ * making it ready for direct insertion into Rust source code.
+ */
+export function wrapInDoubleQuotes(str) {
+    return `"${escapeString(str)}"`;
 }
-function indent(level, text) {
-  const spaces = " ".repeat(level * 4);
-  return `${spaces}${text}`;
+/**
+ * Produces an indented string using 4 spaces per indent level,
+ * in accordance with rustfmt style guidelines.
+ * Useful for code generation scenarios requiring precise formatting.
+ */
+export function indent(level, text) {
+    const spaces = ' '.repeat(level * 4);
+    return `${spaces}${text}`;
 }
-function createChain(method, ...args) {
-  return indent(1, `.${method}(${args.join(", ")})`);
+/**
+ * Formats a Rust chained method call with standard 4-space indentation.
+ * Useful for fluent API or builder patterns in generated Rust code.
+ */
+export function createChain(method, ...args) {
+    return indent(1, `.${method}(${args.join(', ')})`);
 }
-function formatJson(jsonText) {
-  try {
-    const jsonData = JSON.parse(jsonText);
-    const prettyJson = JSON.stringify(jsonData, null, 4);
-    const lines = prettyJson.split("\n");
-    const rustLines = lines.map((line, index) => {
-      if (index === 0) {
-        return line;
-      }
-      if (index === lines.length - 1) {
-        return indent(1, line);
-      }
-      return indent(1, line);
-    });
-    return rustLines.join("\n");
-  } catch {
-    return jsonText;
-  }
+/**
+ * Properly formats a JSON snippet for Rust's `serde_json::json!` macro,
+ * applying idiomatic 4-space indentation to each line for improved readability.
+ */
+export function formatJson(jsonText) {
+    try {
+        const jsonData = JSON.parse(jsonText);
+        const prettyJson = JSON.stringify(jsonData, null, 4);
+        // Split into lines and add proper indentation for Rust
+        const lines = prettyJson.split('\n');
+        const rustLines = lines.map((line, index) => {
+            if (index === 0) {
+                // First line (opening brace)
+                return line;
+            }
+            if (index === lines.length - 1) {
+                // Last line (closing brace)
+                return indent(1, line);
+            }
+            // Middle lines
+            return indent(1, line);
+        });
+        return rustLines.join('\n');
+    }
+    catch {
+        // If JSON parsing fails, return the original text
+        return jsonText;
+    }
 }
-export {
-  createChain,
-  formatJson,
-  indent,
-  wrapInDoubleQuotes
-};
-//# sourceMappingURL=rust.js.map

package/dist/libs/shell.js

@@ -1,5 +1,14 @@
-const escapeSingleQuotes = (value) => value.replace(/'/g, "'\\''");
-export {
-  escapeSingleQuotes
-};
-//# sourceMappingURL=shell.js.map
+/**
+ * Escapes single quotes in a string for safe use inside bash single-quoted strings.
+ * In bash, you cannot directly escape a single quote inside single quotes (i.e., 'hell\'o' is invalid).
+ * Instead, you must close the single quotes, insert an escaped single quote, then reopen the single quotes:
+ *
+ * ```bash
+ * 'hell'\''o'
+ * ```
+ *
+ * This is why escaping a single quote in bash is not as simple as just using a backslash (\' does not work).
+ *
+ * @example "hell'o" becomes "hell'\''o"
+ */
+export const escapeSingleQuotes = (value) => value.replace(/'/g, "'\\''");

package/dist/plugins/c/libcurl/index.js

@@ -1,5 +1 @@
-import { cLibcurl } from "./libcurl.js";
-export {
-  cLibcurl
-};
-//# sourceMappingURL=index.js.map
+export { cLibcurl } from './libcurl.js';

package/dist/plugins/c/libcurl/libcurl.js

@@ -1,14 +1,14 @@
-import { libcurl } from "../../../httpsnippet-lite/targets/c/libcurl/client.js";
-import { convertWithHttpSnippetLite } from "../../../utils/convertWithHttpSnippetLite.js";
-const cLibcurl = {
-  target: "c",
-  client: "libcurl",
-  title: "Libcurl",
-  generate(request) {
-    return convertWithHttpSnippetLite(libcurl, request);
-  }
+import { libcurl } from '../../../httpsnippet-lite/targets/c/libcurl/client.js';
+import { convertWithHttpSnippetLite } from '../../../utils/convertWithHttpSnippetLite.js';
+/**
+ * c/libcurl
+ */
+export const cLibcurl = {
+    target: 'c',
+    client: 'libcurl',
+    title: 'Libcurl',
+    generate(request) {
+        // TODO: Write an own converter
+        return convertWithHttpSnippetLite(libcurl, request);
+    },
 };
-export {
-  cLibcurl
-};
-//# sourceMappingURL=libcurl.js.map

package/dist/plugins/clojure/clj_http/clj_http.js

@@ -1,14 +1,14 @@
-import { clj_http } from "../../../httpsnippet-lite/targets/clojure/clj_http/client.js";
-import { convertWithHttpSnippetLite } from "../../../utils/convertWithHttpSnippetLite.js";
-const clojureCljhttp = {
-  target: "clojure",
-  client: "clj_http",
-  title: "clj-http",
-  generate(request) {
-    return convertWithHttpSnippetLite(clj_http, request);
-  }
+import { clj_http } from '../../../httpsnippet-lite/targets/clojure/clj_http/client.js';
+import { convertWithHttpSnippetLite } from '../../../utils/convertWithHttpSnippetLite.js';
+/**
+ * clojure/clj_http
+ */
+export const clojureCljhttp = {
+    target: 'clojure',
+    client: 'clj_http',
+    title: 'clj-http',
+    generate(request) {
+        // TODO: Write an own converter
+        return convertWithHttpSnippetLite(clj_http, request);
+    },
 };
-export {
-  clojureCljhttp
-};
-//# sourceMappingURL=clj_http.js.map

package/dist/plugins/clojure/clj_http/index.js

@@ -1,5 +1 @@
-import { clojureCljhttp } from "./clj_http.js";
-export {
-  clojureCljhttp
-};
-//# sourceMappingURL=index.js.map
+export { clojureCljhttp } from './clj_http.js';