> npx tsgo --version
Version 7.0.0-beta

{
  "devDependencies": {
    "typescript": "npm:@typescript/typescript6@^6.0.0",
  }
}

  {
      "compilerOptions": {
          // ...
+         "rootDir": "./src"
      },
      "include": ["./src"]
  }

  {
      "compilerOptions": {
          // Explicitly list the @types packages you need (e.g. bun, mocha, jasmine, etc.)
+         "types": ["node", "jest"]
      }
  }

declare function callIt<T>(obj: {
    produce: (x: number) => T,
    consume: (y: T) => void,
}): void;
 
// Works, no issues.
callIt({
    produce: (x: number) => x * 2,
    consume: y => y.toFixed(),
});
 
// Works, no issues even though the order of the properties is flipped.
callIt({
    consume: y => y.toFixed(),
    produce: (x: number) => x * 2,
});

declare function callIt<T>(obj: {
    produce: (x: number) => T,
    consume: (y: T) => void,
}): void;
 
// Works fine, `x` is inferred to be a number.
callIt({
    produce(x: number) { return x * 2; },
    consume(y) { return y.toFixed(); },
});
 
callIt({
    consume(y) { return y.toFixed(); },
    //                  ~
    // error: 'y' is of type 'unknown'.
 
    produce(x: number) { return x * 2; },
});

function callFunc<T>(callback: (x: T) => void, value: T) {
    return callback(value);
}
 
callFunc(x => x.toFixed(), 42);
//       ^
// We need to figure out the type of `x` here,
// but we also need to figure out the type of `T` to check the callback.

// Arrow syntax - no errors.
callIt({
    consume: y => y.toFixed(),
    produce: (x: number) => x * 2,
});
 
// Method syntax - errors!
callIt({
    consume(y) { return y.toFixed(); },
    //                  ~
    // error: 'y' is of type 'unknown'.
 
    produce(x: number) { return x * 2; },
});

{
    "name": "my-package",
    "type": "module",
    "imports": {
        "#root": "./dist/index.js",
        "#root/*": "./dist/*"
    }
}

{
    "name": "my-package",
    "type": "module",
    "imports": {
        "#": "./dist/index.js",
        "#/*": "./dist/*"
    }
}

// Input: some-file.ts
export function foo(condition: boolean) {
    return condition ? 100 : 500;
}
 
// Output: some-file.d.ts
export declare function foo(condition: boolean): 100 | 500;
//                                               ^^^^^^^^^
//             Note the order of this union: 100, then 500.

// Input: some-file.ts
const x = 500;
export function foo(condition: boolean) {
    return condition ? 100 : 500;
}
 
// Output: some-file.d.ts
export declare function foo(condition: boolean): 500 | 100;
//                                               ^^^^^^^^^
//                           Note the change in order here.

- someFunctionCall(/*...*/);
+ someFunctionCall<SomeExplicitType>(/*...*/);

- const someVariable = { /*... some complex object ...*/ };
+ const someVariable: SomeExplicitType = { /*... some complex object ...*/ };
 
someFunctionCall(someVariable);

let yesterday = Temporal.Now.instant().subtract({
    hours: 24,
});
 
let tomorrow = Temporal.Now.instant().add({
    hours: 24,
});
 
console.log(`Yesterday: ${yesterday}`);
console.log(`Tomorrow: ${tomorrow}`);

const f:any = []
    fields.map((p) =>{
      f.push(p.id)
    })
    console.log("All fields:",f)
// All fields: ["1", "2", "4", "5", "6"]

 
    const tags = {}
 
    f.map((i:any, o:any) => { // je loop mes terrains disponibles
      if(selectedFields.find((e:any) => e == i.toString()) == i){ // Si l'un de mes trois terrains actifs est dans f
        console.log(i, "IS IN ALL FIELD")
        // tags prend la valeur de {"field"+i.toString():"1"})
      }
      else{ // et si elle ne l'est pas, la valeur vient à 0
        console.log(i, "is NOT in all fields")
        // tags prend la valeur de {"field"+i.toString():"0"})
 
      }
    })
// pour contruire, au fur et à mesure de la progression de map()
 
    console.log("TAGS", tags) // doit afficher ceci {"field1":"1", "filed2":"1", "field3":"0", "field4":"0", "field5":"1"}

 
import { useFetchQuery } from "@/hooks/useFetchQuery";
const {data, isFetching} = useFetchQuery("/getsettings/[id_field]/[id_user]", {id_field: 0, id_user:id_user})

import { useInfiniteQuery, useQuery } from '@tanstack/react-query'
 
const endpoint = "https://api.web.ch/dashboard"
 
type API = {
'/getsettings/[id_field]/[id_user]': {
        response: number, 
        id_field: number,
        method: string,
        fields:{
            id_field: number,
            field_name: string,
            field_longname: string,
            field_city: string,
            field_lat: number,
            field_lng: number
        }[],
        settings: {
            id_station_type?: number,
            station_type_name: string,
            station_type_awe?: string,
            field_data: {
                id_field: number,
                field_name: string,
                field_user_role: number,
                station_data: {
                    id_station: number,
                    station_name: string,
                    station_longname: string,
                    station_type_awe: string,
                    station_archive: number,
                    station_lat: number,
                    station_lng: number,
                    station_alt: number,
                    sensors_data: {
                        id_sensor: number,
                        sensor_active: number,
                        sensor_name: string,
                        sensor_unit: string,
                        sensor_longname: string,
                        id_sensor_type: number,
                        sensor_type_name: string,
                        sensor_type_longname: string,
                        sensor_type_awe: string,
                        sensor_chart_style: string,
                        sensor_chart_borderWidth: string,
                        sensor_chart_pointRadius: number,
                        sensor_chart_showLine: number,
                        sensor_chart_fill: number,
                        sensor_chart_borderColor: string,
                        sensor_chart_backgroundColor: string,
                        sensor_chart_pointStyle: string,
                        sensor_threshold_operator:'string',
                        sensor_threshold_min: number,
                        sensor_threshold_max: number,
 
                    }[],
                }[],
            }[],
        }[],
    }
}
 
export function useFetchQuery<T extends keyof API>(path: T, params?: Record<string, string | number>){
    const localurl = endpoint + Object.entries(params ?? {}).reduce((acc, [key, value]) => acc.replaceAll(`[${key}]`, value.toString()) as T, path)
 
    //console.log("useFetchUqrey: ",localurl)
 
    return useQuery({
        queryKey: [localurl],
        //refetchIntervalInBackground: true,  
        //refetchInterval: 60000, // 60 000 ms = 60 secondes
        //refetchOnWindowFocus: false,
        //staleTime:30000,
        queryFn: async () => { // Comment on reécupère les résultat
            //await wait(2);
            return fetch(localurl,{
                headers:{
                    Accept: 'application/json',
                }
            }).then((r) => r.json() as Promise<API[T]>); // Convertir le résultat (r) en json
        },
    })
}

 
const {data, isPaused, isLoading, error, refetch, isFetching}= useQuery({ // Min 52 https://www.youtube.com/watch?v=bpHq_-bPkGo
        queryKey: ['station', params.id, dateRange],
        queryFn: () => fetchStation(params.id, dayjs(dateRange.startDate).format("YYYY-MM-DD"), dayjs(dateRange.endDate).format("YYYY-MM-DD"), id_user),
        //retryOnMount: false,
        refetchInterval: 30000,
        //gcTime: 1000 * 60,
        //staleTime: 1000 * 30, // Data remains fresh for 60 sec
        refetchOnWindowFocus: true,
        //enabled: false,
        //retry: 2, // Retry twice on failure
        //retryDelay: 2000, // Wait 2 seconds between retries
        //select: (data) => data.map((post) => post.title), // Extract only post title
    })

 
import { QueryClient, useInfiniteQuery, useQuery } from '@tanstack/react-query'
 
const uri = "https://api.web.ch/dashboard"
const endpoint = "/getstation/"
const params = "/"
 
const headers = {
    accept: 'application/json',
    Authorisation: 'key',
}
 
export const fetchStation = async (id:string, dateFrom:string, dateTo:string, user_id:number) => {
 
    const url = uri+endpoint+id+'/'+dateFrom+'/'+dateTo+'/'+user_id+'/';
    const options = {
        method: 'GET',
        headers,
    };
 
    try {
        const res = await fetch(url, options);
        /*
        if(!res.ok){
           throw new Error('[fetchQuery] Failed to fetch a s tation') 
        }
        */
        const json = await res.json();
        return json;
 
    }catch(err){
        console.error('[fetchQuery] ' + err);
    }
 
};

 
type API = {
'/getsettings/[id_field]/[id_user]': {
        response: number, 
        id_field: number,
        method: string,
        fields:{
            id_field: number,
            field_name: string,
            field_longname: string,
            field_city: string,
            field_lat: number,
            field_lng: number
        }[],
        settings: {
            id_station_type?: number,
            station_type_name: string,
            station_type_awe?: string,
            field_data: {
                id_field: number,
                field_name: string,
                field_user_role: number,
                station_data: {
                    id_station: number,
                    station_name: string,
                    station_longname: string,
                    station_type_awe: string,
                    station_archive: number,
                    station_lat: number,
                    station_lng: number,
                    station_alt: number,
                    sensors_data: {
                        id_sensor: number,
                        sensor_active: number,
                        sensor_name: string,
                        sensor_unit: string,
                        sensor_longname: string,
                        id_sensor_type: number,
                        sensor_type_name: string,
                        sensor_type_longname: string,
                        sensor_type_awe: string,
                        sensor_chart_style: string,
                        sensor_chart_borderWidth: string,
                        sensor_chart_pointRadius: number,
                        sensor_chart_showLine: number,
                        sensor_chart_fill: number,
                        sensor_chart_borderColor: string,
                        sensor_chart_backgroundColor: string,
                        sensor_chart_pointStyle: string,
                        sensor_threshold_operator:'string',
                        sensor_threshold_min: number,
                        sensor_threshold_max: number,
 
                    }[],
                }[],
            }[],
        }[],
    }
}

$ dx cowsay "Hello, Deno!"
 ______________
< Hello, Deno! >
 --------------
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\
                ||----w |
                ||     ||

const awsSecretKey = Deno.env.get("AWS_SECRET_KEY");
console.log(awsSecretKey);
 
const passwd = await Deno.readTextFile("/etc/passwd");
console.log(passwd);

$ deno run --ignore-read=/etc --ignore-env=AWS_SECRET_KEY main.ts
undefined
error: Uncaught (in promise) NotFound: No such file or directory (os error 2)
const passwd = await Deno.readTextFile("/etc/passwd");
                          ^
    at Object.readTextFile (ext:deno_fs/30_fs.js:799:24)
    at file:///dev/main.ts:4:27

$ SOME_SECRET=foo deno run --allow-env=SOME_SECRET main.ts
{ SOME_SECRET: "foo" }

$ deno install npm:lodahs
Add npm:lodahs@0.0.1-security
 
Dependencies:
+ npm:lodahs 0.0.1-security
 
$ deno audit --socket
 
No known vulnerabilities found
 
Socket.dev firewall report
 
╭ pkg:npm/lodahs@0.0.1-security
│ Supply Chain Risk: 0
│ Maintenance: 76
│ Quality: 41
│ Vulnerabilities: 100
│ License: 100
╰ Alerts (1/0/0): [critical] malware
 
Found 1 alerts across 1 packages
Severity: 0 low, 0 medium, 0 high, 1 critical

# Using Shell (macOS and Linux):
curl -fsSL https://deno.land/install.sh | sh
 
# Using PowerShell (Windows):
iwr https://deno.land/install.ps1 -useb | iex

 /* Save Chart settings */
    const saveChartSettings = async(field:string, value:number) => {
        console.log( "SensorID:", id_sensor , "DB field:", field, "Value:",JSON.stringify(value,null,1))
 
 
        try {
            const response = await fetch('https://api.site-site.ch/putChartSettings.inc.php', {
                method: 'POST',
                headers:{
                    accept:'application(json',
                    Authorisation: 'key',
                },
                body: JSON.stringify({
                    id_sensor: id_sensor,
                    field: field,
                    value: value
                })
            })
 
            if(!response.ok){
                setThresholdError("[Save Threshold] Failed to fetch the API (check the path)")
            }
 
            const json = await response.json();
            console.info("Response:", json);
 
            if(json.response=="200"){
                return 1
            }
            else{
               return 0
            }
 
        }catch(err){
            setThresholdError("[Save setting] Check API path. " + err)
        } finally {
 
        }
    }

if(saveChartSettings('border-color', value) == 1 ){
            setIsBorderColorSaved(1)
        }
        else{
            setIsBorderColorSaved(0)
        }

if(await saveChartSettings('border-color', value) == 1 ){
            setIsBorderColorSaved(1)
        }
        else{
            setIsBorderColorSaved(0)
        }

{
  // Visit https://aka.ms/tsconfig to read more about this file
  "compilerOptions": {
    // File Layout
    // "rootDir": "./src",
    // "outDir": "./dist",
 
    // Environment Settings
    // See also https://aka.ms/tsconfig_modules
    "module": "nodenext",
    "target": "esnext",
    "types": [],
    // For nodejs:
    // "lib": ["esnext"],
    // "types": ["node"],
    // and npm install -D @types/node
 
    // Other Outputs
    "sourceMap": true,
    "declaration": true,
    "declarationMap": true,
 
    // Stricter Typechecking Options
    "noUncheckedIndexedAccess": true,
    "exactOptionalPropertyTypes": true,
 
    // Style Options
    // "noImplicitReturns": true,
    // "noImplicitOverride": true,
    // "noUnusedLocals": true,
    // "noUnusedParameters": true,
    // "noFallthroughCasesInSwitch": true,
    // "noPropertyAccessFromIndexSignature": true,
 
    // Recommended Options
    "strict": true,
    "jsx": "react-jsx",
    "verbatimModuleSyntax": true,
    "isolatedModules": true,
    "noUncheckedSideEffectImports": true,
    "moduleDetection": "force",
    "skipLibCheck": true,
  }
}

// ./some-feature.ts
initializationWithSideEffects();
 
function initializationWithSideEffects() {
  // ...
  specialConstant = 42;
 
  console.log("Side effects have occurred!");
}
 
export let specialConstant: number;

import defer * as feature from "./some-feature.js";
 
// No side effects have occurred yet
 
// ...
 
// As soon as `specialConstant` is accessed, the contents of the `feature`
// module are run and side effects have taken place.
console.log(feature.specialConstant); // 42

//  Not allowed
import defer { doSomething } from "some-module";
 
//  Not allowed  
import defer defaultExport from "some-module";
 
//  Only this syntax is supported
import defer * as feature from "some-module";

error TS2345: Argument of type 'ArrayBufferLike' is not assignable to parameter of type 'BufferSource'.
error TS2322: Type 'ArrayBufferLike' is not assignable to type 'ArrayBuffer'.
error TS2322: Type 'Buffer' is not assignable to type 'Uint8Array<ArrayBufferLike>'.
error TS2322: Type 'Buffer' is not assignable to type 'ArrayBuffer'.
error TS2345: Argument of type 'Buffer' is not assignable to parameter of type 'string | Uint8Array<ArrayBufferLike>'.