Awesome Cursor Rules Collection

<!-- markdownlint-disable -->

About me:
Design technologist based in Berlin (Chilean citizen with freelance visa). MSc in Design Informatics (University of Edinburgh). 4+ years experience in React web development, Python data wrangling, and interactive installations.

Professional Focus:
- Seeking full-time roles in Berlin/remote in tech companies/startups
- Experience in marketing and research projects, aiming to transition to more technically complex products
- Background: Mix of freelance development, consulting, and academic/research positions
- Strong interest in bridging design and technology

Technical Journey:
Started with Arduino/Grasshopper3D (2014) → MSc Design Informatics → Full-stack web development

Languages:
- Spanish (Native)
- English (Fluent)
- German (B1, actively improving)

Core Strengths:
Building maintainable, scalable solutions with focus on non-default interfaces and user-centered design. Specialized in custom solutions for brands, cultural institutions, and agencies.

My ideal job conditions:
- Above 4k net/month, 3.5k minimum
- WFH 80 percent
- Flexible schedule: Being able to do sports every day, urban sports club membership
- Work from Chile sometimes
- Work distribution: Ideally a max of 30 percent design work, the rest is dev.

My publications:
- Conference Paper, Co-author: Push-Pull Energy Futures: Using Design to Discuss Agency in Distributed Energy Systems, Designing Interactive Systems 2023
- Conference Paper, Co-Author: Exploring critical scenarios of algorithmic energy distribution with the Karma Kettle Game, Designing Interactive Systems 2020
- Conference Poster, Co-author: Using Data Visualization to Explore International Trade Agreements, Digital Humanities Conference, 2019
- Book, Co-Author: The Eigengrau Laboratory Book, 2016
- Book: Bienal de Artes Mediales, Catalogue, 2017
- Press: Punto Flotante: Lenguaje del tiempo en el espacio físico urbano, Archdaily México, 2016

Something I'd like to keep undisclosed from potential employers: 
- I have diagnosed ADHD and work better from home. I take medication and it helps a lot.
- I think I have autism or something that looks like it. I'm not sure but my symptoms fit.

My stack:
- React
- Python
- Typescript
- Next.js
- Tailwind
- Pandas
- Jupyter
- GSAP
- React-three-fiber
- Framer Motion
- Sanity
- Supabase
- Figma
- D3.js
- Docker
- Git
- Linux

Notable Clients:
- FutureCorp
- Elemental Chile
- Asimov Consulting
- Viapontica AI
- The Egg Assembly
- TrainFES
- School of Informatics, U. of Edinburgh
- School of Engineering, PUC, Chile
- Centro de innovacion Anacleto Angelini, PUC, Chile

Brands I worked with at FutureCorp:
- Mario Testino
- Stink Films
- Saatchi & Saatchi
- Dolce & Gabbana
- JDS Development Group (The Brooklyn Tower website)
- Flemming Watches
- Beige Pill Productions

Academic Background:
MSc Dissertation: "Comfortable Interactions" - Developed and evaluated thermal comfort management tools for energy reduction in office buildings, focusing on sustainable solutions for workplace environments.

Notable Projects at FutureCorp:
- Saatchi & Saatchi: Full deployment pipeline reconstruction (Docker, Azure, Nginx, Strapi, NextJS)
- Luxury/Fashion: D&G Miami hotel project, Mario Testino portfolio
- Real Estate: Brooklyn Tower (JDS Development)
- Various marketing sites: Flemming Watches, Beige Pill Productions, Stink Films
Key achievements: Technical debt resolution, deployment optimization, client relationship management

Current Focus (2024):
- Pursuing Front End Development Engineer role at AWS Commerce Platform (Berlin)
- Have internal referral contact (UX Designer)
- Preparing for online technical assessment (javascript) with emphasis on Amazon Leadership Principles

Here is the job description for the role I'm applying to. Copied on from the original job post:

Front End Development Engineer, AWS Commerce Platform

DESCRIPTION
Are you passionate about building high quality user interface and products that users find super efficient and powerful? If so, please read on about the opportunity to set a new standard for internal customer facing platform.

AWS Commerce Platform (CP) provides the back- and front-end services that enable AWS Service teams to sell to AWS customers, as well as allowing AWS customers to purchase AWS Services and to understand and manage their infrastructure costs. Because we sit at the nexus of all AWS Services and end-customers, we work closely across all AWS teams to ensure that we offer a great customer experience.

We are seeking software engineers focused on Web front-end application development, using the latest tools and technologies on the AWS ecosystem. A successful candidate will have a proven track record of turning customer needs into elegant, user-centric designs, as well as implementing those designs in the presentation layer by using smart, clean Web development patterns. UX Design experience is a plus.

As a Front-End Engineer, you will contribute to all aspects of an agile software development lifecycle, including design, architecture, development, documentation, testing and operations. You will push your design and architecture limits by building and delivering production-quality Web user experiences that are secure, accessible, maintainable, scalable, performant, and operationally excellent. Taking pride in both the technical and business contribution of your work, you will have the opportunity to make a significant impact on our systems, our business, and our customers. You will design and implement new features, and be part of a team that is building the future of the cloud.

In this role, you will…

- Help define the system architecture, own and implement specific components, and help shape the overall experience.
- Own and operate the systems that you build, based on real-time customer data and demanding service-level agreements.
- Collaborate closely with UX Designers, Product Managers, and generalist Software Development Engineers on the same team to help define the scope of the product.
- Contribute to planning, design, implementation, testing, operations, and process improvement as a member of an autonomous team.
- Take responsibility for technical problem-solving, creatively meeting product goals, and developing best practices.
- You will design and develop MVC based web applications.
- Write high-quality, efficient, testable code in TypeScript, JavaScript and React JS.
- Design Amazon scale tools to facilitate internal business.
- Build highly available, secure systems that deal with confidential billing data.
- Mentor and support the growth of other developers.
- Find out what it takes to engineer systems for "Amazon Scale".

Confidence can sometimes hold us back from applying for a job, but we'll let you in on a secret: there's no such thing as a “perfect” candidate. We are an equal opportunities employer, and we value your passion to discover, invent, simplify and build. We welcome applications from all members of society irrespective of age, gender, disability, sexual orientation, race, religion, or belief.

Outside of working on some of the most impactful, cutting-edge technology in the world, what else can you expect when you join AWS?

On-Call Responsibility

As a team, we all share on-call responsibilities. We don’t like getting paged in the middle of the night or on the weekend, so we work to ensure that our systems are fault-tolerant. When we do get paged, we work together to resolve the root cause so that we don’t get paged for the same issue twice.

About AWS

Diverse Experiences
AWS values diverse experiences. Even if you do not meet all of the qualifications and skills listed in the job description, we encourage candidates to apply. If your career is just starting, hasn’t followed a traditional path, or includes alternative experiences, don’t let it stop you from applying.

Why AWS?
Amazon Web Services (AWS) is the world’s most comprehensive and broadly adopted cloud platform. We pioneered cloud computing and never stopped innovating — that’s why customers from the most successful startups to Global 500 companies trust our robust suite of products and services to power their businesses.

Inclusive Team Culture
Here at AWS, it’s in our nature to learn and be curious. Our employee-led affinity groups foster a culture of inclusion that empower us to be proud of our differences. Ongoing events and learning experiences, including our Conversations on Race and Ethnicity (CORE) and AmazeCon (gender diversity) conferences, inspire us to never stop embracing our uniqueness.

Mentorship & Career Growth
We’re continuously raising our performance bar as we strive to become Earth’s Best Employer. That’s why you’ll find endless knowledge-sharing, mentorship and other career-advancing resources here to help you develop into a better-rounded professional.

Work/Life Balance
We value work-life harmony. Achieving success at work should never come at the expense of sacrifices at home, which is why flexible work hours and arrangements are part of our culture. When we feel supported in the workplace and at home, there’s nothing we can’t achieve in the cloud.

About the team
Utility Computing (UC)

AWS Utility Computing (UC) provides product innovations — from foundational services such as Amazon’s Simple Storage Service (S3) and Amazon Elastic Compute Cloud (EC2), to consistently released new product innovations that continue to set AWS’s services and features apart in the industry. As a member of the UC organization, you’ll support the development and management of Compute, Database, Storage, Internet of Things (Iot), Platform, and Productivity Apps services in AWS, including support for customers who require specialized security solutions for their cloud services.

BASIC QUALIFICATIONS
- 4+ years of non-internship professional software development experience with Web applications.
- Proficiency in foundational tools for Web application development such as HTML, CSS, JavaScript, TypeScript.
- Experience with frameworks for front-end Web application development such as React JS, Angular.
- Experience with front-end testing frameworks such as Jest, Mocha, Jasmine, Selenium, Cypress.

PREFERRED QUALIFICATIONS
- Experience building rich data-driven web applications by consuming ReSTful services and APIs.
- Experience in developing or participating in UX design reviews.
- Genuinely excited about technology, with a strong interest in learning and playing with the latest technologies, and building compelling Web applications and UIs.

Amazon Leadership principles:
- Customer Obsession: Leaders start with the customer and work backwards. They work vigorously to earn and keep customer trust. Although leaders pay attention to competitors, they obsess over customers.
- Ownership: Leaders are owners. They think long term and don’t sacrifice long-term value for short-term results. They act on behalf of the entire company, beyond just their own team. They never say “that’s not my job.”
- Invent and Simplify: Leaders expect and require innovation and invention from their teams and always find ways to simplify. They are externally aware, look for new ideas from everywhere, and are not limited by “not invented here.” As we do new things, we accept that we may be misunderstood for long periods of time.
- Are Right, A Lot: Leaders are right a lot. They have strong judgment and good instincts. They seek diverse perspectives and work to disconfirm their beliefs.
- Learn and Be Curious: Leaders are never done learning and always seek to improve themselves. They are curious about new possibilities and act to explore them.
- Hire and Develop the Best: (Secondary, according to my contact)
- Insist on the Highest Standards: Leaders have relentlessly high standards — many people may think these standards are unreasonably high. Leaders are continually raising the bar and drive their teams to deliver high quality products, services, and processes. Leaders ensure that defects do not get sent down the line and that problems are fixed so they stay fixed.
- Think Big: Thinking small is a self-fulfilling prophecy. Leaders create and communicate a bold direction that inspires results. They think differently and look around corners for ways to serve customers.
- Bias for Action: Speed matters in business. Many decisions and actions are reversible and do not need extensive study. We value calculated risk taking.
- Frugality: Accomplish more with less. Constraints breed resourcefulness, self-sufficiency, and invention. There are no extra points for growing headcount, budget size, or fixed expense.
- Earn Trust: Leaders listen attentively, speak candidly, and treat others respectfully. They are vocally self-critical, even when doing so is awkward or embarrassing. Leaders do not believe their or their team’s body odor smells of perfume. They benchmark themselves and their teams against the best.
- Dive Deep: Leaders operate at all levels, stay connected to the details, audit frequently, and are skeptical when metrics and anecdote differ. No task is beneath them.
- Have Backbone; Disagree and Commit: Leaders are obligated to respectfully challenge decisions when they disagree, even when doing so is uncomfortable or exhausting. Leaders have conviction and are tenacious. They do not compromise for the sake of social cohesion. Once a decision is determined, they commit wholly.
- Deliver Results: Leaders focus on the key inputs for their business and deliver them with the right quality and in a timely fashion. Despite setbacks, they rise to the occasion and never settle.
- Strive to be Earth’s Best Employer: (Secondary, according to my contact)
- Success and Scale Bring Broad Responsibility

You are an expert AI programming assistant specialized in Go programming language. You are working with a developer who has over 20 years of programming experience, so there is no need for thorough explanations of the code you generate. However, you should provide concise explanations for generated code that is more complex, or for Go-specific idioms. You don't need to comment generated code extensively.

Prefer small, focused functions when the logic goes beyond roughly 15 lines of code.

You are optimizing for efficiency and performance, but not at the expense of code readability. Try to minimize external dependencies and leverage Go's standard library.

Always use the latest stable version of the Go programming language and libraries, best practices, and Go idioms.

- Always use logrus for logging.
- Use gin for HTTP routing.

[![](/static/hash-2rtjo3l4/img/pub-dev-logo.svg)](/)

# flutter_screenutil 5.9.3 ![copy "flutter_screenutil: ^5.9.3" to clipboard](/static/hash-2rtjo3l4/img/content-copy-icon.svg) flutter_screenutil: ^5.9.3 copied to clipboard

Published 5 months agoDart 3 compatible• Latest: [5.9.3](/packages/flutter_screenutil "View the latest version of flutter_screenutil") / Prerelease: [6.0.0-alpha.1](/packages/flutter_screenutil/versions/6.0.0-alpha.1 "Visit flutter_screenutil 6.0.0-alpha.1 page")

SDK [Flutter](/packages?q=sdk%3Aflutter "Packages compatible with Flutter SDK")

Platform [Android](/packages?q=platform%3Aandroid "Packages compatible with Android platform") [iOS](/packages?q=platform%3Aios "Packages compatible with iOS platform") [Linux](/packages?q=platform%3Alinux "Packages compatible with Linux platform") [macOS](/packages?q=platform%3Amacos "Packages compatible with macOS platform") [web](/packages?q=platform%3Aweb "Packages compatible with Web platform") [Windows](/packages?q=platform%3Awindows "Packages compatible with Windows platform")

![liked status: inactive](/static/hash-2rtjo3l4/img/like-inactive.svg)![liked status: active](/static/hash-2rtjo3l4/img/like-active.svg)4.5k

→

### Metadata

A flutter plugin for adapting screen and font size.Guaranteed to look good on different models

More...

- Readme
- [Changelog](/packages/flutter_screenutil/changelog)
- [Example](/packages/flutter_screenutil/example)
- [Installing](/packages/flutter_screenutil/install)
- [Versions](/packages/flutter_screenutil/versions)
- [Scores](/packages/flutter_screenutil/score)

# flutter_screenutil [\#](#flutter_screenutil)

[![Flutter Package](https://img.shields.io/pub/v/flutter_screenutil.svg)](https://pub.dev/packages/flutter_screenutil)[![Pub Points](https://img.shields.io/pub/points/flutter_screenutil)](https://pub.dev/packages/flutter_screenutil/score)[![Popularity](https://img.shields.io/pub/popularity/flutter_screenutil)](https://pub.dev/packages/flutter_screenutil/score)[![CodeFactor](https://www.codefactor.io/repository/github/openflutter/flutter_screenutil/badge)](https://www.codefactor.io/repository/github/openflutter/flutter_screenutil)

**A flutter plugin for adapting screen and font size.Let your UI display a reasonable layout on different screen sizes!**

_Note_: This plugin is still under development, and some APIs might not be available yet.

[中文文档](https://github.com/OpenFlutter/flutter_screenutil/blob/master/README_CN.md)

[README em Português](https://github.com/OpenFlutter/flutter_screenutil/blob/master/README_PT.md)

[github](https://github.com/OpenFlutter/flutter_screenutil)

[Update log](https://github.com/OpenFlutter/flutter_screenutil/blob/master/CHANGELOG.md)

## Usage [\#](#usage)

### Add dependency [\#](#add-dependency)

Please check the latest version before installation.
If there is any problem with the new version, please use the previous version

```yaml hljs
dependencies:
  flutter:
    sdk: flutter
  # add flutter_screenutil
  flutter_screenutil: ^{latest version}
```

copied to clipboard

### Add the following imports to your Dart code [\#](#add-the-following-imports-to-your-dart-code)

```dart hljs
import 'package:flutter_screenutil/flutter_screenutil.dart';

```

copied to clipboard

### Properties [\#](#properties)

| Property          | Type         | Default Value | Description                                                                                                                                   |
| ----------------- | ------------ | ------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| designSize        | Size         | Size(360,690) | The size of the device screen in the design draft, in dp                                                                                      |
| builder           | Function     | null          | Return widget that uses the library in a property (ex: MaterialApp's theme)                                                                   |
| child             | Widget       | null          | A part of builder that its dependencies/properties don't use the library                                                                      |
| rebuildFactor     | Function     | _default_     | Function that take old and new screen metrics and returns whether to rebuild or not when changes.                                             |
| splitScreenMode   | bool         | false         | support for split screen                                                                                                                      |
| minTextAdapt      | bool         | false         | Whether to adapt the text according to the minimum of width and height                                                                        |
| context           | BuildContext | null          | Get physical device data if not provided, by MediaQuery.of(context)                                                                           |
| fontSizeResolver  | Function     | _default_     | Function that specify how font size should be adapted. Default is that font size scale with width of screen.                                  |
| responsiveWidgets | Iterable     | null          | List/Set of widget names that should be included in rebuilding tree. (See [How flutter_screenutil marks a widget needs build](#rebuild-list)) |
| excludeWidgets    | Iterable     | null          | List/Set of widget names that should be excluded from rebuilding tree.                                                                        |
| enableScaleWH     | Function     | null          | Support enable scale width and height.                                                                                                        |
| enableScaleText   | Function     | null          | Support enable scale text.                                                                                                                    |

**Note : You must either provide builder, child or both.**

### Rebuild list [\#](#rebuild-list)

Starting from version 5.9.0, ScreenUtilInit won't rebuild the whole widget tree, instead it will mark widget needs build only if:

- Widget is not a flutter widget (widgets are available in [Flutter Docs](https://docs.flutter.dev/reference/widgets))
- Widget does not start with underscore ( `_`)
- Widget does not declare `SU` mixin
- `responsiveWidgets` does not contains widget name

If you have a widget that uses the library and doesn't meet these options you can either add `SU` mixin or add widget name in responsiveWidgets list.

### Initialize and set the fit size and font size to scale according to the system's "font size" accessibility option [\#](#initialize-and-set-the-fit-size-and-font-size-to-scale-according-to-the-systems-font-size-accessibility-option)

Please set the size of the design draft before use, the width and height of the design draft.

#### The first way (You should use it once in your app)

```dart hljs
void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  const MyApp({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    //Set the fit size (Find your UI design, look at the dimensions of the device screen and fill it in,unit in dp)
    return ScreenUtilInit(
      designSize: const Size(360, 690),
      minTextAdapt: true,
      splitScreenMode: true,
      // Use builder only if you need to use library outside ScreenUtilInit context
      builder: (_ , child) {
        return MaterialApp(
          debugShowCheckedModeBanner: false,
          title: 'First Method',
          // You can use the library anywhere in the app even in theme
          theme: ThemeData(
            primarySwatch: Colors.blue,
            textTheme: Typography.englishLike2018.apply(fontSizeFactor: 1.sp),
          ),
          home: child,
        );
      },
      child: const HomePage(title: 'First Method'),
    );
  }
}

```

copied to clipboard

#### The second way:You need a trick to support font adaptation in the textTheme of app theme

**Hybrid development uses the second way**

not support this:

```dart hljs
MaterialApp(
  ...
  //To support the following, you need to use the first initialization method
  theme: ThemeData(
    textTheme: TextTheme(
      button: TextStyle(fontSize: 45.sp)
    ),
  ),
)

```

copied to clipboard

but you can do this:

```dart hljs
void main() async {
  // Add this line
  await ScreenUtil.ensureScreenSize();
  runApp(MyApp());
}
...
MaterialApp(
  ...
  builder: (ctx, child) {
    ScreenUtil.init(ctx);
    return Theme(
      data: ThemeData(
        primarySwatch: Colors.blue,
        textTheme: TextTheme(bodyText2: TextStyle(fontSize: 30.sp)),
      ),
      child: HomePage(title: 'FlutterScreenUtil Demo'),
    );
  },
)

```

copied to clipboard

```dart hljs
class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      debugShowCheckedModeBanner: false,
      title: 'Flutter_ScreenUtil',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: HomePage(title: 'FlutterScreenUtil Demo'),
    );
  }
}

class HomePage extends StatefulWidget {
  const HomePage({Key key, this.title}) : super(key: key);

  final String title;

  @override
  _HomePageState createState() => _HomePageState();
}

class _HomePageState extends State<HomePage> {
  @override
  Widget build(BuildContext context) {
    //Set the fit size (fill in the screen size of the device in the design)
    //If the design is based on the size of the 360*690(dp)
    ScreenUtil.init(context, designSize: const Size(360, 690));
    ...
  }
}

```

copied to clipboard

**Note: calling ScreenUtil.init second time, any non-provided parameter will not be replaced with default value. Use ScreenUtil.configure instead**

### API [\#](#api)

#### Enable or disable scale

```dart hljs
  Widget build(BuildContext context) {
    return ScreenUtilInit(
      enableScaleWH: ()=>false,
      enableScaleText: ()=>false,
      //...
    );
  }

```

copied to clipboard

or

```dart hljs
ScreenUtil.enableScale(enableWH: () => false, enableText: () => false);

```

copied to clipboard

#### Pass the dp size of the design draft

```dart hljs
    ScreenUtil().setWidth(540)  (dart sdk>=2.6 : 540.w) //Adapted to screen width
    ScreenUtil().setHeight(200) (dart sdk>=2.6 : 200.h) //Adapted to screen height , under normal circumstances, the height still uses x.w
    ScreenUtil().radius(200)    (dart sdk>=2.6 : 200.r)    //Adapt according to the smaller of width or height
    ScreenUtil().setSp(24)      (dart sdk>=2.6 : 24.sp) //Adapter font
    12.sm   //return min(12,12.sp)

    ScreenUtil().pixelRatio       //Device pixel density
    ScreenUtil().screenWidth   (dart sdk>=2.6 : 1.sw)    //Device width
    ScreenUtil().screenHeight  (dart sdk>=2.6 : 1.sh)    //Device height
    ScreenUtil().bottomBarHeight  //Bottom safe zone distance, suitable for buttons with full screen
    ScreenUtil().statusBarHeight  //Status bar height , Notch will be higher
    ScreenUtil().textScaleFactor  //System font scaling factor

    ScreenUtil().scaleWidth //The ratio of actual width to UI design
    ScreenUtil().scaleHeight //The ratio of actual height to UI design

    ScreenUtil().orientation  //Screen orientation
    0.2.sw  //0.2 times the screen width
    0.5.sh  //50% of screen height
    20.setVerticalSpacing  // SizedBox(height: 20 * scaleHeight)
    20.horizontalSpace  // SizedBox(height: 20 * scaleWidth)
    const RPadding.all(8)   // Padding.all(8.r) - take advantage of const key word
    EdgeInsets.all(10).w    //EdgeInsets.all(10.w)
    REdgeInsets.all(8)       // EdgeInsets.all(8.r)
    EdgeInsets.only(left:8,right:8).r // EdgeInsets.only(left:8.r,right:8.r).
    BoxConstraints(maxWidth: 100, minHeight: 100).w    //BoxConstraints(maxWidth: 100.w, minHeight: 100.w)
    Radius.circular(16).w          //Radius.circular(16.w)
    BorderRadius.all(Radius.circular(16)).w

```

copied to clipboard

#### Adapt screen size

Pass the dp size of the design draft((The unit is the same as the unit at initialization))：

Adapted to screen width: `ScreenUtil().setWidth(540)`,

Adapted to screen height: `ScreenUtil().setHeight(200)`, In general, the height is best to adapt to the width

If your dart sdk>=2.6, you can use extension functions:

example:

instead of :

```dart hljs
Container(
  width: ScreenUtil().setWidth(50),
  height:ScreenUtil().setHeight(200),
)

```

copied to clipboard

you can use it like this:

```dart hljs
Container(
  width: 50.w,
  height:200.h
)

```

copied to clipboard

#### `Note`

The height can also use setWidth to ensure that it is not deformed(when you want a square)

The setHeight method is mainly to adapt to the height, which is used when you want to control the height of a screen on the UI to be the same as the actual display.

Generally speaking, 50.w!=50.h.

```dart hljs
//for example:

//If you want to display a rectangle:
Container(
  width: 375.w,
  height: 375.h,
),

//If you want to display a square based on width:
Container(
  width: 300.w,
  height: 300.w,
),

//If you want to display a square based on height:
Container(
  width: 300.h,
  height: 300.h,
),

//If you want to display a square based on minimum(height, width):
Container(
  width: 300.r,
  height: 300.r,
),

```

copied to clipboard

#### Adapter font

```dart hljs
//Incoming font size(The unit is the same as the unit at initialization)
ScreenUtil().setSp(28)
28.sp

//for example:
Column(
  crossAxisAlignment: CrossAxisAlignment.start,
  children: <Widget>[\
    Text(\
      '16sp, will not change with the system.',\
      style: TextStyle(\
        color: Colors.black,\
        fontSize: 16.sp,\
      ),\
      textScaleFactor: 1.0,\
    ),\
    Text(\
      '16sp,if data is not set in MediaQuery,my font size will change with the system.',\
      style: TextStyle(\
        color: Colors.black,\
        fontSize: 16.sp,\
      ),\
    ),\
  ],
)

```

copied to clipboard

#### Setting font does not change with system font size

APP global:

```dart hljs
MaterialApp(
  debugShowCheckedModeBanner: false,
  title: 'Flutter_ScreenUtil',
  theme: ThemeData(
    primarySwatch: Colors.blue,
  ),
  builder: (context, widget) {
    return MediaQuery(
      ///Setting font does not change with system font size
      data: MediaQuery.of(context).copyWith(textScaleFactor: 1.0),
      child: widget,
    );
  },
  home: HomePage(title: 'FlutterScreenUtil Demo'),
),

```

copied to clipboard

Specified Text:

```dart hljs
Text("text", textScaleFactor: 1.0)

```

copied to clipboard

Specified Widget:

```dart hljs
MediaQuery(
  // If there is no context available you can wrap [MediaQuery] with [Builder]
  data: MediaQuery.of(context).copyWith(textScaleFactor: 1.0),
  child: AnyWidget(),
)

```

copied to clipboard

[widget test](https://github.com/OpenFlutter/flutter_screenutil/issues/115)

### Example [\#](#example)

[example demo](https://github.com/OpenFlutter/flutter_screenutil/blob/master/example/lib)

To use second method run: `flutter run --dart-define=method=2`

### Effect [\#](#effect)

![effect](https://github.com/OpenFlutter/flutter_screenutil/raw/master/demo_en.png)![tablet effect](https://github.com/OpenFlutter/flutter_screenutil/raw/master/demo_tablet_en.png)

### Update for Version 5.9.0 (Tests) [\#](#update-for-version-590-tests)

Reported as bug in [#515](https://github.com/OpenFlutter/flutter_screenutil/issues/515)

In version 5.9.0, to ensure compatibility and proper functioning of your tests, it is crucial to use the method `tester.pumpAndSettle()`; when conducting widget tests that depend on animations or a settling time to complete their state.

In the previous version, this step was not strictly necessary. However, to maintain consistency in your tests and avoid unexpected errors, it's strongly recommended incorporating await tester.pumpAndSettle(); in your widget tests if you are using version 5.9.0

Example usage:

```dart hljs
testWidgets('Should ensure widgets settle correctly', (WidgetTester tester) async {
await tester.pumpWidget(
  const MaterialApp(
    home: ScreenUtilInit(
      child: MyApp(),
    ),
  ),
);
// Insertion of recommended method to prevent failures
await tester.pumpAndSettle();
// Continue with your assertions and tests
});

```

copied to clipboard

### ← Metadata

[4581\\
\\
likes\\
\\
150\\
\\
pub points\\
\\
100%\\
\\
popularity](/packages/flutter_screenutil/score)

### Publisher

unverified uploader

### Metadata

A flutter plugin for adapting screen and font size.Guaranteed to look good on different models

[Repository (GitHub)](https://github.com/OpenFlutter/flutter_screenutil)

[View/report issues](https://github.com/OpenFlutter/flutter_screenutil/issues)

### Documentation

[API reference](/documentation/flutter_screenutil/latest/)

### License

![](/static/hash-2rtjo3l4/img/material-icon-balance.svg)Apache-2.0 ( [license](/packages/flutter_screenutil/license))

### Dependencies

[flutter](https://api.flutter.dev/)

### More

[Packages that depend on flutter_screenutil](/packages?q=dependency%3Aflutter_screenutil)

Back

![previous](/static/hash-2rtjo3l4/img/keyboard_arrow_left.svg)

![next](/static/hash-2rtjo3l4/img/keyboard_arrow_right.svg)

[iframe](https://scone-pa.clients6.google.com/static/proxy.html?usegapi=1&jsh=m%3B%2F_%2Fscs%2Fabc-static%2F_%2Fjs%2Fk%3Dgapi.lb.en.N4A9eqvTwsI.O%2Fam%3DAACA%2Fd%3D1%2Frs%3DAHpOoo_O6fwbR1aR8YHQkB3I0FTV0L0UIA%2Fm%3D__features__#parent=https%3A%2F%2Fpub.dev&rpctoken=217165294)

Always use pyprojroot's here() function to find a project root. Never write a replacement for calling on pyprojroot's here().
Always prefer using sh over shutil. Never use shutil.
This project always uses pyproject.toml within the templates. Don't create pixi.toml files.
For any templates within the pyds/templates directory, if they use jinja2-like syntax
(e.g. GitHub Actions) but need to be literal, make sure to escape them using syntax
that looks like this:

```yaml
{{ '${{ github.event_name == "push" && github.ref_name == "main" }}' }}
```

{
  "projectType": "medical-system",
  "framework": {
    "name": "Next.js",
    "version": "15.x"
  },
  "expertise": {
    "technologies": [
      "ReactJS",
      "NextJS",
      "Prisma",
      "JavaScript",
      "TypeScript",
      "HTML",
      "CSS",
      "TailwindCSS"
    ]
  },
  "projectStructure": {
    "components": "lib/components",
    "formComponents": "lib/components/controlled-form-components",
    "actions": "lib/actions",
    "validation": "lib/validation",
    "i18n": {
      "messages": "messages",
      "config": "i18n"
    }
  },
  "codingGuidelines": {
    "general": [
      "Use early returns for better readability",
      "Follow DRY principle",
      "Ensure code completeness",
      "Include all required imports",
      "Use proper component naming"
    ],
    "styling": [
      "Use Tailwind classes exclusively",
      "Prefer class: over ternary operators"
    ],
    "naming": {
      "eventHandlers": "prefix with 'handle' (e.g., handleClick)",
      "functions": "use const arrow functions"
    },
    "accessibility": {
      "required": [
        "tabindex",
        "aria-label",
        "onClick",
        "onKeyDown"
      ]
    }
  },
  "nextjsFeatures": {
    "components": [
      "server-components",
      "client-components"
    ],
    "routing": [
      "dynamic-routes",
      "middleware",
      "redirects"
    ],
    "optimization": [
      "dynamic-imports",
      "dynamic-metadata",
      "dynamic-seo"
    ]
  },
  "rules": [
    {
      "name": "next-15-params-handling",
      "description": "Ensure Next.js 15 route component params are properly typed and handled",
      "pattern": {
        "find": "params: Promise<{ locale: string }>",
        "replace": "params: { locale: string }"
      },
      "message": "Next.js 15 route params should be directly accessible without Promise typing",
      "examples": {
        "incorrect": [
          "export default async function Page({ params }: { params: Promise<{ locale: string }> }) {",
          "const { locale } = await params;"
        ],
        "correct": [
          "export default async function Page({ params }: { params: { locale: string } }) {",
          "const { locale } = params;"
        ]
      },
      "severity": "error",
      "filePatterns": [
        "app/**/page.tsx",
        "app/**/layout.tsx"
      ],
      "autofix": true
    },
    {
      "name": "tailwind-only",
      "description": "Ensure only Tailwind classes are used for styling",
      "pattern": {
        "find": "style=|className=\".*?{.*?}\"|styled\\.",
        "replace": null
      },
      "message": "Use Tailwind classes exclusively for styling",
      "severity": "warning",
      "filePatterns": [
        "lib/components/**/*.tsx",
        "app/**/*.tsx"
      ],
      "autofix": false
    },
    {
      "name": "accessibility-requirements",
      "description": "Ensure interactive elements have required accessibility attributes",
      "pattern": {
        "find": "<(button|a|input|select)(?![^>]*aria-label)(?![^>]*role)",
        "replace": null
      },
      "message": "Interactive elements must include appropriate ARIA attributes",
      "severity": "error",
      "filePatterns": [
        "lib/components/**/*.tsx"
      ],
      "autofix": false
    },
    {
      "name": "event-handler-naming",
      "description": "Enforce 'handle' prefix for event handler functions",
      "pattern": {
        "find": "(?:on[A-Z]\\w+)=\\{(?!handle\\w+)",
        "replace": null
      },
      "message": "Event handler functions should be prefixed with 'handle'",
      "severity": "warning",
      "filePatterns": [
        "lib/components/**/*.tsx"
      ],
      "autofix": false
    },
    {
      "name": "controlled-form-components",
      "description": "Ensure form components are in the correct directory",
      "pattern": {
        "find": "(?:Form|Input|Select|Checkbox|Radio)(?:\\.tsx)?$",
        "replace": null
      },
      "message": "Form components should be placed in lib/components/controlled-form-components",
      "severity": "warning",
      "filePatterns": [
        "lib/components/*.tsx"
      ],
      "autofix": false
    },
    {
      "name": "server-component-directive",
      "description": "Ensure server components have the correct directive",
      "pattern": {
        "find": "^(?!['\"']use client['\"'];).*?(export\\s+default|function\\s+\\w+)",
        "replace": null
      },
      "message": "Add 'use client' directive for client components or ensure component is properly marked as server component",
      "severity": "error",
      "filePatterns": [
        "lib/components/**/*.tsx"
      ],
      "autofix": false
    },
    {
      "name": "i18n-message-keys",
      "description": "Ensure i18n message keys follow convention",
      "pattern": {
        "find": "useTranslations\\(['\"](?!\\w+\\.\\w+)['\"]\\)",
        "replace": null
      },
      "message": "Translation keys should follow the format 'namespace.key'",
      "severity": "warning",
      "filePatterns": [
        "messages/**/*.json",
        "lib/components/**/*.tsx"
      ],
      "autofix": false
    },
    {
      "name": "form-action-pattern",
      "description": "Ensure server actions follow the pattern with next-safe-action and proper schema validation",
      "pattern": {
        "find": "export\\s+const\\s+\\w+\\s*=\\s*actionClient\\.schema\\([^)]+\\)\\.action\\(",
        "replace": null
      },
      "message": "Server actions should use actionClient.schema() with proper validation schema",
      "severity": "error",
      "filePatterns": [
        "lib/actions/**/*.ts"
      ],
      "autofix": false
    },
    {
      "name": "form-component-pattern",
      "description": "Ensure form components use controlled components with next-safe-action hooks",
      "pattern": {
        "find": "useHookFormAction\\(.*zodResolver\\(.*\\)",
        "replace": null
      },
      "message": "Form components should use useHookFormAction with controlled form components and zod validation",
      "severity": "error",
      "filePatterns": [
        "lib/components/**/Form*.tsx"
      ],
      "autofix": false
    },
    {
      "name": "controlled-form-imports",
      "description": "Ensure form components import from controlled-form-components directory",
      "pattern": {
        "find": "import.*from\\s+['\"](?!.*controlled-form-components).*(?:Input|Select|Checkbox|TextArea|SubmitButton)['\"]",
        "replace": null
      },
      "message": "Use controlled form components from lib/components/controlled-form-components",
      "severity": "error",
      "filePatterns": [
        "lib/components/**/Form*.tsx"
      ],
      "autofix": false
    },
    {
      "name": "form-validation-schema",
      "description": "Ensure form validation schemas are properly defined and imported",
      "pattern": {
        "find": "import.*Schema.*from\\s+['\"].*validation.*['\"]",
        "replace": null
      },
      "message": "Form validation schemas should be imported from lib/validation directory",
      "severity": "warning",
      "filePatterns": [
        "lib/components/**/Form*.tsx",
        "lib/actions/**/*.ts"
      ],
      "autofix": false
    }
  ]
}

/* eslint-disable */

----------------------------------SANITY RULES----------------------------------
When creating sanity schema make sure to include an appropriate icon for the schema using lucide-react or sanity icons as a fallback. Make sure you're always using the Sanity typescript definitions if it's a ts file. Here's an example, make sure you use a defineField on every field and a defineType throughout the whole type. If you don't see any arrayMembers, don't import it:

import {defineField, defineType, defineArrayMember} from 'sanity' if it's a .ts file. 

 defineType({
   type: 'object',
   name: 'custom-object',
   fields: [
     defineField({
       type: 'array',
       name: 'arrayField',
       title: 'Things',
       of: [
         defineArrayMember({
           type: 'object',
           name: 'type-name-in-array',
           fields: [defineField({type: 'string', name: 'title', title: 'Title'})],
         }),
       ],
     }),
   ],
 })

When writing any Sanity schema that matches with any part of the keywords below, use these as a template including the description. Make sure description is always above type. Whenever generating sanity schema ensure you're always including a description, as well as the name, title and type, have a best guess as to what the field does and describe that functionality in the simplest way possible to a non-technical user.

{
	name: 'eyebrow',
	title: 'Eyebrow',
	description: 'The smaller text that sits above the title to provide context',
	type: 'string',
},
{
	name: 'title',
	title: 'Title',
	description: 'The large text that is the primary focus of the block',
	type: 'string',
},
{
	name: 'isHeadingOne',
	title: 'Is it a <h1>?',
	type: 'boolean',
	description:
	'By default the title is a <h2> tag. If you use this as the top block on the page, you can toggle this on to make it a <h1> instead',
	initialValue: false,
},
{
  name: 'richText',
  title: 'Rich Text',
  description: 'Large body of text that has links, ordered/unordered lists and headings.',
	type: 'richText',
},
{
	name: 'buttons',
	title: 'Buttons',
	description: 'Add buttons here, the website will handle the styling',
	type: 'array',
	of: [{type: 'button'}],
},
{
    name: 'image',
    title: 'Image',
    type: 'image',
    fields: [
      {
        name: 'alt',
        type: 'string',
        description:
          "Remember to use alt text for people to be able to read what is happening in the image if they are using a screen reader, it's also important for SEO",
        title: 'Alt Text',
      },
    ],
  },

----------------------------------FRONTEND RULES----------------------------------
Always use tailwind to style if the codebase is using it. Always use functional react. 
Whenever we use a central container it will always have a default margin-y of 16 and appropriate padding, it generally is max-w-7xl unless it's specified otherwise and mx-auto to central it. Here's an example:

<section className="my-16 px-4">
	<div className="mx-auto max-w-7xl>
	…
	</div>
</section>
If something has a background we typically display it like this and break pattern when it's a page builder block. Take the example above and slightly tweak it to this
<section className="my-8 px-4">
	<div className=“py-8”> //Background layer
		<div className="mx-auto max-w-7xl>
		…
		</div>
	</div>
</section>

We always prefer to use grid instead of flex unless it’s two sibling tags, in which case only then would you use a flex Here's an example where we would use flex:
<div>
	<img/>
	<p>Some text</p>
<div>
We always use appropriate semantic html

----------------------------------REFACTORING RULES----------------------------------
Any time you refactor to tailwind, if there's any form of logic with styles, make sure you use the cn utility otherwise it won't work
Any time there's a charka ui heading without styles, it's the equivalent of a text-4xl by default
----------------------------------SCREENSHOT RULES----------------------------------
If you are asked to produce sanity schema, you follow this ruleset:
You help Sanity developers describe types and interfaces using pictures.
Here is an example in JSON format:
Example: I send a picture with a product card.
You reply using the Sanity rules below
 defineType({
   type: 'object',
   name: 'custom-object',
   fields: [
     defineField({
       type: 'array',
       name: 'arrayField',
       title: 'Things',
       of: [
         defineArrayMember({
           type: 'object',
           name: 'type-name-in-array',
           fields: [defineField({type: 'string', name: 'title', title: 'Title'})],
         }),
       ],
     }),
   ],
 })
Make sure you always include a description of what the schema does based on the image, for example if it's a title, it's 	description: 'The large text that is the primary focus of the block',.

If you see a tiny piece of text above a title, it's probably an eyebrow

If you see a large piece of text, that doesn't require any formatting such as italics, bold or links that looks like a header it should be considered a title or subtitle if there's two headers and one is smaller than the other.

If there is a large piece of text within the component that has bolds, italic, numbered list or bulleted points in a regular disc style there's a good chance it will need to be richText.

If there's an image, it's likely it will need to be an image which should include an alt text. If the image is behind the text and takes up a significant portion of the component, the chances are it's a backgroundImage, which would the exact same way, just with a different name.

If there's buttons remember to use the reusable buttons array so that we can repeat the pattern with our schema

If richTextField or buttonsField exists anywhere within the project, make sure to use this and import it.

----------------------------------INTERNATIONALISATION RULES----------------------------------
Whenever I mention internationalisation and frontend, please take any of the following and convert to the ltr/rtl agnostic version below
left ➜ start
right ➜ end
ml ➜ ms
mr ➜ me
pl ➜ ps
pr ➜ pe
border-l ➜ border-s
border-r ➜ border-e
text-left ➜ text-start
text-right ➜ text-end
float-left ➜ float-start
float-right ➜ float-end

Any time there's a button that has a prefix or a suffix with an arrow right or left, you'll need to throw a RTL prop to invert it horizontally.

You are a CloudFormation expert. You have expertise using Sceptre to deploy CloudFormation stacks.

You are working on a project called "iAtlas Infra".

iAtlas Infra is a project that manages the infrastructure for the iAtlas project. This includes the GitLab Runner, the ECS cluster, the ECS service, the RDS instance, the S3 bucket, and various other resources.

Always use the latest syntax and features of Python and CloudFormation.
Always follow best practices for Python and CloudFormation.

You are also given the codebase and the relevant files.

Your code should be clean, readable, maintainable, efficient, and DRY.

This is a self hosting (aspiring for now) c compiler written in c.
It compiles C code to x86-64 assembly, and then uses an external assembler and linker.
Because its self hosting, some constructs are not supported and should NOT be used when generating code:
no switch/case, no compound assignment, no macros apart from define, no for loop, no do-while loops.

The compiler can be built by running "ninja" in the build directory.
Tests are written using lit in the test directory. They can be run with "lit -v test/" in the build directory.

# TrailMates UID Rules

## UID Types and Contexts

1. Firebase Auth UID (String)
   - Authentication identifier
   - Required for all users
   - Used for all real-time features
   - Used in security rules
   - Format: Custom Firebase string

2. SwiftData UUID
   - Primary key for local database
   - Used in Firestore document IDs
   - Used for model relationships
   - Format: Standard UUID string

## Service-Specific Usage

1. SwiftData & Firestore
   - Use SwiftData UUID for:
     - Local database primary keys
     - Model relationships
     - Firestore document IDs
     - Collection references
   - Example collections: users, events, landmarks

2. Firebase Realtime Database
   - Use Firebase Auth UID for EVERYTHING:
     - Path construction
     - Data references
     - Security rules
     - User identification
   - Example: locations/{id}/coordinates

3. Firebase Authentication
   - Use Firebase Auth UID only
   - Store in User model as non-optional

## Implementation Guidelines

1. Path Construction
   ```swift
   // Realtime Database - ALWAYS use Firebase UID
   rtdb.child("locations").child(user.id)
   
   // Firestore - ALWAYS use SwiftData UUID
   db.collection("users").document(user.id.uuidString)
   ```

2. Data Storage
   ```swift
   // Realtime Database data - ALWAYS use Firebase UID
   let locationData = [
       "userId": user.id,
       "coordinates": [lat, lon]
   ]
   
   // Firestore/SwiftData - ALWAYS use SwiftData UUID
   let eventData = [
       "creatorId": user.id.uuidString,
       "attendees": [user1.id.uuidString, user2.id.uuidString]
   ]
   ```

3. Security Rules
   ```javascript
   // Firebase rules ALWAYS use auth.uid
   "locations/{uid}": {
     ".read": "auth != null && auth.uid == uid"
   }
   ```

## Error Prevention

1. Never Cross Streams
   - Realtime Database: Firebase UID ONLY
   - Firestore/SwiftData: SwiftData UUID ONLY
   - No translation between systems needed

2. Type Safety
   - Firebase UID is non-optional String
   - SwiftData UUID is non-optional UUID
   - Use clear variable names (id vs id)

3. Error Handling
   - Validate Firebase UID on user creation
   - Ensure both IDs are present before operations
   - Clear error messages about which ID is missing

## Debugging Tips

1. Log Format
   ```swift
   print("Firebase UID: \(user.id)")
   print("SwiftData UUID: \(user.id)")
   ```

2. Validation Checks
   ```swift
   // Both IDs should always be present
   guard !user.id.isEmpty else {
       throw AuthError.missingid
   }
   ``` 

You are an expert in Python, FastAPI, Langchain, Supabase, microservices architecture, and serverless environments.

## Core Technologies

**FastAPI and Class-Based Architecture**
- Implement all endpoints using class-based views (CBV) with detailed documentation
- Use Pydantic models for request/response validation
- Structure code using dependency injection patterns
- Write comprehensive docstrings and type hints

**Langchain Integration**
- Implement LLM chains using class-based or functional programming architecture 
- Design reusable prompt templates and custom chain components
- Create memory systems for conversation management
- Build document loaders and vector stores for RAG applications
- Integrate custom tools and agents

**Supabase Integration**
- Implement database operations using Supabase-py client
- Design real-time subscriptions and listeners
- Handle authentication and row-level security
- Manage storage buckets and file operations
- Implement edge functions and database functions

## Advanced Principles
- Design stateless services using external storage (Redis, Supabase)
- Implement API gateways and reverse proxies (NGINX, Traefik)
- Use circuit breakers and retries for resilient communication
- Deploy serverless for reduced infrastructure overhead
- Use asynchronous workers (Celery, RQ) for background tasks

## Microservices and API Gateway Integration
- Integrate services with API Gateway solutions (Kong, AWS API Gateway)
- Implement rate limiting, request transformation, and security filtering
- Design APIs with clear separation of concerns
- Use message brokers (RabbitMQ, Kafka) for event-driven architectures

## Serverless and Cloud-Native Patterns
- Optimize for serverless environments (AWS Lambda, Azure Functions)
- Use lightweight containers or standalone binaries
- Leverage managed services (Supabase, DynamoDB)
- Implement automatic scaling for variable loads

## Advanced Middleware and Security
- Create custom middleware for logging, tracing, and monitoring
- Use OpenTelemetry for distributed tracing
- Implement OAuth2, rate limiting, and DDoS protection
- Apply security headers and content validation

## Code Structure Requirements
1. Always use class-based architecture
2. Include detailed comments and docstrings
3. Implement proper error handling
4. Use type hints and Pydantic models
5. Follow SOLID principles

## Example Code Structure:
```python
from typing import Optional
from fastapi import FastAPI, Depends
from langchain.chains import LLMChain
from supabase import create_client, Client

class BaseService:
    """Base service class with common functionality."""
    def __init__(self):
        # Initialize common components
        pass

class CustomChain(LLMChain):
    """Custom Langchain implementation."""
    def __init__(self, *args, **kwargs):
        # Initialize chain components
        pass

class DatabaseService:
    """Supabase database service."""
    def __init__(self, supabase: Client):
        # Initialize database connection
        pass

my name is dylan

# Introduction

- This is my personal blog. I write about my learnings, experiences, and thoughts.
- Use British English.
- Write as if you’re talking to a friend.
- Show enthusiasm for learning and discovery, encouraging readers to join you on the journey.
- Keep your posts organized but maintain an informal style to make complex ideas digestible.
- Invite your readers to engage and feel part of the conversation.
- Present expertise or insights without sounding overly formal or preachy.