@gadgetinc/ggt 1.0.3 → 1.0.5

package/lib/services/output/spinner.js

@@ -1,141 +0,0 @@
-import chalk from "chalk";
-import chalkTemplate from "chalk-template";
-import cliSpinners from "cli-spinners";
-import assert from "node:assert";
-import os from "node:os";
-import { dedent } from "ts-dedent";
-import { isString } from "../util/is.js";
-import { output } from "./output.js";
-import { isSprintOptions, sprintln } from "./sprint.js";
-import { symbol } from "./symbols.js";
-export let activeSpinner;
-export const createSpin = (options)=>{
-    return (optionsOrString, ...values)=>{
-        if (isSprintOptions(optionsOrString)) {
-            return createSpin({
-                ...options,
-                ...optionsOrString
-            });
-        }
-        assert(!activeSpinner, "a spinner is already active");
-        let str = optionsOrString;
-        if (!isString(str)) {
-            str = sprintln(str, ...values);
-        }
-        const { ensureNewLine = true, ensureEmptyLineAbove = false, kind = "dots", color = "white", successSymbol = chalk.green(symbol.tick), failSymbol = chalk.red(symbol.cross) } = options;
-        let frameIndex = 0;
-        const frames = cliSpinners[kind].frames;
-        const interval = cliSpinners[kind].interval;
-        let firstRender = true;
-        const render = ({ symbol, message, final: finalRender = false })=>{
-            // strip leading and trailing newlines so we can add them back in
-            // the right place
-            while(message.startsWith("\n")){
-                message = message.slice(1);
-            }
-            while(message.endsWith("\n")){
-                message = message.slice(0, -1);
-            }
-            // if no symbol is provided, use the next frame
-            if (symbol === undefined) {
-                frameIndex = ++frameIndex % frames.length;
-                symbol = chalk[color](frames[frameIndex]);
-            }
-            if (message) {
-                // we have a message to display
-                if (symbol) {
-                    // add the spinner symbol to the first line of the message
-                    const lines = message.split(/\r?\n/);
-                    lines[0] = `${symbol} ${lines[0]}`;
-                    message = lines.join(os.EOL);
-                }
-                if (ensureEmptyLineAbove && !message.startsWith("\n")) {
-                    // add an empty line before the symbol
-                    message = "\n" + message;
-                }
-                if (ensureNewLine && !message.endsWith("\n")) {
-                    // add a newline after the message
-                    message += "\n";
-                }
-            }
-            if (finalRender) {
-                if (!output.isInteractive && ensureEmptyLineAbove) {
-                    // we're in a non-interactive terminal, therefor
-                    // ensureEmptyLineAbove only applies to the first render.
-                    // strip it so that the final render of the spinner is right
-                    // below the first render of the spinner
-                    message = message.slice(1);
-                }
-                // this is the final render, so persist the spinner
-                output.persistSpinner(message);
-                activeSpinner = undefined;
-                return;
-            }
-            // this is not the final render, so we need to update the spinner
-            if (output.isInteractive) {
-                // we're in an interactive terminal, so update the spinner
-                output.updateSpinner(message);
-            } else if (firstRender) {
-                // we're not in an interactive terminal, and this is the first
-                // render, so just write the first render to stdout
-                output.writeStdout(message);
-                firstRender = false;
-            }
-        };
-        // render the first frame
-        render({
-            message: str
-        });
-        let spinnerInterval;
-        if (output.isInteractive) {
-            // we are in an interactive terminal, so keep rendering the spinner
-            spinnerInterval = setInterval(()=>render({
-                    message: str
-                }), interval);
-        }
-        // setup the last render
-        const finalRender = (renderOptions)=>{
-            render({
-                ...renderOptions,
-                final: true
-            });
-            clearInterval(spinnerInterval);
-        };
-        activeSpinner = {
-            text: str,
-            clear () {
-                this.text = "";
-                finalRender({
-                    symbol: "",
-                    message: ""
-                });
-            },
-            succeed (finalStr, ...values) {
-                finalStr ??= str;
-                if (!isString(finalStr)) {
-                    finalStr = dedent(chalkTemplate(finalStr, ...values));
-                }
-                this.text = finalStr;
-                finalRender({
-                    message: finalStr,
-                    symbol: successSymbol
-                });
-            },
-            fail (finalStr, ...values) {
-                finalStr ??= str;
-                if (!isString(finalStr)) {
-                    finalStr = dedent(chalkTemplate(finalStr, ...values));
-                }
-                this.text = finalStr;
-                finalRender({
-                    message: finalStr,
-                    symbol: failSymbol
-                });
-            }
-        };
-        return activeSpinner;
-    };
-};
-export const spin = createSpin({});
-
-//# sourceMappingURL=spinner.js.map

package/lib/services/output/spinner.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/services/output/spinner.ts"],"sourcesContent":["import type { ColorName } from \"chalk\";\nimport chalk from \"chalk\";\nimport chalkTemplate from \"chalk-template\";\nimport type { SpinnerName } from \"cli-spinners\";\nimport cliSpinners from \"cli-spinners\";\nimport assert from \"node:assert\";\nimport os from \"node:os\";\nimport { dedent } from \"ts-dedent\";\nimport { isString } from \"../util/is.js\";\nimport { output } from \"./output.js\";\nimport { isSprintOptions, sprintln } from \"./sprint.js\";\nimport { symbol } from \"./symbols.js\";\n\nexport type SpinnerOptions = {\n  /**\n   * Whether to ensure a new line is after the text.\n   *\n   * @default false\n   */\n  ensureNewLine?: boolean;\n\n  /**\n   * Whether to ensure an empty line is above the spinner.\n   *\n   * @default false\n   */\n  ensureEmptyLineAbove?: boolean;\n\n  /**\n   * The name of the spinner to use.\n   *\n   * @default \"dots\"\n   * @see https://github.com/sindresorhus/cli-spinners\n   */\n  kind?: SpinnerName;\n\n  /**\n   * The color of the spinner.\n   *\n   * @default \"cyan\"\n   * @see https://github.com/chalk/chalk\n   */\n  color?: ColorName;\n\n  /**\n   * The symbol to display when the spinner succeeds.\n   *\n   * @default \"✔\"\n   */\n  successSymbol?: string;\n\n  /**\n   * The symbol to display when the spinner fails.\n   *\n   * @default \"✖\"\n   */\n  failSymbol?: string;\n};\n\nexport type spin = {\n  (str: string): spinner;\n  (template: TemplateStringsArray, ...values: unknown[]): spinner;\n  (options: Omit<SpinnerOptions, \"str\">): spin;\n};\n\nexport type spinner = {\n  text: string;\n  clear: () => void;\n  succeed: {\n    (str?: string): void;\n    (template: TemplateStringsArray, ...values: unknown[]): void;\n  };\n  fail: {\n    (str?: string): void;\n    (template: TemplateStringsArray, ...values: unknown[]): void;\n  };\n};\n\nexport let activeSpinner: spinner | undefined;\n\nexport const createSpin = (options: SpinnerOptions): spin => {\n  return ((optionsOrString: SpinnerOptions | string | TemplateStringsArray, ...values: unknown[]): spin | spinner => {\n    if (isSprintOptions(optionsOrString)) {\n      return createSpin({ ...options, ...optionsOrString });\n    }\n\n    assert(!activeSpinner, \"a spinner is already active\");\n\n    let str = optionsOrString as string;\n    if (!isString(str)) {\n      str = sprintln(str, ...values);\n    }\n\n    const {\n      ensureNewLine = true,\n      ensureEmptyLineAbove = false,\n      kind = \"dots\",\n      color = \"white\",\n      successSymbol = chalk.green(symbol.tick),\n      failSymbol = chalk.red(symbol.cross),\n    } = options;\n\n    let frameIndex = 0;\n    const frames = cliSpinners[kind].frames;\n    const interval = cliSpinners[kind].interval;\n\n    type RenderOptions = { symbol?: string; message: string; final?: boolean };\n    let firstRender = true;\n\n    const render = ({ symbol, message, final: finalRender = false }: RenderOptions): void => {\n      // strip leading and trailing newlines so we can add them back in\n      // the right place\n      while (message.startsWith(\"\\n\")) {\n        message = message.slice(1);\n      }\n\n      while (message.endsWith(\"\\n\")) {\n        message = message.slice(0, -1);\n      }\n\n      // if no symbol is provided, use the next frame\n      if (symbol === undefined) {\n        frameIndex = ++frameIndex % frames.length;\n        symbol = chalk[color](frames[frameIndex]);\n      }\n\n      if (message) {\n        // we have a message to display\n        if (symbol) {\n          // add the spinner symbol to the first line of the message\n          const lines = message.split(/\\r?\\n/);\n          lines[0] = `${symbol} ${lines[0]}`;\n          message = lines.join(os.EOL);\n        }\n\n        if (ensureEmptyLineAbove && !message.startsWith(\"\\n\")) {\n          // add an empty line before the symbol\n          message = \"\\n\" + message;\n        }\n\n        if (ensureNewLine && !message.endsWith(\"\\n\")) {\n          // add a newline after the message\n          message += \"\\n\";\n        }\n      }\n\n      if (finalRender) {\n        if (!output.isInteractive && ensureEmptyLineAbove) {\n          // we're in a non-interactive terminal, therefor\n          // ensureEmptyLineAbove only applies to the first render.\n          // strip it so that the final render of the spinner is right\n          // below the first render of the spinner\n          message = message.slice(1);\n        }\n\n        // this is the final render, so persist the spinner\n        output.persistSpinner(message);\n        activeSpinner = undefined;\n        return;\n      }\n\n      // this is not the final render, so we need to update the spinner\n      if (output.isInteractive) {\n        // we're in an interactive terminal, so update the spinner\n        output.updateSpinner(message);\n      } else if (firstRender) {\n        // we're not in an interactive terminal, and this is the first\n        // render, so just write the first render to stdout\n        output.writeStdout(message);\n        firstRender = false;\n      }\n    };\n\n    // render the first frame\n    render({ message: str });\n\n    let spinnerInterval: NodeJS.Timeout | undefined;\n    if (output.isInteractive) {\n      // we are in an interactive terminal, so keep rendering the spinner\n      spinnerInterval = setInterval(() => render({ message: str }), interval);\n    }\n\n    // setup the last render\n    const finalRender = (renderOptions: Omit<RenderOptions, \"final\">): void => {\n      render({ ...renderOptions, final: true });\n      clearInterval(spinnerInterval);\n    };\n\n    activeSpinner = {\n      text: str,\n      clear(): void {\n        this.text = \"\";\n        finalRender({ symbol: \"\", message: \"\" });\n      },\n      succeed(finalStr?: string | TemplateStringsArray, ...values: unknown[]): void {\n        finalStr ??= str;\n        if (!isString(finalStr)) {\n          finalStr = dedent(chalkTemplate(finalStr, ...values));\n        }\n        this.text = finalStr;\n        finalRender({ message: finalStr, symbol: successSymbol });\n      },\n      fail(finalStr?: string | TemplateStringsArray, ...values: unknown[]): void {\n        finalStr ??= str;\n        if (!isString(finalStr)) {\n          finalStr = dedent(chalkTemplate(finalStr, ...values));\n        }\n        this.text = finalStr;\n        finalRender({ message: finalStr, symbol: failSymbol });\n      },\n    };\n\n    return activeSpinner;\n  }) as spin;\n};\n\nexport const spin = createSpin({});\n"],"names":["chalk","chalkTemplate","cliSpinners","assert","os","dedent","isString","output","isSprintOptions","sprintln","symbol","activeSpinner","createSpin","options","optionsOrString","values","str","ensureNewLine","ensureEmptyLineAbove","kind","color","successSymbol","green","tick","failSymbol","red","cross","frameIndex","frames","interval","firstRender","render","message","final","finalRender","startsWith","slice","endsWith","undefined","length","lines","split","join","EOL","isInteractive","persistSpinner","updateSpinner","writeStdout","spinnerInterval","setInterval","renderOptions","clearInterval","text","clear","succeed","finalStr","fail","spin"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib/services/output/sprint.js

@@ -1,44 +0,0 @@
-import boxen from "boxen";
-import chalkTemplate from "chalk-template";
-import indentString from "indent-string";
-import { dedent } from "ts-dedent";
-import { isArray, isString } from "../util/is.js";
-export const isSprintOptions = (value)=>{
-    return !isString(value) && !isArray(value);
-};
-const createSprint = (options)=>{
-    return (optionsOrString, ...values)=>{
-        if (isSprintOptions(optionsOrString)) {
-            return createSprint({
-                ...options,
-                ...optionsOrString
-            });
-        }
-        const { ensureNewLine = false, ensureEmptyLineAbove = false, indent = 0, boxen: boxenOptions } = options;
-        let str = optionsOrString;
-        if (!isString(str)) {
-            str = dedent(chalkTemplate(str, ...values));
-        }
-        if (ensureEmptyLineAbove && !str.startsWith("\n")) {
-            str = "\n" + str;
-        }
-        if (ensureNewLine && !str.endsWith("\n")) {
-            str += "\n";
-        }
-        if (boxenOptions) {
-            str = boxen(str, boxenOptions);
-        }
-        if (indent > 0) {
-            str = indentString(str, indent);
-        }
-        return str;
-    };
-};
-export const sprint = createSprint({
-    ensureNewLine: false
-});
-export const sprintln = createSprint({
-    ensureNewLine: true
-});
-
-//# sourceMappingURL=sprint.js.map

package/lib/services/output/sprint.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/services/output/sprint.ts"],"sourcesContent":["import type { Options as BoxenOptions } from \"boxen\";\nimport boxen from \"boxen\";\nimport chalkTemplate from \"chalk-template\";\nimport indentString from \"indent-string\";\nimport { dedent } from \"ts-dedent\";\nimport { isArray, isString } from \"../util/is.js\";\n\nexport type SprintOptions = {\n  /**\n   * Whether to ensure a new line is after the content.\n   *\n   * @default true\n   */\n  ensureNewLine?: boolean;\n\n  /**\n   * Whether to ensure an empty line is above the content.\n   *\n   * @default false\n   */\n  ensureEmptyLineAbove?: boolean;\n\n  /**\n   * The number of spaces to indent the text.\n   *\n   * @default 0\n   */\n  indent?: number;\n\n  /**\n   * Whether to wrap the text in a box.\n   *\n   * @default undefined (no box)\n   */\n  boxen?: BoxenOptions;\n};\n\nexport type sprint = {\n  (str: string): string;\n  (template: TemplateStringsArray, ...values: unknown[]): string;\n  (options: SprintOptions): sprint;\n};\n\nexport const isSprintOptions = <const T extends SprintOptions>(value: string | TemplateStringsArray | SprintOptions): value is T => {\n  return !isString(value) && !isArray(value);\n};\n\nconst createSprint = (options: SprintOptions): sprint => {\n  return ((optionsOrString: SprintOptions | string | TemplateStringsArray, ...values: unknown[]): sprint | string => {\n    if (isSprintOptions(optionsOrString)) {\n      return createSprint({ ...options, ...optionsOrString });\n    }\n\n    const { ensureNewLine = false, ensureEmptyLineAbove = false, indent = 0, boxen: boxenOptions } = options;\n\n    let str = optionsOrString as string;\n    if (!isString(str)) {\n      str = dedent(chalkTemplate(str, ...values));\n    }\n\n    if (ensureEmptyLineAbove && !str.startsWith(\"\\n\")) {\n      str = \"\\n\" + str;\n    }\n\n    if (ensureNewLine && !str.endsWith(\"\\n\")) {\n      str += \"\\n\";\n    }\n\n    if (boxenOptions) {\n      str = boxen(str, boxenOptions);\n    }\n\n    if (indent > 0) {\n      str = indentString(str, indent);\n    }\n\n    return str;\n  }) as sprint;\n};\n\nexport const sprint = createSprint({ ensureNewLine: false });\nexport const sprintln = createSprint({ ensureNewLine: true });\n"],"names":["boxen","chalkTemplate","indentString","dedent","isArray","isString","isSprintOptions","value","createSprint","options","optionsOrString","values","ensureNewLine","ensureEmptyLineAbove","indent","boxenOptions","str","startsWith","endsWith","sprint","sprintln"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AACA,OAAOA,WAAW,QAAQ;AAC1B,OAAOC,mBAAmB,iBAAiB;AAC3C,OAAOC,kBAAkB,gBAAgB;AACzC,SAASC,MAAM,QAAQ,YAAY;AACnC,SAASC,OAAO,EAAEC,QAAQ,QAAQ,gBAAgB;AAsClD,OAAO,MAAMC,kBAAkB,CAAgCC;IAC7D,OAAO,CAACF,SAASE,UAAU,CAACH,QAAQG;AACtC,EAAE;AAEF,MAAMC,eAAe,CAACC;IACpB,OAAQ,CAACC,iBAAgE,GAAGC;QAC1E,IAAIL,gBAAgBI,kBAAkB;YACpC,OAAOF,aAAa;gBAAE,GAAGC,OAAO;gBAAE,GAAGC,eAAe;YAAC;QACvD;QAEA,MAAM,EAAEE,gBAAgB,KAAK,EAAEC,uBAAuB,KAAK,EAAEC,SAAS,CAAC,EAAEd,OAAOe,YAAY,EAAE,GAAGN;QAEjG,IAAIO,MAAMN;QACV,IAAI,CAACL,SAASW,MAAM;YAClBA,MAAMb,OAAOF,cAAce,QAAQL;QACrC;QAEA,IAAIE,wBAAwB,CAACG,IAAIC,UAAU,CAAC,OAAO;YACjDD,MAAM,OAAOA;QACf;QAEA,IAAIJ,iBAAiB,CAACI,IAAIE,QAAQ,CAAC,OAAO;YACxCF,OAAO;QACT;QAEA,IAAID,cAAc;YAChBC,MAAMhB,MAAMgB,KAAKD;QACnB;QAEA,IAAID,SAAS,GAAG;YACdE,MAAMd,aAAac,KAAKF;QAC1B;QAEA,OAAOE;IACT;AACF;AAEA,OAAO,MAAMG,SAASX,aAAa;IAAEI,eAAe;AAAM,GAAG;AAC7D,OAAO,MAAMQ,WAAWZ,aAAa;IAAEI,eAAe;AAAK,GAAG"}

package/lib/services/output/symbols.js

@@ -1,23 +0,0 @@
-// eslint-disable-next-line no-restricted-imports -- this is the only place we're allowed to import figures
-import figures, { mainSymbols } from "figures";
-import isUnicodeSupported from "is-unicode-supported";
-import { config } from "../config/config.js";
-import { env } from "../config/env.js";
-// we always use main symbols in tests rather than figures so that our
-// tests are consistent across platforms (particularly Windows)
-export const symbol = {
-    ...env.testLike ? mainSymbols : figures
-};
-if (isUnicodeSupported() && config.windowsOrWsl) {
-    // when unicode is supported and we're on windows or wsl, these
-    // symbols end up rendering over two cells while only taking up one,
-    // so we add an extra space to each of them to make them take up two
-    for (const name of [
-        "tick",
-        "cross"
-    ]){
-        symbol[name] += " ";
-    }
-}
-
-//# sourceMappingURL=symbols.js.map

package/lib/services/output/symbols.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/services/output/symbols.ts"],"sourcesContent":["// eslint-disable-next-line no-restricted-imports -- this is the only place we're allowed to import figures\nimport figures, { mainSymbols } from \"figures\";\nimport isUnicodeSupported from \"is-unicode-supported\";\nimport { config } from \"../config/config.js\";\nimport { env } from \"../config/env.js\";\n\n// we always use main symbols in tests rather than figures so that our\n// tests are consistent across platforms (particularly Windows)\nexport const symbol = { ...(env.testLike ? mainSymbols : figures) };\n\nif (isUnicodeSupported() && config.windowsOrWsl) {\n  // when unicode is supported and we're on windows or wsl, these\n  // symbols end up rendering over two cells while only taking up one,\n  // so we add an extra space to each of them to make them take up two\n  for (const name of [\"tick\", \"cross\"] as const) {\n    symbol[name] += \" \";\n  }\n}\n"],"names":["figures","mainSymbols","isUnicodeSupported","config","env","symbol","testLike","windowsOrWsl","name"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,2GAA2G;AAC3G,OAAOA,WAAWC,WAAW,QAAQ,UAAU;AAC/C,OAAOC,wBAAwB,uBAAuB;AACtD,SAASC,MAAM,QAAQ,sBAAsB;AAC7C,SAASC,GAAG,QAAQ,mBAAmB;AAEvC,sEAAsE;AACtE,+DAA+D;AAC/D,OAAO,MAAMC,SAAS;IAAE,GAAID,IAAIE,QAAQ,GAAGL,cAAcD,OAAO;AAAE,EAAE;AAEpE,IAAIE,wBAAwBC,OAAOI,YAAY,EAAE;IAC/C,+DAA+D;IAC/D,oEAAoE;IACpE,oEAAoE;IACpE,KAAK,MAAMC,QAAQ;QAAC;QAAQ;KAAQ,CAAW;QAC7CH,MAAM,CAACG,KAAK,IAAI;IAClB;AACF"}

package/lib/services/output/table.js

@@ -1,98 +0,0 @@
-import CliTable3 from "cli-table3";
-import indentString from "indent-string";
-import { dedent } from "ts-dedent";
-import { println } from "./print.js";
-import { sprintln } from "./sprint.js";
-export const sprintTable = ({ title, headers, rows, footer, ensureEmptyLineAboveBody = false, ensureEmptyLineAboveFooter = false, borders: borderType = "none", colAligns = [], colWidths = [], indent, ...printOptions })=>{
-    const table = new CliTable3({
-        chars: borders[borderType],
-        colAligns,
-        colWidths,
-        head: headers,
-        style: {
-            head: [],
-            border: []
-        }
-    });
-    table.push(...rows);
-    let text = table.toString() + "\n";
-    if (borderType === "none") {
-        // remove the left padding
-        text = dedent(text).slice(1);
-    }
-    // remove the right padding
-    text = text.split("\n").map((line)=>line.trimEnd()).join("\n");
-    if (indent) {
-        text = indentString(text, indent);
-    }
-    if (title) {
-        text = sprintln(title) + sprintln({
-            ensureEmptyLineAbove: ensureEmptyLineAboveBody
-        })(text);
-    }
-    if (footer) {
-        text = sprintln(text) + sprintln({
-            ensureEmptyLineAbove: ensureEmptyLineAboveFooter
-        })(footer);
-    }
-    return sprintln(printOptions)(text);
-};
-export const printTable = (options)=>{
-    println(options)(sprintTable(options));
-};
-// prettier-ignore
-const borders = {
-    none: {
-        "top-left": "",
-        top: "",
-        "top-mid": "",
-        "top-right": "",
-        "left-mid": "",
-        mid: "",
-        "mid-mid": "",
-        "right-mid": "",
-        left: "",
-        middle: "",
-        right: "",
-        "bottom-left": "",
-        bottom: "",
-        "bottom-mid": "",
-        "bottom-right": ""
-    },
-    thin: {
-        "top-left": "┌",
-        top: "─",
-        "top-mid": "┬",
-        "top-right": "┐",
-        "left-mid": "├",
-        mid: "─",
-        "mid-mid": "┼",
-        "right-mid": "┤",
-        left: "│",
-        middle: "│",
-        right: "│",
-        "bottom-left": "└",
-        bottom: "─",
-        "bottom-mid": "┴",
-        "bottom-right": "┘"
-    },
-    thick: {
-        "top-left": "╔",
-        top: "═",
-        "top-mid": "╤",
-        "top-right": "╗",
-        left: "║",
-        middle: "│",
-        right: "║",
-        "left-mid": "╟",
-        mid: "─",
-        "mid-mid": "┼",
-        "right-mid": "╢",
-        "bottom-left": "╚",
-        bottom: "═",
-        "bottom-mid": "╧",
-        "bottom-right": "╝"
-    }
-};
-
-//# sourceMappingURL=table.js.map

package/lib/services/output/table.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/services/output/table.ts"],"sourcesContent":["import CliTable3 from \"cli-table3\";\nimport indentString from \"indent-string\";\nimport { dedent } from \"ts-dedent\";\nimport { println, type PrintOptions } from \"./print.js\";\nimport { sprintln, type SprintOptions } from \"./sprint.js\";\n\nexport type SprintTableOptions = SprintOptions & {\n  /**\n   * The text to print above the table.\n   */\n  title?: string;\n\n  /**\n   * The headers of the table.\n   */\n  headers?: string[];\n\n  /**\n   * The rows of the table.\n   */\n  rows: string[][];\n\n  /**\n   * The text to print below the table.\n   */\n  footer?: string;\n\n  /**\n   * Whether to add an empty line above the body of the table.\n   *\n   * @default false\n   */\n  ensureEmptyLineAboveBody?: boolean;\n\n  /**\n   * Whether to add an empty line above the footer of the table.\n   *\n   * @default false\n   */\n  ensureEmptyLineAboveFooter?: boolean;\n\n  /**\n   * The type of borders to use.\n   *\n   * @default \"none\"\n   */\n  borders?: \"none\" | \"thin\" | \"thick\";\n\n  /**\n   * The alignment of the content in each column.\n   *\n   * @default [] (left-aligned)\n   */\n  colAligns?: (\"left\" | \"center\" | \"right\")[];\n\n  /**\n   * The width of each column.\n   *\n   * @default [] (auto-sized)\n   */\n  colWidths?: number[];\n};\n\nexport const sprintTable = ({\n  title,\n  headers,\n  rows,\n  footer,\n  ensureEmptyLineAboveBody = false,\n  ensureEmptyLineAboveFooter = false,\n  borders: borderType = \"none\",\n  colAligns = [],\n  colWidths = [],\n  indent,\n  ...printOptions\n}: SprintTableOptions): string => {\n  const table = new CliTable3({\n    chars: borders[borderType],\n    colAligns,\n    colWidths,\n    head: headers,\n    style: { head: [], border: [] },\n  });\n\n  table.push(...rows);\n\n  let text = table.toString() + \"\\n\";\n  if (borderType === \"none\") {\n    // remove the left padding\n    text = dedent(text).slice(1);\n  }\n\n  // remove the right padding\n  text = text\n    .split(\"\\n\")\n    .map((line) => line.trimEnd())\n    .join(\"\\n\");\n\n  if (indent) {\n    text = indentString(text, indent);\n  }\n\n  if (title) {\n    text = sprintln(title) + sprintln({ ensureEmptyLineAbove: ensureEmptyLineAboveBody })(text);\n  }\n\n  if (footer) {\n    text = sprintln(text) + sprintln({ ensureEmptyLineAbove: ensureEmptyLineAboveFooter })(footer);\n  }\n\n  return sprintln(printOptions)(text);\n};\n\nexport type PrintTableOptions = PrintOptions & SprintTableOptions;\n\nexport const printTable = (options: PrintTableOptions): void => {\n  println(options)(sprintTable(options));\n};\n\n// prettier-ignore\nconst borders = {\n    none: {\n      \"top-left\": \"\", top: \"\", \"top-mid\": \"\", \"top-right\": \"\",\n      \"left-mid\": \"\", mid: \"\", \"mid-mid\": \"\", \"right-mid\": \"\",\n      left: \"\", middle: \"\", right: \"\",\n      \"bottom-left\": \"\", bottom: \"\", \"bottom-mid\": \"\", \"bottom-right\": \"\",\n    },\n    thin: {\n      \"top-left\": \"┌\", top: \"─\", \"top-mid\": \"┬\", \"top-right\": \"┐\",\n      \"left-mid\": \"├\", mid: \"─\", \"mid-mid\": \"┼\", \"right-mid\": \"┤\",\n      left: \"│\", middle: \"│\", right: \"│\",\n      \"bottom-left\": \"└\", bottom: \"─\", \"bottom-mid\": \"┴\", \"bottom-right\": \"┘\",\n    },\n    thick: {\n      \"top-left\": \"╔\", top: \"═\", \"top-mid\": \"╤\", \"top-right\": \"╗\",\n      left: \"║\", middle: \"│\", right: \"║\",\n      \"left-mid\": \"╟\", mid: \"─\", \"mid-mid\": \"┼\", \"right-mid\": \"╢\",\n      \"bottom-left\": \"╚\", bottom: \"═\", \"bottom-mid\": \"╧\", \"bottom-right\": \"╝\",\n    },\n  };\n"],"names":["CliTable3","indentString","dedent","println","sprintln","sprintTable","title","headers","rows","footer","ensureEmptyLineAboveBody","ensureEmptyLineAboveFooter","borders","borderType","colAligns","colWidths","indent","printOptions","table","chars","head","style","border","push","text","toString","slice","split","map","line","trimEnd","join","ensureEmptyLineAbove","printTable","options","none","top","mid","left","middle","right","bottom","thin","thick"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,OAAOA,eAAe,aAAa;AACnC,OAAOC,kBAAkB,gBAAgB;AACzC,SAASC,MAAM,QAAQ,YAAY;AACnC,SAASC,OAAO,QAA2B,aAAa;AACxD,SAASC,QAAQ,QAA4B,cAAc;AA2D3D,OAAO,MAAMC,cAAc,CAAC,EAC1BC,KAAK,EACLC,OAAO,EACPC,IAAI,EACJC,MAAM,EACNC,2BAA2B,KAAK,EAChCC,6BAA6B,KAAK,EAClCC,SAASC,aAAa,MAAM,EAC5BC,YAAY,EAAE,EACdC,YAAY,EAAE,EACdC,MAAM,EACN,GAAGC,cACgB;IACnB,MAAMC,QAAQ,IAAIlB,UAAU;QAC1BmB,OAAOP,OAAO,CAACC,WAAW;QAC1BC;QACAC;QACAK,MAAMb;QACNc,OAAO;YAAED,MAAM,EAAE;YAAEE,QAAQ,EAAE;QAAC;IAChC;IAEAJ,MAAMK,IAAI,IAAIf;IAEd,IAAIgB,OAAON,MAAMO,QAAQ,KAAK;IAC9B,IAAIZ,eAAe,QAAQ;QACzB,0BAA0B;QAC1BW,OAAOtB,OAAOsB,MAAME,KAAK,CAAC;IAC5B;IAEA,2BAA2B;IAC3BF,OAAOA,KACJG,KAAK,CAAC,MACNC,GAAG,CAAC,CAACC,OAASA,KAAKC,OAAO,IAC1BC,IAAI,CAAC;IAER,IAAIf,QAAQ;QACVQ,OAAOvB,aAAauB,MAAMR;IAC5B;IAEA,IAAIV,OAAO;QACTkB,OAAOpB,SAASE,SAASF,SAAS;YAAE4B,sBAAsBtB;QAAyB,GAAGc;IACxF;IAEA,IAAIf,QAAQ;QACVe,OAAOpB,SAASoB,QAAQpB,SAAS;YAAE4B,sBAAsBrB;QAA2B,GAAGF;IACzF;IAEA,OAAOL,SAASa,cAAcO;AAChC,EAAE;AAIF,OAAO,MAAMS,aAAa,CAACC;IACzB/B,QAAQ+B,SAAS7B,YAAY6B;AAC/B,EAAE;AAEF,kBAAkB;AAClB,MAAMtB,UAAU;IACZuB,MAAM;QACJ,YAAY;QAAIC,KAAK;QAAI,WAAW;QAAI,aAAa;QACrD,YAAY;QAAIC,KAAK;QAAI,WAAW;QAAI,aAAa;QACrDC,MAAM;QAAIC,QAAQ;QAAIC,OAAO;QAC7B,eAAe;QAAIC,QAAQ;QAAI,cAAc;QAAI,gBAAgB;IACnE;IACAC,MAAM;QACJ,YAAY;QAAKN,KAAK;QAAK,WAAW;QAAK,aAAa;QACxD,YAAY;QAAKC,KAAK;QAAK,WAAW;QAAK,aAAa;QACxDC,MAAM;QAAKC,QAAQ;QAAKC,OAAO;QAC/B,eAAe;QAAKC,QAAQ;QAAK,cAAc;QAAK,gBAAgB;IACtE;IACAE,OAAO;QACL,YAAY;QAAKP,KAAK;QAAK,WAAW;QAAK,aAAa;QACxDE,MAAM;QAAKC,QAAQ;QAAKC,OAAO;QAC/B,YAAY;QAAKH,KAAK;QAAK,WAAW;QAAK,aAAa;QACxD,eAAe;QAAKI,QAAQ;QAAK,cAAc;QAAK,gBAAgB;IACtE;AACF"}

package/lib/services/output/timestamp.js

@@ -1,12 +0,0 @@
-import chalk from "chalk";
-import dayjs from "dayjs";
-import { env } from "../config/env.js";
-import { parseBoolean } from "../util/boolean.js";
-export const ts = ()=>{
-    if (!env.testLike && parseBoolean(process.env["CI"])) {
-        return new Date().toISOString();
-    }
-    return chalk.gray(dayjs().format("hh:mm:ss A"));
-};
-
-//# sourceMappingURL=timestamp.js.map

package/lib/services/output/timestamp.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/services/output/timestamp.ts"],"sourcesContent":["import chalk from \"chalk\";\nimport dayjs from \"dayjs\";\nimport { env } from \"../config/env.js\";\nimport { parseBoolean } from \"../util/boolean.js\";\n\nexport const ts = (): string => {\n  if (!env.testLike && parseBoolean(process.env[\"CI\"])) {\n    return new Date().toISOString();\n  }\n  return chalk.gray(dayjs().format(\"hh:mm:ss A\"));\n};\n"],"names":["chalk","dayjs","env","parseBoolean","ts","testLike","process","Date","toISOString","gray","format"],"rangeMappings":";;;;;;;;;","mappings":"AAAA,OAAOA,WAAW,QAAQ;AAC1B,OAAOC,WAAW,QAAQ;AAC1B,SAASC,GAAG,QAAQ,mBAAmB;AACvC,SAASC,YAAY,QAAQ,qBAAqB;AAElD,OAAO,MAAMC,KAAK;IAChB,IAAI,CAACF,IAAIG,QAAQ,IAAIF,aAAaG,QAAQJ,GAAG,CAAC,KAAK,GAAG;QACpD,OAAO,IAAIK,OAAOC,WAAW;IAC/B;IACA,OAAOR,MAAMS,IAAI,CAACR,QAAQS,MAAM,CAAC;AACnC,EAAE"}

package/lib/services/output/update.js

@@ -1,99 +0,0 @@
-import boxen from "boxen";
-import dayjs from "dayjs";
-import fs from "fs-extra";
-import ms from "ms";
-import assert from "node:assert";
-import path from "node:path";
-import semver from "semver";
-import { z } from "zod";
-import { config } from "../config/config.js";
-import { packageJson } from "../config/package-json.js";
-import { http } from "../http/http.js";
-import { println } from "./print.js";
-import { sprint } from "./sprint.js";
-const UPDATE_CHECK_FREQUENCY = ms("12 hours");
-const Registry = z.object({
-    name: z.literal("ggt"),
-    "dist-tags": z.object({
-        latest: z.string(),
-        experimental: z.string()
-    })
-});
-export const getDistTags = async (ctx)=>{
-    const json = await http({
-        context: {
-            ctx
-        },
-        method: "GET",
-        url: "https://registry.npmjs.org/ggt",
-        responseType: "json",
-        resolveBodyOnly: true,
-        timeout: {
-            request: ms("5s")
-        }
-    });
-    return Registry.parse(json)["dist-tags"];
-};
-export const shouldCheckForUpdate = async ()=>{
-    try {
-        const lastCheck = Number(await fs.readFile(path.join(config.cacheDir, "last-update-check"), "utf8"));
-        assert(!Number.isNaN(lastCheck));
-        return dayjs().isAfter(lastCheck + UPDATE_CHECK_FREQUENCY);
-    } catch (error) {
-        return true;
-    }
-};
-/**
- * Checks for updates to the `ggt` npm package and logs a warning
- * message if an update is available.
- *
- * @returns A Promise that resolves with void when the check is
- * complete.
- */ export const warnIfUpdateAvailable = async (ctx)=>{
-    try {
-        const shouldCheck = await shouldCheckForUpdate();
-        if (!shouldCheck) {
-            return;
-        }
-        await fs.outputFile(path.join(config.cacheDir, "last-update-check"), String(Date.now()));
-        const tags = await getDistTags(ctx);
-        let latest;
-        let updateAvailable;
-        let updateMessage;
-        if (packageJson.version.includes("experimental")) {
-            // this is an experimental release
-            latest = tags.experimental;
-            updateAvailable = packageJson.version !== latest;
-            updateMessage = sprint`
-        Update available! {red ${packageJson.version}} → {green ${latest}}
-        Run "npm install -g ${packageJson.name}@experimental" to update.
-      `;
-        } else {
-            // this is a stable release
-            latest = tags.latest;
-            updateAvailable = semver.lt(packageJson.version, latest);
-            updateMessage = sprint`
-        Update available! {red ${packageJson.version}} → {green ${latest}}
-        Changelog: https://github.com/gadget-inc/ggt/releases/tag/v${latest}
-        Run "npm install -g ${packageJson.name}" to update.
-      `;
-        }
-        if (updateAvailable) {
-            ctx.log.info("update available", {
-                current: packageJson.version,
-                latest
-            });
-            println(boxen(updateMessage, {
-                padding: 1,
-                borderStyle: "round",
-                textAlignment: "center"
-            }));
-        }
-    } catch (error) {
-        ctx.log.error("failed to check for updates", {
-            error
-        });
-    }
-};
-
-//# sourceMappingURL=update.js.map

package/lib/services/output/update.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/services/output/update.ts"],"sourcesContent":["import boxen from \"boxen\";\nimport dayjs from \"dayjs\";\nimport fs from \"fs-extra\";\nimport ms from \"ms\";\nimport assert from \"node:assert\";\nimport path from \"node:path\";\nimport semver from \"semver\";\nimport { z } from \"zod\";\nimport type { Context } from \"../command/context.js\";\nimport { config } from \"../config/config.js\";\nimport { packageJson } from \"../config/package-json.js\";\nimport { http } from \"../http/http.js\";\nimport { println } from \"./print.js\";\nimport { sprint } from \"./sprint.js\";\n\nconst UPDATE_CHECK_FREQUENCY = ms(\"12 hours\");\n\nconst Registry = z.object({\n  name: z.literal(\"ggt\"),\n  \"dist-tags\": z.object({\n    latest: z.string(),\n    experimental: z.string(),\n  }),\n});\n\ntype Registry = z.infer<typeof Registry>;\n\nexport const getDistTags = async (ctx: Context): Promise<Registry[\"dist-tags\"]> => {\n  const json = await http({\n    context: { ctx },\n    method: \"GET\",\n    url: \"https://registry.npmjs.org/ggt\",\n    responseType: \"json\",\n    resolveBodyOnly: true,\n    timeout: {\n      request: ms(\"5s\"),\n    },\n  });\n\n  return Registry.parse(json)[\"dist-tags\"];\n};\n\nexport const shouldCheckForUpdate = async (): Promise<boolean> => {\n  try {\n    const lastCheck = Number(await fs.readFile(path.join(config.cacheDir, \"last-update-check\"), \"utf8\"));\n    assert(!Number.isNaN(lastCheck));\n    return dayjs().isAfter(lastCheck + UPDATE_CHECK_FREQUENCY);\n  } catch (error) {\n    return true;\n  }\n};\n\n/**\n * Checks for updates to the `ggt` npm package and logs a warning\n * message if an update is available.\n *\n * @returns A Promise that resolves with void when the check is\n * complete.\n */\nexport const warnIfUpdateAvailable = async (ctx: Context): Promise<void> => {\n  try {\n    const shouldCheck = await shouldCheckForUpdate();\n    if (!shouldCheck) {\n      return;\n    }\n\n    await fs.outputFile(path.join(config.cacheDir, \"last-update-check\"), String(Date.now()));\n\n    const tags = await getDistTags(ctx);\n\n    let latest: string;\n    let updateAvailable: boolean;\n    let updateMessage: string;\n\n    if (packageJson.version.includes(\"experimental\")) {\n      // this is an experimental release\n      latest = tags.experimental;\n      updateAvailable = packageJson.version !== latest;\n      updateMessage = sprint`\n        Update available! {red ${packageJson.version}} → {green ${latest}}\n        Run \"npm install -g ${packageJson.name}@experimental\" to update.\n      `;\n    } else {\n      // this is a stable release\n      latest = tags.latest;\n      updateAvailable = semver.lt(packageJson.version, latest);\n      updateMessage = sprint`\n        Update available! {red ${packageJson.version}} → {green ${latest}}\n        Changelog: https://github.com/gadget-inc/ggt/releases/tag/v${latest}\n        Run \"npm install -g ${packageJson.name}\" to update.\n      `;\n    }\n\n    if (updateAvailable) {\n      ctx.log.info(\"update available\", { current: packageJson.version, latest });\n      println(\n        boxen(updateMessage, {\n          padding: 1,\n          borderStyle: \"round\",\n          textAlignment: \"center\",\n        }),\n      );\n    }\n  } catch (error) {\n    ctx.log.error(\"failed to check for updates\", { error });\n  }\n};\n"],"names":["boxen","dayjs","fs","ms","assert","path","semver","z","config","packageJson","http","println","sprint","UPDATE_CHECK_FREQUENCY","Registry","object","name","literal","latest","string","experimental","getDistTags","ctx","json","context","method","url","responseType","resolveBodyOnly","timeout","request","parse","shouldCheckForUpdate","lastCheck","Number","readFile","join","cacheDir","isNaN","isAfter","error","warnIfUpdateAvailable","shouldCheck","outputFile","String","Date","now","tags","updateAvailable","updateMessage","version","includes","lt","log","info","current","padding","borderStyle","textAlignment"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,OAAOA,WAAW,QAAQ;AAC1B,OAAOC,WAAW,QAAQ;AAC1B,OAAOC,QAAQ,WAAW;AAC1B,OAAOC,QAAQ,KAAK;AACpB,OAAOC,YAAY,cAAc;AACjC,OAAOC,UAAU,YAAY;AAC7B,OAAOC,YAAY,SAAS;AAC5B,SAASC,CAAC,QAAQ,MAAM;AAExB,SAASC,MAAM,QAAQ,sBAAsB;AAC7C,SAASC,WAAW,QAAQ,4BAA4B;AACxD,SAASC,IAAI,QAAQ,kBAAkB;AACvC,SAASC,OAAO,QAAQ,aAAa;AACrC,SAASC,MAAM,QAAQ,cAAc;AAErC,MAAMC,yBAAyBV,GAAG;AAElC,MAAMW,WAAWP,EAAEQ,MAAM,CAAC;IACxBC,MAAMT,EAAEU,OAAO,CAAC;IAChB,aAAaV,EAAEQ,MAAM,CAAC;QACpBG,QAAQX,EAAEY,MAAM;QAChBC,cAAcb,EAAEY,MAAM;IACxB;AACF;AAIA,OAAO,MAAME,cAAc,OAAOC;IAChC,MAAMC,OAAO,MAAMb,KAAK;QACtBc,SAAS;YAAEF;QAAI;QACfG,QAAQ;QACRC,KAAK;QACLC,cAAc;QACdC,iBAAiB;QACjBC,SAAS;YACPC,SAAS3B,GAAG;QACd;IACF;IAEA,OAAOW,SAASiB,KAAK,CAACR,KAAK,CAAC,YAAY;AAC1C,EAAE;AAEF,OAAO,MAAMS,uBAAuB;IAClC,IAAI;QACF,MAAMC,YAAYC,OAAO,MAAMhC,GAAGiC,QAAQ,CAAC9B,KAAK+B,IAAI,CAAC5B,OAAO6B,QAAQ,EAAE,sBAAsB;QAC5FjC,OAAO,CAAC8B,OAAOI,KAAK,CAACL;QACrB,OAAOhC,QAAQsC,OAAO,CAACN,YAAYpB;IACrC,EAAE,OAAO2B,OAAO;QACd,OAAO;IACT;AACF,EAAE;AAEF;;;;;;CAMC,GACD,OAAO,MAAMC,wBAAwB,OAAOnB;IAC1C,IAAI;QACF,MAAMoB,cAAc,MAAMV;QAC1B,IAAI,CAACU,aAAa;YAChB;QACF;QAEA,MAAMxC,GAAGyC,UAAU,CAACtC,KAAK+B,IAAI,CAAC5B,OAAO6B,QAAQ,EAAE,sBAAsBO,OAAOC,KAAKC,GAAG;QAEpF,MAAMC,OAAO,MAAM1B,YAAYC;QAE/B,IAAIJ;QACJ,IAAI8B;QACJ,IAAIC;QAEJ,IAAIxC,YAAYyC,OAAO,CAACC,QAAQ,CAAC,iBAAiB;YAChD,kCAAkC;YAClCjC,SAAS6B,KAAK3B,YAAY;YAC1B4B,kBAAkBvC,YAAYyC,OAAO,KAAKhC;YAC1C+B,gBAAgBrC,MAAM,CAAC;+BACE,EAAEH,YAAYyC,OAAO,CAAC,WAAW,EAAEhC,OAAO;4BAC7C,EAAET,YAAYO,IAAI,CAAC;MACzC,CAAC;QACH,OAAO;YACL,2BAA2B;YAC3BE,SAAS6B,KAAK7B,MAAM;YACpB8B,kBAAkB1C,OAAO8C,EAAE,CAAC3C,YAAYyC,OAAO,EAAEhC;YACjD+B,gBAAgBrC,MAAM,CAAC;+BACE,EAAEH,YAAYyC,OAAO,CAAC,WAAW,EAAEhC,OAAO;mEACN,EAAEA,OAAO;4BAChD,EAAET,YAAYO,IAAI,CAAC;MACzC,CAAC;QACH;QAEA,IAAIgC,iBAAiB;YACnB1B,IAAI+B,GAAG,CAACC,IAAI,CAAC,oBAAoB;gBAAEC,SAAS9C,YAAYyC,OAAO;gBAAEhC;YAAO;YACxEP,QACEX,MAAMiD,eAAe;gBACnBO,SAAS;gBACTC,aAAa;gBACbC,eAAe;YACjB;QAEJ;IACF,EAAE,OAAOlB,OAAO;QACdlB,IAAI+B,GAAG,CAACb,KAAK,CAAC,+BAA+B;YAAEA;QAAM;IACvD;AACF,EAAE"}

package/lib/services/user/session.js

@@ -1,54 +0,0 @@
-import fs from "fs-extra";
-import { configPath } from "../config/config.js";
-import { swallowEnoent } from "../filesync/directory.js";
-import { createLogger } from "../output/log/logger.js";
-import { memo } from "../util/function.js";
-const log = createLogger({
-    name: "session"
-});
-/**
- * Reads the session from either the environment variable `GGT_SESSION`
- * or from the `session.txt` file in the config directory.
- *
- * @returns The session string if found, otherwise undefined.
- */ export const readSession = memo(()=>{
-    if (process.env["GGT_SESSION"]) {
-        log.debug("reading session from env");
-        return process.env["GGT_SESSION"];
-    }
-    try {
-        log.debug("reading session from disk");
-        return fs.readFileSync(configPath("session.txt"), "utf8");
-    } catch (error) {
-        swallowEnoent(error);
-        return undefined;
-    }
-});
-/**
- * Writes the session to disk in the `session.txt` file in the config.
- *
- * @param session - The session to write to disk.
- */ export const writeSession = (session)=>{
-    readSession.clear();
-    if (process.env["GGT_SESSION"]) {
-        log.debug("writing session to env", {
-            session: Boolean(session)
-        });
-        process.env["GGT_SESSION"] = session;
-    }
-    log.debug("writing session to disk", {
-        session: Boolean(session),
-        path: configPath("session.txt")
-    });
-    if (session) {
-        fs.outputFileSync(configPath("session.txt"), session);
-    } else {
-        fs.removeSync(configPath("session.txt"));
-    }
-};
-export const readToken = ()=>{
-    log.debug("reading token from env");
-    return process.env["GGT_TOKEN"];
-};
-
-//# sourceMappingURL=session.js.map

package/lib/services/user/session.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/services/user/session.ts"],"sourcesContent":["import fs from \"fs-extra\";\nimport { configPath } from \"../config/config.js\";\nimport { swallowEnoent } from \"../filesync/directory.js\";\nimport { createLogger } from \"../output/log/logger.js\";\nimport { memo } from \"../util/function.js\";\n\nconst log = createLogger({ name: \"session\" });\n\n/**\n * Reads the session from either the environment variable `GGT_SESSION`\n * or from the `session.txt` file in the config directory.\n *\n * @returns The session string if found, otherwise undefined.\n */\nexport const readSession = memo((): string | undefined => {\n  if (process.env[\"GGT_SESSION\"]) {\n    log.debug(\"reading session from env\");\n    return process.env[\"GGT_SESSION\"];\n  }\n\n  try {\n    log.debug(\"reading session from disk\");\n    return fs.readFileSync(configPath(\"session.txt\"), \"utf8\");\n  } catch (error) {\n    swallowEnoent(error);\n    return undefined;\n  }\n});\n\n/**\n * Writes the session to disk in the `session.txt` file in the config.\n *\n * @param session - The session to write to disk.\n */\nexport const writeSession = (session: string | undefined): void => {\n  readSession.clear();\n\n  if (process.env[\"GGT_SESSION\"]) {\n    log.debug(\"writing session to env\", { session: Boolean(session) });\n    process.env[\"GGT_SESSION\"] = session;\n  }\n\n  log.debug(\"writing session to disk\", { session: Boolean(session), path: configPath(\"session.txt\") });\n\n  if (session) {\n    fs.outputFileSync(configPath(\"session.txt\"), session);\n  } else {\n    fs.removeSync(configPath(\"session.txt\"));\n  }\n};\n\nexport const readToken = (): string | undefined => {\n  log.debug(\"reading token from env\");\n  return process.env[\"GGT_TOKEN\"];\n};\n"],"names":["fs","configPath","swallowEnoent","createLogger","memo","log","name","readSession","process","env","debug","readFileSync","error","undefined","writeSession","session","clear","Boolean","path","outputFileSync","removeSync","readToken"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,OAAOA,QAAQ,WAAW;AAC1B,SAASC,UAAU,QAAQ,sBAAsB;AACjD,SAASC,aAAa,QAAQ,2BAA2B;AACzD,SAASC,YAAY,QAAQ,0BAA0B;AACvD,SAASC,IAAI,QAAQ,sBAAsB;AAE3C,MAAMC,MAAMF,aAAa;IAAEG,MAAM;AAAU;AAE3C;;;;;CAKC,GACD,OAAO,MAAMC,cAAcH,KAAK;IAC9B,IAAII,QAAQC,GAAG,CAAC,cAAc,EAAE;QAC9BJ,IAAIK,KAAK,CAAC;QACV,OAAOF,QAAQC,GAAG,CAAC,cAAc;IACnC;IAEA,IAAI;QACFJ,IAAIK,KAAK,CAAC;QACV,OAAOV,GAAGW,YAAY,CAACV,WAAW,gBAAgB;IACpD,EAAE,OAAOW,OAAO;QACdV,cAAcU;QACd,OAAOC;IACT;AACF,GAAG;AAEH;;;;CAIC,GACD,OAAO,MAAMC,eAAe,CAACC;IAC3BR,YAAYS,KAAK;IAEjB,IAAIR,QAAQC,GAAG,CAAC,cAAc,EAAE;QAC9BJ,IAAIK,KAAK,CAAC,0BAA0B;YAAEK,SAASE,QAAQF;QAAS;QAChEP,QAAQC,GAAG,CAAC,cAAc,GAAGM;IAC/B;IAEAV,IAAIK,KAAK,CAAC,2BAA2B;QAAEK,SAASE,QAAQF;QAAUG,MAAMjB,WAAW;IAAe;IAElG,IAAIc,SAAS;QACXf,GAAGmB,cAAc,CAAClB,WAAW,gBAAgBc;IAC/C,OAAO;QACLf,GAAGoB,UAAU,CAACnB,WAAW;IAC3B;AACF,EAAE;AAEF,OAAO,MAAMoB,YAAY;IACvBhB,IAAIK,KAAK,CAAC;IACV,OAAOF,QAAQC,GAAG,CAAC,YAAY;AACjC,EAAE"}

package/lib/services/user/user.js

@@ -1,76 +0,0 @@
-import assert from "node:assert";
-import z from "zod";
-import { login } from "../../commands/login.js";
-import { config } from "../config/config.js";
-import { loadAuthHeaders, swallowUnauthorized } from "../http/auth.js";
-import { http } from "../http/http.js";
-import { confirm } from "../output/confirm.js";
-import { println } from "../output/print.js";
-const User = z.object({
-    id: z.union([
-        z.string(),
-        z.number()
-    ]).transform(Number),
-    name: z.string().nullish(),
-    email: z.string()
-});
-/**
- * Retrieves the currently logged in user from Gadgets API.
- *
- * @returns A Promise that resolves to a User object representing the
- * current user, or undefined if the user is not authenticated.
- */ export const getUser = async (ctx)=>{
-    if (ctx.user) {
-        return ctx.user;
-    }
-    const headers = loadAuthHeaders();
-    if (!headers) {
-        return undefined;
-    }
-    try {
-        const json = await http({
-            context: {
-                ctx
-            },
-            url: `https://${config.domains.services}/auth/api/current-user`,
-            headers: {
-                ...headers
-            },
-            responseType: "json",
-            resolveBodyOnly: true
-        });
-        ctx.user = User.parse(json);
-        ctx.log.info("loaded user");
-        return ctx.user;
-    } catch (error) {
-        swallowUnauthorized(ctx, error);
-        return undefined;
-    }
-};
-/**
- * Retrieves the current user or prompts the user to log in if not
- * already logged in.
- *
- * @param ctx - The current context.
- * @returns A Promise that resolves to the current user.
- */ export const getUserOrLogin = async (ctx)=>{
-    let user = await getUser(ctx);
-    if (user) {
-        return user;
-    }
-    ctx.log.info("prompting user to log in");
-    println({
-        ensureEmptyLineAbove: true
-    })`
-    You must be logged in to use "ggt ${ctx.command}".
-  `;
-    await confirm({
-        ensureEmptyLineAbove: true
-    })("Would you like to log in?");
-    await login(ctx);
-    user = await getUser(ctx);
-    assert(user, "missing user after successful login");
-    return user;
-};
-
-//# sourceMappingURL=user.js.map