The operative term here is "a certain amount." `typeof` in Typescript is definitely a dependent type operator (it takes a runtime value and extracts its type which can then be used as a type signature for other types).

You don't have full-spectrum dependent types a la Idris, but you do have some amount of dependent typing. See for example

    type MyResult<T extends boolean> =
        T extends true ? { tag: 'a' } : { tag: 'b' }

    function outputTypeDependsOnInputValue(
        value: boolean
    ): MyResult<typeof value> {
        if (value) {
            // replacing 'a' with 'b' is a type error
            const result: MyResult<typeof value> = { tag: 'a' };
            return result;
        } else {
            // replacing 'b' with 'a' is a type error
            const result: MyResult<typeof value> = { tag: 'b' };
            return result;
        }
    }

> Dependent type systems are complex because they also want to be sound.

Dependent Haskell, if it lands, will not be sound (TypeInType). Idris 2.0 currently also is explicitly not sound. In the case of Idris that's mostly a matter of prioritization, but it's enough to demonstrate that soundness is, perhaps surprisingly, not a huge priority for even all full-spectrum dependently typed languages.

Full TS example:

    type MyResult<T extends boolean> =
        T extends true ? { tag: 'a' } : { tag: 'b' }

    function outputTypeDependsOnInputValue<T extends boolean>(
        value: boolean
    ): MyResult<T>

    function outputTypeDependsOnInputValue(
        value: boolean
    ): MyResult<typeof value> {
        if (value) {
            const result: MyResult<typeof value> = { tag: 'a' };
            return result;
        } else {
            const result: MyResult<typeof value> = { tag: 'b' };
            return result;
        }
    }

    function worksWithA(a: 'a'): void {}

    function worksWithB(b: 'b'): void {}

    function useOurFunction(value: boolean): void {
        if (value) {
            const result = outputTypeDependsOnInputValue<typeof value>(value);
            worksWithA(result.tag);
            // worksWithB(result.tag) is a type error
        } else {
            const result = outputTypeDependsOnInputValue<typeof value>(value);
            worksWithB(result.tag);
            // worksWithA(result.tag) is a type error
        }
    }