feat: Phase 1 — extract the client (web SPA + desktop) to dtoro/oikos-web
Problem: the hexagonal refactor churns the backend tree for nine more phases; the UI delivery stack (web/ SPA, cmd/desktop Wails wrapper, compose/web image) must move to its own repo first so doc/layout rewrites land once on a backend-only tree. Change: - New repo git.hubris.network/dtoro/oikos-web (v0.33.0): web/, desktop/ (updateURL repointed to oikos-web releases), compose/, own CI (web + desktop jobs), own deploy script (CI-green gate, TOCTOU guard, version-tagged images, prune-to-3), own webhook receiver on :9798 + launchd unit, own compose project publishing the same 8091:80. - Cutover executed on mac-mini in order: oikos stack's web service stopped+removed, oikos-web project brought up on 8091; outer Caddy untouched (targets the published port) — serving + Authentik flow + /wails 404 quirk verified post-cutover. - Stripped from oikos: web/, cmd/desktop/, compose/web/, desktop CI workflow, ci.yml web job, Makefile ui/desktop/desktop-package/install targets, the compose web service, oikos-web from deploy.sh's fallback prune list; wails + go-keyring dropped from go.mod, vendor synced. - README / CONTRIBUTING / AGENTS.md / .agents dev+operations docs now point at the new repo; mbse + mascot design docs carry a path note. Risk: production SPA serving depends on the new pipeline now; rollback is versioned-image re-up of the old web service from a pre-split checkout (port 8091). Desktop builds installed before the split still check dtoro/oikos releases — one manual reinstall, noted in the oikos-web release notes. Verification: go vet, make test (race), make generate-check, golangci (no new findings; baseline down 400→365); post-cutover curls — localhost:8091 200, /wails/runtime.js 404, outer Caddy 302 Authentik.
This commit is contained in:
315
web/node_modules/eslint/lib/rules/operator-linebreak.js
generated
vendored
Normal file
315
web/node_modules/eslint/lib/rules/operator-linebreak.js
generated
vendored
Normal file
@@ -0,0 +1,315 @@
|
||||
/**
|
||||
* @fileoverview Operator linebreak - enforces operator linebreak style of two types: after and before
|
||||
* @author Benoît Zugmeyer
|
||||
* @deprecated in ESLint v8.53.0
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Requirements
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const astUtils = require("./utils/ast-utils");
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../types').Rule.RuleModule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
deprecated: {
|
||||
message: "Formatting rules are being moved out of ESLint core.",
|
||||
url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
|
||||
deprecatedSince: "8.53.0",
|
||||
availableUntil: "11.0.0",
|
||||
replacedBy: [
|
||||
{
|
||||
message:
|
||||
"ESLint Stylistic now maintains deprecated stylistic core rules.",
|
||||
url: "https://eslint.style/guide/migration",
|
||||
plugin: {
|
||||
name: "@stylistic/eslint-plugin",
|
||||
url: "https://eslint.style",
|
||||
},
|
||||
rule: {
|
||||
name: "operator-linebreak",
|
||||
url: "https://eslint.style/rules/operator-linebreak",
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
type: "layout",
|
||||
|
||||
docs: {
|
||||
description: "Enforce consistent linebreak style for operators",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/operator-linebreak",
|
||||
},
|
||||
|
||||
schema: [
|
||||
{
|
||||
enum: ["after", "before", "none", null],
|
||||
},
|
||||
{
|
||||
type: "object",
|
||||
properties: {
|
||||
overrides: {
|
||||
type: "object",
|
||||
additionalProperties: {
|
||||
enum: ["after", "before", "none", "ignore"],
|
||||
},
|
||||
},
|
||||
},
|
||||
additionalProperties: false,
|
||||
},
|
||||
],
|
||||
|
||||
fixable: "code",
|
||||
|
||||
messages: {
|
||||
operatorAtBeginning:
|
||||
"'{{operator}}' should be placed at the beginning of the line.",
|
||||
operatorAtEnd:
|
||||
"'{{operator}}' should be placed at the end of the line.",
|
||||
badLinebreak: "Bad line breaking before and after '{{operator}}'.",
|
||||
noLinebreak:
|
||||
"There should be no line break before or after '{{operator}}'.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const usedDefaultGlobal = !context.options[0];
|
||||
const globalStyle = context.options[0] || "after";
|
||||
const options = context.options[1] || {};
|
||||
const styleOverrides = options.overrides
|
||||
? Object.assign({}, options.overrides)
|
||||
: {};
|
||||
|
||||
if (usedDefaultGlobal && !styleOverrides["?"]) {
|
||||
styleOverrides["?"] = "before";
|
||||
}
|
||||
|
||||
if (usedDefaultGlobal && !styleOverrides[":"]) {
|
||||
styleOverrides[":"] = "before";
|
||||
}
|
||||
|
||||
const sourceCode = context.sourceCode;
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Gets a fixer function to fix rule issues
|
||||
* @param {Token} operatorToken The operator token of an expression
|
||||
* @param {string} desiredStyle The style for the rule. One of 'before', 'after', 'none'
|
||||
* @returns {Function} A fixer function
|
||||
*/
|
||||
function getFixer(operatorToken, desiredStyle) {
|
||||
return fixer => {
|
||||
const tokenBefore = sourceCode.getTokenBefore(operatorToken);
|
||||
const tokenAfter = sourceCode.getTokenAfter(operatorToken);
|
||||
const textBefore = sourceCode.text.slice(
|
||||
tokenBefore.range[1],
|
||||
operatorToken.range[0],
|
||||
);
|
||||
const textAfter = sourceCode.text.slice(
|
||||
operatorToken.range[1],
|
||||
tokenAfter.range[0],
|
||||
);
|
||||
const hasLinebreakBefore = !astUtils.isTokenOnSameLine(
|
||||
tokenBefore,
|
||||
operatorToken,
|
||||
);
|
||||
const hasLinebreakAfter = !astUtils.isTokenOnSameLine(
|
||||
operatorToken,
|
||||
tokenAfter,
|
||||
);
|
||||
let newTextBefore, newTextAfter;
|
||||
|
||||
if (
|
||||
hasLinebreakBefore !== hasLinebreakAfter &&
|
||||
desiredStyle !== "none"
|
||||
) {
|
||||
// If there is a comment before and after the operator, don't do a fix.
|
||||
if (
|
||||
sourceCode.getTokenBefore(operatorToken, {
|
||||
includeComments: true,
|
||||
}) !== tokenBefore &&
|
||||
sourceCode.getTokenAfter(operatorToken, {
|
||||
includeComments: true,
|
||||
}) !== tokenAfter
|
||||
) {
|
||||
return null;
|
||||
}
|
||||
|
||||
/*
|
||||
* If there is only one linebreak and it's on the wrong side of the operator, swap the text before and after the operator.
|
||||
* foo &&
|
||||
* bar
|
||||
* would get fixed to
|
||||
* foo
|
||||
* && bar
|
||||
*/
|
||||
newTextBefore = textAfter;
|
||||
newTextAfter = textBefore;
|
||||
} else {
|
||||
const LINEBREAK_REGEX =
|
||||
astUtils.createGlobalLinebreakMatcher();
|
||||
|
||||
// Otherwise, if no linebreak is desired and no comments interfere, replace the linebreaks with empty strings.
|
||||
newTextBefore =
|
||||
desiredStyle === "before" || textBefore.trim()
|
||||
? textBefore
|
||||
: textBefore.replace(LINEBREAK_REGEX, "");
|
||||
newTextAfter =
|
||||
desiredStyle === "after" || textAfter.trim()
|
||||
? textAfter
|
||||
: textAfter.replace(LINEBREAK_REGEX, "");
|
||||
|
||||
// If there was no change (due to interfering comments), don't output a fix.
|
||||
if (
|
||||
newTextBefore === textBefore &&
|
||||
newTextAfter === textAfter
|
||||
) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
if (
|
||||
newTextAfter === "" &&
|
||||
tokenAfter.type === "Punctuator" &&
|
||||
"+-".includes(operatorToken.value) &&
|
||||
tokenAfter.value === operatorToken.value
|
||||
) {
|
||||
// To avoid accidentally creating a ++ or -- operator, insert a space if the operator is a +/- and the following token is a unary +/-.
|
||||
newTextAfter += " ";
|
||||
}
|
||||
|
||||
return fixer.replaceTextRange(
|
||||
[tokenBefore.range[1], tokenAfter.range[0]],
|
||||
newTextBefore + operatorToken.value + newTextAfter,
|
||||
);
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks the operator placement
|
||||
* @param {ASTNode} node The node to check
|
||||
* @param {ASTNode} rightSide The node that comes after the operator in `node`
|
||||
* @param {string} operator The operator
|
||||
* @private
|
||||
* @returns {void}
|
||||
*/
|
||||
function validateNode(node, rightSide, operator) {
|
||||
/*
|
||||
* Find the operator token by searching from the right side, because between the left side and the operator
|
||||
* there could be additional tokens from type annotations. Search specifically for the token which
|
||||
* value equals the operator, in order to skip possible opening parentheses before the right side node.
|
||||
*/
|
||||
const operatorToken = sourceCode.getTokenBefore(
|
||||
rightSide,
|
||||
token => token.value === operator,
|
||||
);
|
||||
const leftToken = sourceCode.getTokenBefore(operatorToken);
|
||||
const rightToken = sourceCode.getTokenAfter(operatorToken);
|
||||
const operatorStyleOverride = styleOverrides[operator];
|
||||
const style = operatorStyleOverride || globalStyle;
|
||||
const fix = getFixer(operatorToken, style);
|
||||
|
||||
// if single line
|
||||
if (
|
||||
astUtils.isTokenOnSameLine(leftToken, operatorToken) &&
|
||||
astUtils.isTokenOnSameLine(operatorToken, rightToken)
|
||||
) {
|
||||
// do nothing.
|
||||
} else if (
|
||||
operatorStyleOverride !== "ignore" &&
|
||||
!astUtils.isTokenOnSameLine(leftToken, operatorToken) &&
|
||||
!astUtils.isTokenOnSameLine(operatorToken, rightToken)
|
||||
) {
|
||||
// lone operator
|
||||
context.report({
|
||||
node,
|
||||
loc: operatorToken.loc,
|
||||
messageId: "badLinebreak",
|
||||
data: {
|
||||
operator,
|
||||
},
|
||||
fix,
|
||||
});
|
||||
} else if (
|
||||
style === "before" &&
|
||||
astUtils.isTokenOnSameLine(leftToken, operatorToken)
|
||||
) {
|
||||
context.report({
|
||||
node,
|
||||
loc: operatorToken.loc,
|
||||
messageId: "operatorAtBeginning",
|
||||
data: {
|
||||
operator,
|
||||
},
|
||||
fix,
|
||||
});
|
||||
} else if (
|
||||
style === "after" &&
|
||||
astUtils.isTokenOnSameLine(operatorToken, rightToken)
|
||||
) {
|
||||
context.report({
|
||||
node,
|
||||
loc: operatorToken.loc,
|
||||
messageId: "operatorAtEnd",
|
||||
data: {
|
||||
operator,
|
||||
},
|
||||
fix,
|
||||
});
|
||||
} else if (style === "none") {
|
||||
context.report({
|
||||
node,
|
||||
loc: operatorToken.loc,
|
||||
messageId: "noLinebreak",
|
||||
data: {
|
||||
operator,
|
||||
},
|
||||
fix,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Validates a binary expression using `validateNode`
|
||||
* @param {BinaryExpression|LogicalExpression|AssignmentExpression} node node to be validated
|
||||
* @returns {void}
|
||||
*/
|
||||
function validateBinaryExpression(node) {
|
||||
validateNode(node, node.right, node.operator);
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
// Public
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
return {
|
||||
BinaryExpression: validateBinaryExpression,
|
||||
LogicalExpression: validateBinaryExpression,
|
||||
AssignmentExpression: validateBinaryExpression,
|
||||
VariableDeclarator(node) {
|
||||
if (node.init) {
|
||||
validateNode(node, node.init, "=");
|
||||
}
|
||||
},
|
||||
PropertyDefinition(node) {
|
||||
if (node.value) {
|
||||
validateNode(node, node.value, "=");
|
||||
}
|
||||
},
|
||||
ConditionalExpression(node) {
|
||||
validateNode(node, node.consequent, "?");
|
||||
validateNode(node, node.alternate, ":");
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
Reference in New Issue
Block a user