Resumo: Por que tem Color.red.frame(maxWidth: 500)uma ScrollViewaltura de visualização de pixels? Por que não 500px ou 0px?

Pelo que entendi sobre posicionamento e dimensionamento do SwiftUI, cada visualização é questionada sobre o tamanho desejado. A visualização responde com seus requisitos máximos e a visualização pai lhe dá o máximo de espaço possível.

• Colorpor padrão usa o máximo de espaço possível.
• O uso de .frame(maxHeight: x)on Colorlimita isso a x pixels
• Nos exemplos a seguir, todas as três Colorvisualizações gostariam de ter um maxHeight de 500px. No entanto, como o espaço disponível é menor que 1500px, ele é dividido igualmente entre as visualizações, que são menores:

Exemplo:

var body: some View {
    VStack {
        Color.red
            .frame(maxHeight: 500)
        
        Color.yellow
            .frame(maxHeight: 500)
        
        Color.green
            .frame(maxHeight: 500)
    }
}

Mas, ao posicionar as Colorvisualizações dentro de um objeto, ScrollViewelas são renderizadas com uma altura de apenas alguns pixels. Por quê?

Não deveria ScrollViewoferecer altura infinita, o que permitiria que as Colorvisualizações usassem sua altura total de 500px cada?

Ou ele ScrollViewdá o mínimo de espaço possível às suas subvisualizações? Nesse caso, eu entenderia se as Colorvisualizações fossem reduzidas a 0px.

Mas de onde vem essa pequena altura (talvez 10px?)? Como isso é calculado?

var body: some View {
    ScrollView {
        VStack {
            Color.red
                .frame(maxHeight: 500)
            
            Color.yellow
                .frame(maxHeight: 500)
            
            Color.green
                .frame(maxHeight: 500)
        }
    }
}

Sei que posso resolver "o problema" usando " frame(height: )em vez disso". No entanto, só quero entender como o SwiftUI calcula a altura neste caso.

Perguntei a um LLM online e ele disse:

Sim, com certeza. Você precisa vincular à biblioteca de dependências mesmo ao criar uma biblioteca estática que chama funções dentro dela.

Mas tentei construir uma biblioteca estática que chama outra função, e tudo o que fiz foi incluir o cabeçalho e, em seguida, chamar a função. Ela foi construída no Linux com GCC, sem nenhuma reclamação sobre referência indefinida ou algo do tipo.

Digamos:

MinhaBibliotecaEstática:

#include "MyExternalFunction.h"

void my_static_library_function()
{
     MyExternalFunction();
}

O compilado acima funciona bem, sem reclamações do compilador.

Então eu crio um executável, main:

void my_static_library_function();

int main()
{
    my_static_library_function();
    return 0;
}

Vinculei o executável principal à minha biblioteca estática (obviamente, porque chamo a função dela) e ENTÃO ele reclama que MyExternalFunction não está definido, então o EXECUTABLE precisa vincular essa função. Mas não a biblioteca estática. Portanto, a biblioteca estática não precisa vincular as funções que chama. E quanto a outros símbolos, como variáveis? É a mesma coisa? Uma biblioteca estática NUNCA PRECISA vincular nada, ela só precisa de declarações?

O que me levou a perguntar isso é que estou construindo uma biblioteca estática (libcurl) e estou me perguntando se essa biblioteca precisa apenas do diretório include para MBedTLS (o backend da biblioteca SSL) para ser compilada.

O código abaixo trava quando o lambda fé chamado.
No entanto, minha expectativa é que, como o pacote de parâmetros é capturado por valor dentro da função "wrapper", ele deveria ter funcionado bem!

Alguém poderia ajudar com o entendimento correto?

void argPrinter(double d, int v, bool b) {
    cout << "argPrinter: " << " " << d  << " " << v << " " << b << endl;
}

template <typename Callable, typename... Args>
auto wrapper(Callable op, Args&&... args) {
    auto result = [&op, args...] () mutable {
         // args... are captured by value.
        cout << "Hello\n";
        op(args...);
    };
    return result;
}

int main() {
    auto f = wrapper(argPrinter, 28.7, -99, true);
   f(); // **SIGSEGV at this call!!**
}

Tenho experimentado std::ranges::viewse notado que cada visualização encadeada fica maior. Para iteradores de visualização, esse padrão é simples: cada um é sempre 8 bytes maior que o anterior. Mas para as visualizações em si, o transformtamanho não aumenta em nada, mas filteraumenta em uma quantidade que não consigo entender. No MSVC, esse padrão é um pouco diferente, mas ainda imprevisível para mim.

Código de teste:

#include <iostream>
#include <ranges>
#include <string>

int main() {
    static constexpr auto printed = [](auto&& v) {
        std::cout << "sizeof(v): " << sizeof(v) << ", ";
        std::cout << "sizeof(it): " << sizeof(v.begin()) << ", ";
        std::cout << "values: { ";
        for (auto&& x : v) {
            std::cout << x << ", ";
        }
        std::cout << "}\n";
        return v;
    };

    using namespace std::ranges::views;
    auto hundred = printed(iota(0ull, 100ull));
    auto small = printed(hundred | filter([](auto i) { return i < 50; }));
    auto times_seven = printed(small | transform([](auto i) { return i * 7; }));
    auto even = printed(times_seven | filter([](auto i) { return i % 2 == 0; }));
    auto as_string = printed(even | transform([](auto i) { return std::to_string(i); }));
    auto no_twos = printed(as_string | filter([](auto s) { return s.find('2') == s.npos; }));
}

Execute-o no GodBolt

Resultados:

Meu código não se importa muito com o tamanho das visualizações, já que elas nunca são armazenadas em lugar nenhum. Só estou me perguntando por que elas não podem ser constantes, dependendo apenas do tamanho do lambda (aqui sempre vazio). Tentei analisar o código-fonte, mas acho muito difícil de ler com todas as camadas de classes base, especialização de modelos e restrições de conceitos.

A função axiosGet:

export const axiosGet = async <TData>({
    url,
    params = {},
    onDone,
    onError
}: TypeAxiosArgs<TData>) => {
    
    try {
        const r = await axios.get<TypeAxiosData<TData, typeof params.paginate>>(url, { params })
        let ret
        if (params?.paginate) {
            ret = r.data
        } else {
            ret = r.data.data // <--- causing typescript to scream, check below
        }
        onDone?.(ret)
        return ret
    } catch (e) {
        console.error(e)
        onError?.(e)
    }
}

Os tipos:

export type TypeAxiosArgs<TData> = {
    url: string
    params?: { paginate?: number } & Record<string, any>
    onDone?: (response: TypeAxiosData<TData, undefined>) => void
    onError?: (error: any) => void
}

export type TypeAxiosData<
    TData,
    TPaginate extends number | undefined
> = TPaginate extends undefined
    ? TData
    : {
            data: TData
            meta: {
                from: number
                to: number
                total: number
                last_page: number
            }
      }

Estou recebendo um erro r.data.datase params.paginatefor indefinido

Property 'data' does not exist on type 'TypeAxiosData<TData, number | undefined>'.
  Property 'data' does not exist on type 'TData'.ts(2339)

Sinto que o problema está no axios.getgenérico, que precisa ser algo diferente, mas não consigo descobrir o quê.

Editar: TypeAxiosData corrigido e tentativa de conversão manual.

export const axiosGet = async <TData>({
    url,
    params = {},
    onDone,
    onError
}: TypeAxiosArgs<TData>) => {
    
    try {
        const r = await axios.get<TypeAxiosData<TData, typeof params.paginate>>(url, { params })
        let ret
        if (params?.paginate) {
            ret = r.data as TypeAxiosData<TData, number>
        } else {
            ret = r.data.data as TypeAxiosData<TData, undefined>
        }
        onDone?.(ret)
        return ret
    } catch (e) {
        console.error(e)
        onError?.(e)
    }
}

axiosGet<{ id: number, name: string }>({ url: "", params: { paginate: undefined } })
    .then((result) => {})

O problema que estou tendo é que o tipo de resultado está sendo declarado como:

(parameter) result: {
    id: number;
    name: string;
} | {
    data: {
        id: number;
        name: string;
    };
    meta: {
        from: number;
        to: number;
        total: number;
        last_page: number;
    };
} | undefined

Em vez de:

(parameter) result: {
    id: number;
    name: string;
} | undefined

Estou tentando criar uma grade nxn de blocos que caibam em um contêiner fixo (800px x 700px). Consegui gerar o número correto de blocos usando JavaScript, mas estou com dificuldades para alinhá-los perfeitamente no contêiner usando CSS.

Cada bloco deve ser redimensionado automaticamente para que todos os blocos n² caibam exatamente no contêiner sem transbordar, e eles devem formar um layout de grade perfeito.

Aqui está meu código atual:

const btn = document.createElement("button");
const body = document.querySelector("body");
body.appendChild(btn);
btn.className = "button";
btn.textContent = "button";

const container = document.createElement("div");
container.className = "container";
body.appendChild(container);

btn.addEventListener("click", () => {
  let select = Number(prompt("수 입력: "));
  container.innerHTML = ""; // clear existing boxes

  for (let i = 0; i < select * select; i++) {
    const div = document.createElement("div");
    div.className = "box";
    div.style.width = `calc(800px / ${select})`;
    div.style.height = `calc(700px / ${select})`;
    container.appendChild(div);
  }
});

*::after,
*::before {
  box-sizing: border-box;
}

* {
  margin: 0;
  padding: 0;
}

html,
body {
  height: 100%;
}

body {
  display: flex;
  justify-content: center;
  align-items: center;
}

.container {
  width: 800px;
  height: 700px;
  border: 3px solid black;
  overflow: hidden;
  display: flex;
  flex-wrap: wrap;
  justify-content: space-between;
}

.box {
  border: 1px solid black;
}

Após esta postagem, consegui montar uma pequena função para colocar dentro de um corpo de texto maior (FASTA) strings mais curtas determinadas de outro arquivo com base em algumas condições ( por exemplo, 100 eventos de um subconjunto de apenas 400 a 500 caracteres de comprimento e selecionados aleatoriamente).

Agora, estou satisfeito com o resultado; no entanto, desejo imprimir exatamente onde esses 100 eventos foram adicionados no corpo de texto maior — idealmente, posição inicial-final, se não for muito difícil.

Acho que isso poderia ser integrado get_retro_text()ou, se for mais fácil, criado como uma função externa, mas não consigo descobrir por onde começar... qualquer ajuda é muito apreciada, obrigado antecipadamente!

###library import
from Bio import SeqIO
import random

###string import and wrangling
input_file = open("homo_sapiens_strings.fasta.txt")
my_dict = SeqIO.to_dict(SeqIO.parse(input_file, "fasta"))

s = []
for j in my_dict.values():
   s.append(j)

###import FASTA --> some already made function I found to import and print whole FASTA genomes but testing on a part of it
def fasta_reader(filename):
  from Bio.SeqIO.FastaIO import FastaIterator
  with open(filename) as handle:
    for record in FastaIterator(handle):
      yield record

head = ""
body = ""
for entry in fasta_reader("hg37_chr1.fna"):
  head = str(entry.id)
  body = str(entry.seq)

###randomly selects 100 sequences and adds them to the FASTA
def insert (source_str, insert_str, pos):
    return source_str[:pos] + insert_str + source_str[pos:]

def get_retro_text(genome, all_strings):
    string_of_choice = [string for string in all_strings if 400 < len(string) < 500]
    hundred_strings = random.sample(string_of_choice, k=100)

    text_of_strings = []
    for k in range(len(hundred_strings)):
        text_of_strings.append(str(hundred_strings[k].seq))

    single_string = ",".join(text_of_strings)
    new_genome = insert(genome, single_string, random.randint(0, len(genome)))
    
    return new_genome

big_genome = get_retro_text(body, s)

EDIT exemplo de estrutura de bodyes

body

NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNtaaccctaaccctaacccta
accctaaccctaaccctaaccctaaccctaaccctaaccctaaccctaaccctaacccta
accctaaccctaaccctaaccctaacccaaccctaaccctaaccctaaccctaaccctaa
ccctaacccctaaccctaaccctaaccctaaccctaacctaaccctaaccctaaccctaa
ccctaaccctaaccctaaccctaaccctaacccctaaccctaaccctaaaccctaaaccc
taaccctaaccctaaccctaaccctaaccccaaccccaaccccaaccccaaccccaaccc
caaccctaacccctaaccctaaccctaaccctaccctaaccctaaccctaaccctaaccc
taaccctaacccctaacccctaaccctaaccctaaccctaaccctaaccctaaccctaac
ccctaaccctaaccctaaccctaaccctcgCGGTACCCTCAGCCGGCCCGCCCGCCCGGG
TCTGACCTGAGGAGAACTGTGCTCCGCCTTCAGAGTACCACCGAAATCTGTGCAGAGGAc
aacgcagctccgccctcgcggtGCTCtccgggtctgtgctgaggagaacgCAACTCCGCC
GTTGCAAAGGCGcgccgcgccggcgcaggcgcagagaggcgcgccgcgccggcgcaggcg
cagagaggcgcgccgcgccggcgcaggcgcagagaggcgcgccgcgccggcgcaggcgca
gagaggcgcgccgcgccggcgcaggcgcagagaggcgcgccgcgccggcgcaggcgcaga
caCATGCTAGCGCGTCGGGGTGGAGGCgtggcgcaggcgcagagaggcgcgccgcgccgg
cgcaggcgcagagacaCATGCTACCGCGTCCAGGGGTGGAGGCgtggcgcaggcgcagag
aggcgcaccgcgccggcgcaggcgcagagacaCATGCTAGCGCGTCCAGGGGTGGAGGCG
TggcgcaggcgcagagacgcAAGCCTAcgggcgggggttgggggggcgTGTGTTGCAGGA
GCAAAGTCGCACGGCGCCGGGCTGGGGCGGGGGGAGGGTGGCGCCGTGCACGCGCAGAAA
CTCACGTCACGGTGGCGCGGCGCAGAGACGGGTAGAACCTCAGTAATCCGAAAAGCCGGG
ATCGACCGCCCCTTGCTTGCAGCCGGGCACTACAGGACCCGCTTGCTCACGGTGCTGTGC
CAGGGCGCCCCCTGCTGGCGACTAGGGCAACTGCAGGGCTCTCTTGCTTAGAGTGGTGGC
CAGCGCCCCCTGCTGGCGCCGGGGCACTGCAGGGCCCTCTTGCTTACTGTATAGTGGTGG
CACGCCGCCTGCTGGCAGCTAGGGACATTGCAGGGTCCTCTTGCTCAAGGTGTAGTGGCA
GCACGCCCACCTGCTGGCAGCTGGGGACACTGCCGGGCCCTCTTGCTCCAACAGTACTGG
CGGATTATAGGGAAACACCCGGAGCATATGCTGTTTGGTCTCAGTAGACTCCTAAATATG
GGATTCCTgggtttaaaagtaaaaaataaatatgtttaatttgtGAACTGATTACCATCA
GAATTGTACTGTTCTGTATCCCACCAGCAATGTCTAGGAATGCCTGTTTCTCCACAAAGT
GTTtacttttggatttttgccagTCTAACAGGTGAAGCCCTGGAGATTCTTATTAGTGAT
TTGGGCTGGGGCCTGgccatgtgtatttttttaaatttccactgaTGATTTTGCTGCATG
GCCGGTGTTGAGAATGACTGCGCAAATTTGCCGGATTTCCTTTGCTGTTCCTGCATGTAG
TTTAAACGAGATTGCCAGCACCGGGTATCATTCACCATTTTTCTTTTCGTTAACTTGCCG
TCAGCCTTTTCTTTGACCTCTTCTTTCTGTTCATGTGTATTTGCTGTCTCTTAGCCCAGA
CTTCCCGTGTCCTTTCCACCGGGCCTTTGAGAGGTCACAGGGTCTTGATGCTGTGGTCTT
CATCTGCAGGTGTCTGACTTCCAGCAACTGCTGGCCTGTGCCAGGGTGCAAGCTGAGCAC
TGGAGTGGAGTTTTCCTGTGGAGAGGAGCCATGCCTAGAGTGGGATGGGCCATTGTTCAT

s

[[SeqRecord(seq=Seq('ATGGCGGGACACCCGAAAGAGAGGGTGGTCACAGATGAGGTCCATCAGAACCAG...TAG'), id='retro_hsap_1', name='retro_hsap_1', description='retro_hsap_1', dbxrefs=[]), SeqRecord(seq=Seq('ATGGTCAACGTACCTAAAACCCGAAGAACCTTCTGTAAGAAGTGTGGCAAGCAT...TAA'), id='retro_hsap_2', name='retro_hsap_2', description='retro_hsap_2', dbxrefs=[]), SeqRecord(seq=Seq('ATGTCCACAATGGGAAACGAGGCCAGTTACCCGGCGGAGATGTGCTCCCACTTT...TGA'), id='retro_hsap_3', name='retro_hsap_3', description='retro_hsap_3', dbxrefs=[])]]

Estou procurando uma função regex que corresponda exatamente a essas variantes de "SA..." (SAC, SAD, SAE, SAP, SAW, SAAC, SAAN, SAAS, SABE, SABW ), mas sem diferenciar maiúsculas de minúsculas.
O problema é que pode haver um ou mais separadores (espaço, barra invertida /, ponto, hífen -) entre cada caractere de cada palavra, por exemplo, "S /AC", "SA.P", "S / AB W".
Acabei com o padrão abaixo; sim, funciona, mas é feio e muito longo!
Existe um melhor e mais compacto?

Option Explicit
Option Compare Text

Function MatchSAWord(ByVal inputText As String) As Boolean
    Dim regex As Object
    Set regex = CreateObject("VBScript.RegExp")
   
    Dim sep As String, pat As String
   
    sep = "[ .\/-]*"
       
    pat = "\b(" & _
        "S" & sep & "A" & sep & "C" & "|" & _
        "S" & sep & "A" & sep & "D" & "|" & _
        "S" & sep & "A" & sep & "E" & "|" & _
        "S" & sep & "A" & sep & "P" & "|" & _
        "S" & sep & "A" & sep & "W" & "|" & _
        "S" & sep & "A" & sep & "A" & sep & "C" & "|" & _
        "S" & sep & "A" & sep & "A" & sep & "N" & "|" & _
        "S" & sep & "A" & sep & "A" & sep & "S" & "|" & _
        "S" & sep & "A" & sep & "B" & sep & "E" & "|" & _
        "S" & sep & "A" & sep & "B" & sep & "W" & _
        ")\b"
       
    With regex
        .Global = False
        .IgnoreCase = True
        .pattern = pat
    End With
    MatchSAWord = regex.Test(inputText)
End Function

Código TF de exemplo

data "grafana_data_source" "azure_monitor" {
  name = "grafana-azure-monitor-datasource"

resource "grafana_dashboard" "test" {
  folder      = grafana_folder.rule_folder.uid
  config_json = file("${path.module}/VMDASHBOARD.json")
}

Mas aqui o problema é que quando eu faço referência ao uid dentro do arquivo json

VMDASHBOARD.json

uid: ${data.grafana_data_source.azure_monitor.uid}

não está sendo executado dinamicamente e mostrando uid ilegal

Tenho uma aplicação Node.js com acesso a banco de dados. A string de conexão é obtida de um arquivo JSON e a parte da senha dentro da string de conexão contém salt, nonce e a cifra, que é criptografada por AES-GCM. O segredo para criptografar + descriptografar a senha usa uma derivação de chave do SCrypt dentro da biblioteca interna de criptografia do Node.js. Até agora, tudo bem, a criptografia e a descriptografia funcionam perfeitamente.

Entretanto, para outro caso de uso, tenho que usar essa string de conexão agora de um aplicativo C# e não consigo descriptografar a string de senha.

O método falha com o seguinte erro:

A tag de autenticação computada não corresponde à tag de autenticação de entrada

Já rastreei a derivação da chave. Não consegui encontrar uma implementação .NET que correspondesse à derivação da chave do nodejs.

Aqui está meu código - Node.js:

decrypt(encryptedText) {
    const decoded = Buffer.from(encryptedText, "base64").toString("utf8");
    const [saltHex, ivHex, authTagHex, encryptedHex] = decoded.split(":");
    const salt = Buffer.from(saltHex, "hex");
    const secretByte = Buffer.from(this.secretKey, "utf-8");
    const key = crypto.scryptSync(salt, secretByte, 32, { cost: 16384, blockSize: 8, parallelization: 1 });
    const iv = Buffer.from(ivHex, "hex");
    const authTag = Buffer.from(authTagHex, "hex");
    const decipher = crypto.createDecipheriv("aes-256-gcm", key, iv);
    decipher.setAuthTag(authTag);
    let decrypted = decipher.update(encryptedHex, "hex", "utf8");
    decrypted += decipher.final("utf8");
    return decrypted;
}

Código C#:

public static String DecryptAESGCM(Dictionary<string, byte[]> encrypted, string secret)
{
    byte[] secretByte = Encoding.UTF8.GetBytes(secret);

    //clsLogger.Log(Encoding.UTF8.GetString(encrypted.GetValueOrDefault("salt")), enumLogLevel.INFO);

    // Derive key
    byte[] derivedKey = SCrypt.ComputeDerivedKey(secretByte, encrypted.GetValueOrDefault("salt"), 16384, 8, 1, 1, 32);

    using (AesGcm aes = new AesGcm(derivedKey, encrypted.GetValueOrDefault("tag").Length))
    {
        byte[] plainText = new byte[encrypted.GetValueOrDefault("cipher").Length];
        aes.Decrypt(encrypted.GetValueOrDefault("nonce"), encrypted.GetValueOrDefault("cipher"), encrypted.GetValueOrDefault("tag"), plainText);

        return Encoding.UTF8.GetString(plainText);
    }
}

O dicionário em C# é um armazenamento de valor-chave com byte[]salt, nonce, tag e cifra.

Já tentei várias bibliotecas diferentes para reproduzir a chave derivada e garanti que salt e secret tenham os mesmos valores em node.js e c# antes da função ser chamada, mas as chaves derivadas são sempre diferentes.

Alguém teve um caso semelhante e conseguiu resolver ou tem alguma ideia de como?

Obrigado antecipadamente!
Robin