:

Nachträglich noch mal einen schönen ersten Advent und bald 2ten Advent schon mal vorweg 🙂

Hätte mal eine Frage:
Hat von euch schon mal jemand einen Living Style Guide aus technischer Sicht selber gebaut?

Ich weiß, dass es Style-Guide generatoren gibt aber die sind alle zu sehr an eine bestimmte Technologie geknüpft. Ich erkläre einfach mal grob, wie es bei uns im Unternehmen so läuft. Vielleicht wird dann meine Frage etwas verständlicher. Ich sag auch mein aktuelles Problem dazu:

Dazu hatte ich nun die grundlegende Idee, ein Package einer WC einfach so aufzubauen, dass man förmlich einen Ordner hat, worin man die reine Component entwickelt und einen weiteren, wo man Docu-Snippets und auch Live-Demos oder sowas drin ablegen kann. Allgemein war meine Idee zu den Doku's so, dass man , um einen visuellen einheitlichen Stil zu gewährleisten, alle Informationen als *.md ( MarkDown ) Files schreibt.

Frage 1 wäre nun:
Wie würdet ihr die "einzelnen" Live-Demo-Beispiele bauen und zur Verfügung stellen?

Frage 1 wäre nun:

Dazu hatte ich nun die grundlegende Idee, ein Package einer WC einfach so aufzubauen, dass man förmlich einen Ordner hat, worin man die reine Component entwickelt und einen weiteren, wo man Docu-Snippets und auch Live-Demos oder sowas drin ablegen kann. Allgemein war meine Idee zu den Doku's so, dass man , um einen visuellen einheitlichen Stil zu gewährleisten, alle Informationen als *.md ( MarkDown ) Files schreibt.

Frage 1 wäre nun:
Wie würdet ihr die "einzelnen" Live-Demo-Beispiele bauen und zur Verfügung stellen?

Frage 2:
Wie könnte das Package des Living-Style-Guide aussehen bzw. wie könnte man die ganzen Informationen "möglichst" automatisiert so zusammen mergen, dass am Ende eine HTML bei raus kommt, die halt Infos zur Komponente gibt, wie auch Live-Demos zeigt etc......

hmm mit select ist es das gleich, eigentlich klar

wsA.Range("a1,b1").EntireColumn.Select

        Selection.ExportAsFixedFormat _

        Type:=xlTypePDF, _

        Filename:=myFile, _

Auch so wird jede Spalte auf einem extra Blatt ausgegeben

Ich hab auch eine Frage, vielleicht weiß ja jemand wie man das bequem löst.
Ich muss Elemente miteinander vergleichen und wenn ein Element mit allen bisherigen Elementen
der Liste mir ein 'unknown' liefert, dann ist das ein neues Element.
Wenn das NICHT so ist, hätte ich gern das label des bereits bekannten Elements.

Mir wurde geraten dafür ein Maybe Pattern (in TypeScript) zu verwenden aber so richtig werde ich daraus nicht schlau.
Naja hier erst mal mein Code:

function knownState(
  referenceList: UpgradedDecetionInterface[],
  currentElement: UpgradedDecetionInterface
): boolean {
  const newPerson = referenceList.every(referenceFace => {
    const bestMatch = referenceFace.faceMatcher.findBestMatch(
      currentElement.descriptor[0]
    );

    return bestMatch.label === 'unknown';
  });

  return newPerson;
}```
`newPerson` ist nur dann true, wenn das `every` bei jedem bisherigen Element 'unknown' ist, wie schon erwähnt.
Das Ding ist, wie komm ich jetzt am besten an das Label rann, ohne noch mal `findBestMatch` auszuführen?

Benutzen tue ich das bisher so:
```Javascript
const copyListOfDetections = listOfDetections;
let resultList: UpgradedDecetionInterface[] = [];

copyListOfDetections.map((detection, index) => {
    if (index >= 1) {
        const stateOfDetection = knownState(resultList, detection);

        if (stateOfDetection.known) {
            console.log('Kenn ich');
        } else {
            console.log('Kenn ich nicht');
            resultList.push(detection);
        }
    }
}```

Ich hab auch eine Frage, vielleicht weiß ja jemand wie man das bequem löst.
Ich muss Elemente miteinander vergleichen und wenn ein Element mit allen bisherigen Elementen
der Liste mir ein 'unknown' liefert, dann ist das ein neues Element.

Wenn das NICHT so ist, hätte ich gern das label des bereits bekannten Elements.

Mir wurde geraten dafür ein Maybe Pattern (in TypeScript) zu verwenden aber so richtig werde ich daraus nicht schlau.
Naja hier erst mal mein Code:

function knownState(
  referenceList: UpgradedDecetionInterface[],
  currentElement: UpgradedDecetionInterface
): boolean {
  const newPerson = referenceList.every(referenceFace => {
    const bestMatch = referenceFace.faceMatcher.findBestMatch(
      currentElement.descriptor[0]
    );

    return bestMatch.label === 'unknown';
  });

  return newPerson;
}

newPerson ist nur dann true, wenn das every bei jedem bisherigen Element 'unknown' ist, wie schon erwähnt.
Das Ding ist, wie komm ich jetzt am besten an das Label rann, ohne noch mal findBestMatch auszuführen?

Benutzen tue ich das bisher so:

const copyListOfDetections = listOfDetections;
let resultList: UpgradedDecetionInterface[] = [];

copyListOfDetections.map((detection, index) => {
    if (index >= 1) {
        const stateOfDetection = knownState(resultList, detection);

        if (stateOfDetection.known) {
            console.log('Kenn ich');
        } else {
            console.log('Kenn ich nicht');
            resultList.push(detection);
        }
    }
}```

Ich hab auch eine Frage, vielleicht weiß ja jemand wie man das bequem löst.
Ich muss Elemente miteinander vergleichen und wenn ein Element mit allen bisherigen Elementen
der Liste mir ein 'unknown' liefert, dann ist das ein neues Element.

Wenn das NICHT so ist, hätte ich gern das label des bereits bekannten Elements.

Mir wurde geraten dafür ein Maybe Pattern (in TypeScript) zu verwenden aber so richtig werde ich daraus nicht schlau.
Naja hier erst mal mein Code:

function knownState(
  referenceList: UpgradedDecetionInterface[],
  currentElement: UpgradedDecetionInterface
): boolean {
  const newPerson = referenceList.every(referenceFace => {
    const bestMatch = referenceFace.faceMatcher.findBestMatch(
      currentElement.descriptor[0]
    );

    return bestMatch.label === 'unknown';
  });

  return newPerson;
}

newPerson ist nur dann true, wenn das every bei jedem bisherigen Element 'unknown' ist, wie schon erwähnt.
Das Ding ist, wie komm ich jetzt am besten an das Label rann, ohne noch mal findBestMatch auszuführen?

Benutzen tue ich das bisher so:

const copyListOfDetections = listOfDetections;
let resultList: UpgradedDecetionInterface[] = [];

copyListOfDetections.map((detection, index) => {
    if (index >= 1) {
        const stateOfDetection = knownState(resultList, detection);

        if (stateOfDetection.known) {
            console.log('Kenn ich');
        } else {
            console.log('Kenn ich nicht');
            resultList.push(detection);
        }
    }
}

export class UnknownDetection {
    known: boolean = false;
}

export class KnownDetection {
    known: boolean = true;
    label: string;
    distance: number;
}

export type knownDetection = UnknownDetection | KnownDetection;

sah dann so aus:

function knownState(
    referenceFaces: UpgradedDecetionInterface[],
    currentDetection: UpgradedDecetionInterface,
): knownDetection {
    let knownPersonLabel: knownDetection = { known: false };

    const newPerson = referenceFaces.every(referenceFace => {
        const bestMatch = referenceFace.faceMatcher.findBestMatch(
            currentDetection.descriptor[0],
        );

        if (bestMatch.label !== 'unknown') {
            knownPersonLabel = {
                distance: bestMatch.distance,
                known: true,
                label: bestMatch.label,
            };
        }

        return bestMatch.label === 'unknown';
    });

    if (newPerson) {
        const unknownState = {
            known: false,
        };
        console.log(unknownState);

        return unknownState
    } else {
        console.log(knownPersonLabel);

        knownPersonLabel;
    }
}

tarvos90: sowas in der Richtung:

    let result: { label: knownDetection, newPerson: boolean } = {
        label: { known: false },
        newPerson: false,
    }

    const result = referenceFaces.reduce((prev, current) => {
        
    })

so geht's lol :D

function getKnownState(
    referenceFaces: UpgradedDecetionInterface[],
    currentDetection: UpgradedDecetionInterface,
): knownStateInterface {
    // Returns true if every referenceFace in referenceFaces
    // compared to one Detection is labeled as 'unknown'.
    const isNew = referenceFaces.every(referenceFace => {
        const bestMatch = referenceFace.faceMatcher.findBestMatch(
            currentDetection.descriptor[0],
        );

        return bestMatch.label === 'unknown';
    });

    if (isNew) {
        const newDetection = {
            known: false,
        };

        return newDetection;
    }

    const bestMatchLabels = referenceFaces.map(referenceFace => {
        const bestMatch = referenceFace.faceMatcher.findBestMatch(
            currentDetection.descriptor[0],
        );

        return bestMatch.toString(false);
    });

    const bestMatchLabel = bestMatchLabels.filter(label => {
        return label !== 'unknown';
    })[0];

    const knownDetection = {
        known: true,
        label: bestMatchLabel,
    };

    return knownDetection;
}

tarvos90: Würde das eher so machen:

    const bestMatchLabel = bestMatchLabels.filter(label => {
        return label !== 'unknown';
    }).shift();

Finde so Array-Access über index nicht so optimal, weil es ja nicht umbedingt gegeben sein muss das es das Element gibt.