@uides/stepwise 2.0.0-rc.33 → 2.0.2

package/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Change Log - @uides/stepwise
+
+This log was last generated on Wed, 21 Jan 2026 15:58:34 GMT and should not be manually modified.
+
+## 2.0.2
+Wed, 21 Jan 2026 15:58:34 GMT
+
+### Breaking changes
+
+- Upgrade valibot to 0.42.1
+- Make lib "pure ESM"
+
+### Minor changes
+
+- Create initial library
+- Update schemas to reflect latest stepwise template changes
+
+### Updates
+
+- Remove unused template json files
+- Update typescript version
+

package/generators/componentExtractor.d.mts

@@ -0,0 +1 @@
+export {};

package/generators/componentReducer.d.mts

@@ -0,0 +1 @@
+export {};

package/generators/node_modules/@isaacs/cliui/build/lib/index.js

@@ -0,0 +1,211 @@
+const align = {
+    right: alignRight,
+    center: alignCenter
+};
+const lib_top = 0;
+const right = 1;
+const bottom = 2;
+const left = 3;
+class UI {
+    constructor(opts){
+        var _a;
+        this.width = opts.width;
+        this.wrap = null != (_a = opts.wrap) ? _a : true;
+        this.rows = [];
+    }
+    span(...args) {
+        const cols = this.div(...args);
+        cols.span = true;
+    }
+    resetOutput() {
+        this.rows = [];
+    }
+    div(...args) {
+        if (0 === args.length) this.div('');
+        if (this.wrap && this.shouldApplyLayoutDSL(...args) && 'string' == typeof args[0]) return this.applyLayoutDSL(args[0]);
+        const cols = args.map((arg)=>{
+            if ('string' == typeof arg) return this.colFromString(arg);
+            return arg;
+        });
+        this.rows.push(cols);
+        return cols;
+    }
+    shouldApplyLayoutDSL(...args) {
+        return 1 === args.length && 'string' == typeof args[0] && /[\t\n]/.test(args[0]);
+    }
+    applyLayoutDSL(str) {
+        const rows = str.split('\n').map((row)=>row.split('\t'));
+        let leftColumnWidth = 0;
+        rows.forEach((columns)=>{
+            if (columns.length > 1 && mixin.stringWidth(columns[0]) > leftColumnWidth) leftColumnWidth = Math.min(Math.floor(0.5 * this.width), mixin.stringWidth(columns[0]));
+        });
+        rows.forEach((columns)=>{
+            this.div(...columns.map((r, i)=>({
+                    text: r.trim(),
+                    padding: this.measurePadding(r),
+                    width: 0 === i && columns.length > 1 ? leftColumnWidth : void 0
+                })));
+        });
+        return this.rows[this.rows.length - 1];
+    }
+    colFromString(text) {
+        return {
+            text,
+            padding: this.measurePadding(text)
+        };
+    }
+    measurePadding(str) {
+        const noAnsi = mixin.stripAnsi(str);
+        return [
+            0,
+            noAnsi.match(/\s*$/)[0].length,
+            0,
+            noAnsi.match(/^\s*/)[0].length
+        ];
+    }
+    toString() {
+        const lines = [];
+        this.rows.forEach((row)=>{
+            this.rowToString(row, lines);
+        });
+        return lines.filter((line)=>!line.hidden).map((line)=>line.text).join('\n');
+    }
+    rowToString(row, lines) {
+        this.rasterize(row).forEach((rrow, r)=>{
+            let str = '';
+            rrow.forEach((col, c)=>{
+                const { width } = row[c];
+                const wrapWidth = this.negatePadding(row[c]);
+                let ts = col;
+                if (wrapWidth > mixin.stringWidth(col)) ts += ' '.repeat(wrapWidth - mixin.stringWidth(col));
+                if (row[c].align && 'left' !== row[c].align && this.wrap) {
+                    const fn = align[row[c].align];
+                    ts = fn(ts, wrapWidth);
+                    if (mixin.stringWidth(ts) < wrapWidth) {
+                        const w = width || 0;
+                        ts += ' '.repeat(w - mixin.stringWidth(ts) - 1);
+                    }
+                }
+                const padding = row[c].padding || [
+                    0,
+                    0,
+                    0,
+                    0
+                ];
+                if (padding[left]) str += ' '.repeat(padding[left]);
+                str += addBorder(row[c], ts, '| ');
+                str += ts;
+                str += addBorder(row[c], ts, ' |');
+                if (padding[right]) str += ' '.repeat(padding[right]);
+                if (0 === r && lines.length > 0) str = this.renderInline(str, lines[lines.length - 1]);
+            });
+            lines.push({
+                text: str.replace(/ +$/, ''),
+                span: row.span
+            });
+        });
+        return lines;
+    }
+    renderInline(source, previousLine) {
+        const match = source.match(/^ */);
+        const leadingWhitespace = match ? match[0].length : 0;
+        const target = previousLine.text;
+        const targetTextWidth = mixin.stringWidth(target.trimEnd());
+        if (!previousLine.span) return source;
+        if (!this.wrap) {
+            previousLine.hidden = true;
+            return target + source;
+        }
+        if (leadingWhitespace < targetTextWidth) return source;
+        previousLine.hidden = true;
+        return target.trimEnd() + ' '.repeat(leadingWhitespace - targetTextWidth) + source.trimStart();
+    }
+    rasterize(row) {
+        const rrows = [];
+        const widths = this.columnWidths(row);
+        let wrapped;
+        row.forEach((col, c)=>{
+            col.width = widths[c];
+            wrapped = this.wrap ? mixin.wrap(col.text, this.negatePadding(col), {
+                hard: true
+            }).split('\n') : col.text.split('\n');
+            if (col.border) {
+                wrapped.unshift('.' + '-'.repeat(this.negatePadding(col) + 2) + '.');
+                wrapped.push("'" + '-'.repeat(this.negatePadding(col) + 2) + "'");
+            }
+            if (col.padding) {
+                wrapped.unshift(...new Array(col.padding[lib_top] || 0).fill(''));
+                wrapped.push(...new Array(col.padding[bottom] || 0).fill(''));
+            }
+            wrapped.forEach((str, r)=>{
+                if (!rrows[r]) rrows.push([]);
+                const rrow = rrows[r];
+                for(let i = 0; i < c; i++)if (void 0 === rrow[i]) rrow.push('');
+                rrow.push(str);
+            });
+        });
+        return rrows;
+    }
+    negatePadding(col) {
+        let wrapWidth = col.width || 0;
+        if (col.padding) wrapWidth -= (col.padding[left] || 0) + (col.padding[right] || 0);
+        if (col.border) wrapWidth -= 4;
+        return wrapWidth;
+    }
+    columnWidths(row) {
+        if (!this.wrap) return row.map((col)=>col.width || mixin.stringWidth(col.text));
+        let unset = row.length;
+        let remainingWidth = this.width;
+        const widths = row.map((col)=>{
+            if (col.width) {
+                unset--;
+                remainingWidth -= col.width;
+                return col.width;
+            }
+        });
+        const unsetWidth = unset ? Math.floor(remainingWidth / unset) : 0;
+        return widths.map((w, i)=>{
+            if (void 0 === w) return Math.max(unsetWidth, _minWidth(row[i]));
+            return w;
+        });
+    }
+}
+function addBorder(col, ts, style) {
+    if (col.border) {
+        if (/[.']-+[.']/.test(ts)) return '';
+        if (0 !== ts.trim().length) return style;
+        return '  ';
+    }
+    return '';
+}
+function _minWidth(col) {
+    const padding = col.padding || [];
+    const minWidth = 1 + (padding[left] || 0) + (padding[right] || 0);
+    if (col.border) return minWidth + 4;
+    return minWidth;
+}
+function getWindowWidth() {
+    if ('object' == typeof process && process.stdout && process.stdout.columns) return process.stdout.columns;
+    return 80;
+}
+function alignRight(str, width) {
+    str = str.trim();
+    const strWidth = mixin.stringWidth(str);
+    if (strWidth < width) return ' '.repeat(width - strWidth) + str;
+    return str;
+}
+function alignCenter(str, width) {
+    str = str.trim();
+    const strWidth = mixin.stringWidth(str);
+    if (strWidth >= width) return str;
+    return ' '.repeat(width - strWidth >> 1) + str;
+}
+let mixin;
+function cliui(opts, _mixin) {
+    mixin = _mixin;
+    return new UI({
+        width: (null == opts ? void 0 : opts.width) || getWindowWidth(),
+        wrap: null == opts ? void 0 : opts.wrap
+    });
+}
+export { UI, cliui };

package/generators/node_modules/@pkgjs/parseargs/examples/is-default-value.js

@@ -0,0 +1,31 @@
+import * as __WEBPACK_EXTERNAL_MODULE__index_js_95fdb65a__ from "../index.js";
+var __webpack_modules__ = {
+    "..": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE__index_js_95fdb65a__;
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+const { parseArgs } = __webpack_require__("..");
+const options = {
+    file: {
+        short: 'f',
+        type: 'string',
+        default: 'FOO'
+    }
+};
+const { values, tokens } = parseArgs({
+    options,
+    tokens: true
+});
+const isFileDefault = !tokens.some((token)=>'option' === token.kind && 'file' === token.name);
+console.log(values);
+console.log(`Is the file option [${values.file}] the default value? ${isFileDefault}`);

package/generators/node_modules/@pkgjs/parseargs/examples/limit-long-syntax.js

@@ -0,0 +1,33 @@
+import * as __WEBPACK_EXTERNAL_MODULE__index_js_95fdb65a__ from "../index.js";
+var __webpack_modules__ = {
+    "..": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE__index_js_95fdb65a__;
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+const { parseArgs } = __webpack_require__("..");
+const options = {
+    file: {
+        short: 'f',
+        type: 'string'
+    },
+    log: {
+        type: 'string'
+    }
+};
+const { values, tokens } = parseArgs({
+    options,
+    tokens: true
+});
+const badToken = tokens.find((token)=>'option' === token.kind && null != token.value && token.rawName.startsWith('--') && !token.inlineValue);
+if (badToken) throw new Error(`Option value for '${badToken.rawName}' must be inline, like '${badToken.rawName}=VALUE'`);
+console.log(values);

package/generators/node_modules/@pkgjs/parseargs/examples/negate.js

@@ -0,0 +1,48 @@
+import * as __WEBPACK_EXTERNAL_MODULE__index_js_95fdb65a__ from "../index.js";
+var __webpack_modules__ = {
+    "..": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE__index_js_95fdb65a__;
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+const { parseArgs } = __webpack_require__("..");
+const options = {
+    color: {
+        type: 'boolean'
+    },
+    'no-color': {
+        type: 'boolean'
+    },
+    logfile: {
+        type: 'string'
+    },
+    'no-logfile': {
+        type: 'boolean'
+    }
+};
+const { values, tokens } = parseArgs({
+    options,
+    tokens: true
+});
+tokens.filter((token)=>'option' === token.kind).forEach((token)=>{
+    if (token.name.startsWith('no-')) {
+        const positiveName = token.name.slice(3);
+        values[positiveName] = false;
+        delete values[token.name];
+    } else values[token.name] = token.value ?? true;
+});
+const color = values.color;
+const logfile = values.logfile ?? 'default.log';
+console.log({
+    logfile,
+    color
+});

package/generators/node_modules/@pkgjs/parseargs/examples/no-repeated-options.js

@@ -0,0 +1,38 @@
+import * as __WEBPACK_EXTERNAL_MODULE__index_js_95fdb65a__ from "../index.js";
+var __webpack_modules__ = {
+    "..": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE__index_js_95fdb65a__;
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+const { parseArgs } = __webpack_require__("..");
+const options = {
+    ding: {
+        type: 'boolean',
+        short: 'd'
+    },
+    beep: {
+        type: 'boolean',
+        short: 'b'
+    }
+};
+const { values, tokens } = parseArgs({
+    options,
+    tokens: true
+});
+const seenBefore = new Set();
+tokens.forEach((token)=>{
+    if ('option' !== token.kind) return;
+    if (seenBefore.has(token.name)) throw new Error(`option '${token.name}' used multiple times`);
+    seenBefore.add(token.name);
+});
+console.log(values);

package/generators/node_modules/@pkgjs/parseargs/examples/simple-hard-coded.js

@@ -0,0 +1,36 @@
+import * as __WEBPACK_EXTERNAL_MODULE__index_js_95fdb65a__ from "../index.js";
+var __webpack_modules__ = {
+    "..": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE__index_js_95fdb65a__;
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+const { parseArgs } = __webpack_require__("..");
+const args = [
+    '-f',
+    '--bar',
+    'b'
+];
+const options = {
+    foo: {
+        type: 'boolean',
+        short: 'f'
+    },
+    bar: {
+        type: 'string'
+    }
+};
+const { values, positionals } = parseArgs({
+    args,
+    options
+});
+console.log(values, positionals);