import { writable } from 'svelte/store'
import type { Writable } from 'svelte/store'

import { writable, type Writable } from 'svelte/store'

export const email: Writable<null | string> = writable('')

export const email: Writable<string | undefined> = writable()

    import * as Grain from '../../../../grain-types'

    import * as Grain from '../../../../../grain-types'

    } from '../../../../plot'
    import type { Sample } from '../../../../plot'

    } from '../../../../../plot'
    import type { Sample } from '../../../../../plot'

    let { data, annee = data.annee, pvgis_loading = true } = $props()
    console.log(data)

    let {
        data = $bindable(),
        annee = data.annee,
        pvgis_loading = true,
    } = $props()
    const data_ = $state(data)

    let prms: Writable<
        {
            prm: null | number
            nom: string
            prenom: string
            siret: string
            pro: boolean
        }[]
    > = getContext('prms')
    let prms_modified: Writable<boolean> = getContext('prms_modified')
    let profils: Writable<{ type: string; conso: number }[]> =
        getContext('profils')
    let profils_modified: Writable<boolean> = getContext('profils_modified')

        data.prms.push({ prm: null, nom: '', prenom: '', siret: '', pro: true })
        data.prms = data.prms

        prms.update((prms) => {
            prms.push({
                prm: null,
                nom: '',
                prenom: '',
                siret: '',
                pro: true,
            })
            return prms
        })
        prms_modified.set(true)

        for (let p of data.prms) {
            p.consentement = false

        if (data_.prms) {
            for (let p of data_.prms) {
                p.consentement = false
            }

        const prt = Object.keys(profils_)
        data.profils.push({ type: prt[0], conso: 0 })
        data.profils = data.profils

        profils.update((p) => {
            const prt = Object.keys(profils_)
            p.push({ type: prt[0], conso: 0 })
            return p
        })
        profils_modified.set(true)
        updatePlot(puissance, communaute)

    async function delProfil(i: number) {
        data.profils.splice(i, 1)
        data.profils = data.profils
        await updatePlot(puissance, communaute)

    function delProfil(i: number) {
        profils.update((p) => {
            p.splice(i, 1)
            return p
        })
        profils_modified.set(true)
        updatePlot(puissance, communaute)

        if (data.prms) {

        if (data_.prms) {

            for (let i = 0; i < data.prms.length; i++) {

            for (let i = 0; i < data_.prms.length; i++) {

                    data.prms[i].releve = r

                    data_.prms[i].releve = r

                            data.prms[i].nom = ent.results[0].dirigeants[0].nom
                            data.prms[i].prenom =

                            data_.prms[i].nom = ent.results[0].dirigeants[0].nom
                            data_.prms[i].prenom =

                            data.prms[i].codeinsee =

                            data_.prms[i].codeinsee =

                            console.log(data.prms[i])

                            console.log(data_.prms[i])

            console.log(data.prms)

            console.log(data_.prms)

                `${server}/api/grain/projet/${data.id || 'nouveau'}/prms`,

                `${server}/api/grain/projet/${data_.id || 'nouveau'}/prms`,

                    body: JSON.stringify(data.prms),

                    body: JSON.stringify(data_.prms),

        if (!annee) {
            return
        }

            data.profils,

            $profils,

        {#if data.profils.length}

        {#if $profils?.length}

                    {#each data.profils as pr, i (i)}

                    {#each $profils as pr, i (i)}

                                    onchange={() =>
                                        updatePlot(puissance, communaute)}>

                                    onchange={() => {
                                        profils_modified.set(true)
                                        updatePlot(puissance, communaute)
                                    }}>

        {#if data.active && data.id && data.id != 'nouveau'}

        {#if data_.active && data_.id && data_.id != 'nouveau'}

            {#if data.prms.length}
                {#each data.prms as prm, i (prm)}

            {#if data_.prms?.length}
                {#each data_.prms as prm, i (prm)}

                                    data.prms.splice(i, 1)
                                    data.prms = data.prms

                                    data_.prms.splice(i, 1)
                                    data_.prms = data_.prms

                {#if data.prms.length}

                {#if data_.prms?.length}

                        disabled={!!data.prms.find(

                        disabled={!!data_.prms.find(

        {:else if data.active}

        {:else if data_.active}

    const data = $props()

    const props = $props()
    let data = $state(props.data)

<Simulation {data} />

<Simulation bind:data />

    import * as Grain from '../../../../grain-types'

    import * as Grain from '../../../../../grain-types'

    import * as L from 'leaflet'

    import type * as L from 'leaflet'

    import { asset } from '$app/paths'

        L.Map.addInitHook('addHandler', 'gestureHandling', G.GestureHandling)

        leaflet.Map.addInitHook(
            'addHandler',
            'gestureHandling',
            G.GestureHandling
        )

        map = L.map(L.DomUtil.create('div'), {

        map = leaflet.map(leaflet.DomUtil.create('div'), {

            $communaute.circle = L.circle($communaute, circleOpts).addTo(map)

            $communaute.circle = leaflet
                .circle($communaute, circleOpts)
                .addTo(map)

        let layer = L.tileLayer(
            `https://tile.openstreetmap.org/{z}/{x}/{y}.png`,
            {

        let layer = leaflet
            .tileLayer(`https://tile.openstreetmap.org/{z}/{x}/{y}.png`, {

            }
        ).addTo(map)

            })
            .addTo(map)

            redIcon = L.icon({

            redIcon = leaflet.icon({

                c.dot = L.marker(c, {

                c.dot = leaflet.marker(c, {

                $communaute!.circle = L.circle(e.latlng, circleOpts).addTo(map)

                $communaute!.circle = leaflet!
                    .circle(e.latlng, circleOpts)
                    .addTo(map)

                    dot: L.marker(e.latlng, {

                    dot: leaflet!.marker(e.latlng, {

                    const d = diff(b.features[i].properties.label, endroit)

                    const d = diff(
                        b.features[i].properties.label.toLowerCase(),
                        endroit.toLowerCase()
                    )

                console.log('diff', min, argmin)
                if (!$communaute) {
                    communaute.set({
                        lat: b.features[argmin].geometry.coordinates[1],
                        lng: b.features[argmin].geometry.coordinates[0],
                        compteurs: [],
                        derogation,
                    })

                if (min >= 0) {
                    console.log('diff', min, argmin)
                    if (!$communaute) {
                        communaute.set({
                            lat: b.features[argmin].geometry.coordinates[1],
                            lng: b.features[argmin].geometry.coordinates[0],
                            compteurs: [],
                            derogation,
                        })
                    }
                    $communaute!.lng =
                        b.features[argmin].geometry.coordinates[0]
                    $communaute!.lat =
                        b.features[argmin].geometry.coordinates[1]

                $communaute!.lng = b.features[argmin].geometry.coordinates[0]
                $communaute!.lat = b.features[argmin].geometry.coordinates[1]

    <link rel="stylesheet" href="{assets}/leaflet.css" />
    <link rel="stylesheet" href="{assets}/leafletfs.css" />
    <link rel="stylesheet" href="{assets}/leaflet-gesture-handling.min.css" />

    <link rel="stylesheet" href={asset('/static/leaflet.css')} />
    <link rel="stylesheet" href={asset('/static/leafletfs.css')} />
    <link
        rel="stylesheet"
        href={asset('/static/leaflet-gesture-handling.min.css')} />

import type { Grain } from '../../../helpers'
import * as H from '../../../helpers'
import type { Sample } from '../../../plot'
import { sample } from '../../../plot'

import type { Grain } from '../../../../helpers'
import * as H from '../../../../helpers'
import type { Sample } from '../../../../plot'
import { sample } from '../../../../plot'

    modified: Writable<boolean>

        this.modified = writable(false)

                w.subscribe(
                    (value) =>
                        (this.s[k as keyof Grain.SimulationCommunaute] =
                            value as any)
                )

                w.subscribe((value) => {
                    this.s[k as keyof Grain.SimulationCommunaute] = value as any
                    this.modified.set(true)
                })

                    console.log('TARIF', $N)

                    resultat.remboursement = new Array($duree + 1)
                    resultat.crd = new Array($duree + 1)
                    resultat.interets = new Array($duree + 1)

                    resultat.remboursement = new Array(Math.ceil($duree) + 1)
                    resultat.crd = new Array(Math.ceil($duree) + 1)
                    resultat.interets = new Array(Math.ceil($duree) + 1)

    import * as H from '../../../helpers'
    import type { Sample } from '../../../plot'

    import * as H from '../../../../helpers'
    import type { Sample } from '../../../../plot'

    import type { Writable } from 'svelte/store'

    import { derived, type Readable, type Writable } from 'svelte/store'

    let an = new Date().getFullYear()

    // let an = new Date().getFullYear()

    let resultatNetData: { id: string; data: { x: number; y: number }[] }[] = [
        { id: '', data: [] },
    ]
    $effect(() => {
        resultatNetData[0] = {
            id: '',
            data: new Array($N).fill(0).map((_, i) => {
                return { x: an + i, y: $resultatNet[i] }
            }),
        }
    })

    // let resultatNetData: { id: string; data: { x: number; y: number }[] }[] =
    //     $derived(() => {
    //         return [
    //             {
    //                 id: '',
    //                 data: new Array($N).fill(0).map((_, i) => {
    //                     return { x: an + i, y: $resultatNet[i] }
    //                 }),
    //             },
    //         ]
    //     })
    //           data: new Array($N).fill(0).map((_, i) => {
    //               return { x: an + i, y: $resultatNet[i] }
    //           }),

    let maxa = $state(0)
    let mina = $state(0)
    let margin = $state(1)
    function traceArray(f: Array<number>, n: number) {

    // let maxa = $state(0)
    // let mina = $state(0)
    // let margin = $state(1)
    function traceArray(
        f: Array<number>,
        n: number
    ): { maxa: number; mina: number; margin: number; c: string } {
        let maxa = 0
        let mina = 0
        let margin = 1

        return c

        return { maxa, mina, margin, c }

    let tr: Readable<{
        mina: number
        maxa: number
        c: string
        margin: number
    }> = derived([resultatNet, N], ([$resultatNet, $N]) => {
        console.log('TRACE')
        // return { maxa: 0, mina: 0, margin: 1, c: '' }
        return traceArray($resultatNet, $N)
    })

                                    -maxa - margin

                                    -$tr.maxa - $tr.margin

                                    maxa - mina + 2 * margin

                                    $tr.maxa - $tr.mina + 2 * $tr.margin

                                    d={traceArray($resultatNet, $N)}

                                    d={$tr.c}

<script lang="ts">
    import Synthese from './Synthese.svelte'
</script>
<Synthese />

import { mkdirSync, writeFile } from 'node:fs'

import { PROJETS_DIR } from '$env/static/private'

    save: async () => {
        console.log('Pas de sauvegarde configurée')

    save: async ({ request }) => {
        const data = await request.formData()
        const d = data.get('data')
        if (d) {
            const b = JSON.parse(d as string)
            const nom_ = b.nom.replaceAll('/', '_')
            b.id = nom_
            try {
                mkdirSync(PROJETS_DIR)
            } catch (err) {
                if (
                    err &&
                    typeof err == 'object' &&
                    'code' in err &&
                    err.code != 'EEXIST'
                ) {
                    console.error(err)
                }
            }
            writeFile(
                PROJETS_DIR + '/' + nom_ + '.json',
                JSON.stringify(b),
                (err) => {
                    if (err) {
                        console.error(err)
                    }
                }
            )
            return nom_
        }
        return null

    import { writable } from 'svelte/store'

    import { derived, writable } from 'svelte/store'

    import { email } from '../../../stores'

    } from '../../../grain-types'

    } from '../../../../grain-types'
    import { goto } from '$app/navigation'

    let data: {
        nom: string
        porteur: string
        adresse: string
        tel: string
        id: string

    type Data = {
        nom?: string
        porteur?: string
        adresse?: string
        tel?: string
        id?: string

        prms: Prm[]
        profils: Profil[]
        email?: string

        prms?: Prm[]
        profils?: Profil[]

        expert: boolean
        N: number
    } = props.data

        expert?: boolean
        email?: string
    }

    let data: Data = $state(props.data)

    setContext('simulation', simulation)
    setContext('banque', simulation.banque)
    setContext('communaute', writable(null))

    let profils_modified = writable(false)
    let prms_modified = writable(false)

    let needsSaving = derived(
        [simulation.modified, profils_modified, prms_modified],
        ([$mod, $profils, $prms]) => {
            console.log('derived', $mod)
            return $mod || $profils || $prms
        }
    )
    setContext('simulation', simulation)
    setContext('profils', writable(data.profils || []))
    setContext('prms', writable(data.prms || []))
    setContext('profils_modified', profils_modified)
    setContext('prms_modified', writable(data.prms || []))
    let communaute = writable(data.communaute)
    setContext('communaute', communaute)

    const compteActive = page.route.id?.endsWith('/finances') ?? false
    const descriptionActive = page.route.id?.endsWith('/description') ?? false
    const banqueActive = page.route.id?.endsWith('/banque') ?? false
    const expertActive = page.route.id?.endsWith('/expert') ?? false
    const simuActive = page.route.id?.endsWith('/simulation') ?? false
    const syntheseActive =

    const compteActive = $derived(page.route.id?.endsWith('/finances') ?? false)
    const descriptionActive = $derived(
        page.route.id?.endsWith('/description') ?? false
    )
    const banqueActive = $derived(page.route.id?.endsWith('/banque') ?? false)
    const expertActive = $derived(page.route.id?.endsWith('/expert') ?? false)
    const simuActive = $derived(page.route.id?.endsWith('/simulation') ?? false)
    const syntheseActive = $derived(

        !descriptionActive &&
        !banqueActive &&
        !expertActive &&
        !simuActive

            !descriptionActive &&
            !banqueActive &&
            !expertActive &&
            !simuActive
    )

        email.set(data.email || null)
        email.subscribe((value) => {
            if (value) data.email = value
        })

    async function save_() {
        let resp = await fetch(`/grain/projet/${props.params.id}?/save`, {
            method: 'POST',
            headers: {
                'content-type': 'application/x-www-form-urlencoded',
            },
            body:
                'data=' +
                encodeURIComponent(
                    JSON.stringify(<Data>{
                        id: data.id,
                        nom: data.nom,
                        simulation: simulation.s,
                        prms: data.prms,
                        profils: data.profils,
                        communaute: $communaute,
                        expert: $expert,
                    })
                ),
        })
        let id = await resp.json()
        console.log('ID', id)
        simulation.modified.set(false)
        profils_modified.set(false)
        prms_modified.set(false)
        return JSON.parse(id.data)[0]
    }
    async function save() {
        let id: string | null = await save_()
        console.log('SAVED', id)
        if (id && id != data.id) {
            data.id = id
            goto(resolve('/grain/projet/[id]', { id }))
        }
    }

                    <form action="/projet/{data.id}/?save">
                        <button class="my-2 btn btn-sm btn-primary"
                            >Sauvegarder</button>

                    <form onsubmit={save}>
                        <button
                            class="my-2 btn btn-sm btn-primary"
                            disabled={!$needsSaving}>Sauvegarder</button>

                        href={resolve('/projet/[id]', { id: data.id })}
                        class="nav-link {syntheseActive && 'active'}"

                        href={resolve('/grain/projet/[id]', {
                            id: data.id || 'nouveau',
                        })}
                        class="nav-link {syntheseActive ? 'active' : ''}"

                        href={resolve('/projet/[id]/finances', { id: data.id })}
                        class="nav-link {compteActive && 'active'}"

                        href={resolve('/grain/projet/[id]/finances', {
                            id: data.id || 'nouveau',
                        })}
                        class="nav-link {compteActive ? 'active' : ''}"

                        href={resolve('/projet/[id]/description', {
                            id: data.id,

                        href={resolve('/grain/projet/[id]/description', {
                            id: data.id || 'nouveau',

                        class="nav-link {descriptionActive && 'active'}"

                        class="nav-link {descriptionActive ? 'active' : ''}"

                        href={resolve('/projet/[id]/banque', { id: data.id })}
                        class="nav-link {banqueActive && 'active'}"

                        href={resolve('/grain/projet/[id]/banque', {
                            id: data.id || 'nouveau',
                        })}
                        class="nav-link {banqueActive ? 'active' : ''}"

                            href={resolve('/projet/[id]/expert', {
                                id: data.id,

                            href={resolve('/grain/projet/[id]/expert', {
                                id: data.id || 'nouveau',

                            class="nav-link {expertActive && 'active'}"

                            class="nav-link {expertActive ? 'active' : ''}"

                        href={resolve('/projet/[id]/simulation', {
                            id: data.id,

                        href={resolve('/grain/projet/[id]/simulation', {
                            id: data.id || 'nouveau',

                        class="nav-link {simuActive && 'active'}"

                        class="nav-link {simuActive ? 'active' : ''}"

import { Grain } from '../../../helpers'
import * as fs from 'node:fs'

import { Grain } from '../../../../helpers'
import { readFileSync } from 'node:fs'
import { PROJETS_DIR } from '$env/static/private'

    console.log('LOAD')

        return fs.readFileSync(params['id'], 'utf8')

        const result = JSON.parse(
            readFileSync(
                PROJETS_DIR + '/' + fixNom(params.id) + '.json',
                'utf8'
            )
        )
        console.log(result)
        return result

function fixNom(nom: string): string {
    return nom.replaceAll('/', '_')
}

    import { onMount } from 'svelte'
    import '../app.scss'
    import { email } from '../stores'

    import { getContext, onMount } from 'svelte'
    import '../../app.scss'

    import type { Writable } from 'svelte/store'

    const email: Writable<string | undefined> = getContext('email')

        email.set(data.email || null)

        email.set(data.email)

                href={resolve('/projet/nouveau', {})}>Lancer ma simulation</a>

                data-testid="a-projet-nouveau"
                href={resolve('/grain/projet/nouveau', {})}
                >Lancer ma simulation</a>

                                href={resolve('/projet/[pid]', { pid: p.id })}

                                href={resolve('/grain/projet/[pid]', {
                                    pid: p.id,
                                })}

                href={resolve('/projet/nouveau', {})}>Je lance ma simulation</a>

                href={resolve('/grain/projet/nouveau', {})}
                >Je lance ma simulation</a>

    import '../app.scss'

    import '../../app.scss'

    import '../app.scss'

    import '../../app.scss'

<script lang="ts">
    import GrainMain, { type Data } from './GrainMain.svelte'
    const { data }: { data: Data } = $props()
</script>
<GrainMain {data} />

    import '../app.scss'

    import '../../app.scss'

    import { page } from '$app/state'

                            <a class="nav-link" href={resolve('/apropos', {})}
                                >À propos</a>
                        </li>
                        <li class="nav-item mx-2">

                                class="btn btn-sm btn-outline-primary"
                                href={resolve('/projet/nouveau', {})}
                                >Je lance ma simulation</a>

                                class="nav-link"
                                href={resolve('/grain/apropos', {})}
                                >À propos</a>

                        {#if !page.url.pathname.startsWith('/grain/projet')}
                            <li class="nav-item mx-2">
                                <a
                                    class="btn btn-sm btn-outline-primary"
                                    href={resolve('/grain/projet/[id]', {
                                        id: 'nouveau',
                                    })}>Je lance ma simulation</a>
                            </li>
                        {/if}

import { redirect } from '@sveltejs/kit'
import type { PageLoad } from './$types'
export const load: PageLoad = async () => {
    throw redirect(301, '/grain')
}

        Plotly!.newPlot(plot, [soleil, somme], layout_, {
            responsive: true,
            modeBarButtonsToRemove: modeBarButtonsToRemove,
            displaylogo: false,
            displayModeBar: true,
        })
        //@ts-ignore
        plot.on('plotly_relayout', (event: any) =>
            relayout(event, plot, Plotly, layout, has_plot, soleil, somme)
        )

        Plotly!
            .newPlot(plot, [soleil, somme], layout_, {
                responsive: true,
                modeBarButtonsToRemove: modeBarButtonsToRemove,
                displaylogo: false,
                displayModeBar: true,
            })
            (plot as any)
            .on('plotly_relayout', (event: any) =>
                relayout(event, plot, Plotly, layout, has_plot, soleil, somme)
            )

.git
.DS_Store