التعدادات في TypeScript

enum Direction {
    Up,      // 0
    Down,    // 1
    Left,    // 2
    Right    // 3
}

let playerDirection: Direction = Direction.Up;
console.log(playerDirection);  // 0

// الاستخدام في الشروط
if (playerDirection === Direction.Up) {
    console.log("Moving up!");
}

// التعدادات ثنائية الاتجاه - يمكنك الحصول على الاسم من القيمة
let directionName = Direction[0];  // "Up"
console.log(directionName);

enum HttpStatus {
    OK = 200,
    Created = 201,
    Accepted = 202,
    BadRequest = 400,
    Unauthorized = 401,
    Forbidden = 403,
    NotFound = 404,
    InternalServerError = 500
}

function handleResponse(status: HttpStatus) {
    switch (status) {
        case HttpStatus.OK:
            console.log("Success!");
            break;
        case HttpStatus.NotFound:
            console.log("Resource not found");
            break;
        case HttpStatus.InternalServerError:
            console.log("Server error");
            break;
    }
}

handleResponse(HttpStatus.OK);  // "Success!"

enum Level {
    Easy = 1,     // 1
    Medium,       // 2 (زيادة تلقائية)
    Hard,         // 3 (زيادة تلقائية)
    Expert = 10,  // 10
    Master        // 11 (زيادة تلقائية)
}

console.log(Level.Easy);    // 1
console.log(Level.Medium);  // 2
console.log(Level.Expert);  // 10
console.log(Level.Master);  // 11

enum FileAccess {
    None = 0,
    Read = 1 << 0,     // 1
    Write = 1 << 1,    // 2
    ReadWrite = Read | Write,  // 3
    Execute = 1 << 2   // 4
}

// فحص الأذونات باستخدام العمليات البتية
function hasPermission(access: FileAccess, permission: FileAccess): boolean {
    return (access & permission) === permission;
}

let myAccess = FileAccess.ReadWrite;
console.log(hasPermission(myAccess, FileAccess.Read));   // true
console.log(hasPermission(myAccess, FileAccess.Write));  // true
console.log(hasPermission(myAccess, FileAccess.Execute)); // false

enum Color {
    Red = "RED",
    Green = "GREEN",
    Blue = "BLUE"
}

let favoriteColor: Color = Color.Red;
console.log(favoriteColor);  // "RED"

// التعدادات النصية أكثر قابلية للقراءة في وقت التشغيل
function setTheme(color: Color) {
    console.log(`Setting theme to ${color}`);
}

setTheme(Color.Blue);  // "Setting theme to BLUE"

// التعدادات النصية ليست ثنائية الاتجاه
// Color["RED"]  // Error: Element implicitly has an 'any' type

// نقاط نهاية API
enum ApiRoute {
    Users = "/api/users",
    Posts = "/api/posts",
    Comments = "/api/comments",
    Auth = "/api/auth"
}

async function fetchData(route: ApiRoute) {
    const response = await fetch(route);
    return response.json();
}

fetchData(ApiRoute.Users);

// أسماء الأحداث
enum EventType {
    Click = "click",
    MouseOver = "mouseover",
    KeyDown = "keydown",
    Submit = "submit"
}

document.addEventListener(EventType.Click, (e) => {
    console.log("Clicked!");
});

// أسماء جداول قاعدة البيانات
enum TableName {
    Users = "users",
    Products = "products",
    Orders = "orders",
    OrderItems = "order_items"
}

function selectFrom(table: TableName, columns: string[]) {
    return `SELECT ${columns.join(", ")} FROM ${table}`;
}

console.log(selectFrom(TableName.Users, ["id", "name", "email"]));

const enum Direction {
    Up,
    Down,
    Left,
    Right
}

let direction = Direction.Up;

// بعد التجميع، يصبح هذا:
// let direction = 0;  // التعداد اختفى، القيمة فقط تبقى

// الفوائد: لا كود وقت تشغيل، أداء أفضل
// العيب: لا يمكن استخدام التعيين العكسي (Direction[0] لا يعمل)

// تعداد عادي - ينتج كود وقت تشغيل
enum Status {
    Active,
    Inactive
}

// يُترجم إلى:
// var Status;
// (function (Status) {
//     Status[Status["Active"] = 0] = "Active";
//     Status[Status["Inactive"] = 1] = "Inactive";
// })(Status || (Status = {}));

// تعداد ثابت - لا كود وقت تشغيل
const enum Status {
    Active,
    Inactive
}

let status = Status.Active;
// يُترجم إلى:
// let status = 0; // القيمة فقط، لا كائن تعداد

enum Mixed {
    No = 0,
    Yes = "YES"
}

console.log(Mixed.No);   // 0
console.log(Mixed.Yes);  // "YES"

// التعيين العكسي يعمل فقط للقيم الرقمية
console.log(Mixed[0]);   // "No"
// Mixed["YES"]  // Error

enum ShapeKind {
    Circle,
    Square
}

// استخدام عضو التعداد كنوع
interface Circle {
    kind: ShapeKind.Circle;
    radius: number;
}

interface Square {
    kind: ShapeKind.Square;
    sideLength: number;
}

type Shape = Circle | Square;

function getArea(shape: Shape): number {
    switch (shape.kind) {
        case ShapeKind.Circle:
            return Math.PI * shape.radius ** 2;
        case ShapeKind.Square:
            return shape.sideLength ** 2;
    }
}

let circle: Circle = { kind: ShapeKind.Circle, radius: 10 };
console.log(getArea(circle));

enum Priority {
    Low,      // 0
    Medium,   // 1
    High      // 2
}

// التعيين الأمامي (الاسم إلى القيمة)
let value = Priority.High;  // 2

// التعيين العكسي (القيمة إلى الاسم)
let name = Priority[2];     // "High"

// التكرار على أسماء التعداد
for (let key in Priority) {
    if (isNaN(Number(key))) {
        console.log(key);  // "Low", "Medium", "High"
    }
}

// التكرار على قيم التعداد
for (let key in Priority) {
    if (!isNaN(Number(key))) {
        console.log(Priority[key]);  // "Low", "Medium", "High"
    }
}

enum Color {
    Red,
    Green,
    Blue
}

// يبدو كائن JavaScript المُولَّد مثل:
// {
//   0: "Red",
//   1: "Green",
//   2: "Blue",
//   Red: 0,
//   Green: 1,
//   Blue: 2
// }

// يمكنك فحص ما إذا كانت القيمة عضو تعداد صالح
function isValidColor(value: any): value is Color {
    return Object.values(Color).includes(value);
}

console.log(isValidColor(Color.Red));   // true
console.log(isValidColor(0));           // true
console.log(isValidColor(5));           // false

// الحصول على جميع مفاتيح التعداد
const colorKeys = Object.keys(Color).filter(k => isNaN(Number(k)));
console.log(colorKeys);  // ["Red", "Green", "Blue"]

// الحصول على جميع قيم التعداد (أرقام)
const colorValues = Object.keys(Color).filter(k => !isNaN(Number(k))).map(Number);
console.log(colorValues);  // [0, 1, 2]

// استخدام التعداد
enum Status {
    Active = "ACTIVE",
    Inactive = "INACTIVE",
    Pending = "PENDING"
}

function setStatus(status: Status) {
    console.log(status);
}

// استخدام نوع الاتحاد
type Status = "ACTIVE" | "INACTIVE" | "PENDING";

function setStatus(status: Status) {
    console.log(status);
}

// كلا النهجين يعملان، لكن لهما خصائص مختلفة

enum ErrorCode {
    Success = 0,
    InvalidInput = 1001,
    DatabaseError = 2001,
    NetworkError = 3001,
    Unauthorized = 4001,
    NotFound = 4004
}

class Result<T> {
    constructor(
        public code: ErrorCode,
        public data?: T,
        public message?: string
    ) {}

    isSuccess(): boolean {
        return this.code === ErrorCode.Success;
    }
}

function fetchUser(id: number): Result<User> {
    if (id < 0) {
        return new Result(ErrorCode.InvalidInput, undefined, "Invalid user ID");
    }
    // ... منطق الجلب
    return new Result(ErrorCode.Success, userData);
}

enum OrderState {
    Created,
    PaymentPending,
    PaymentConfirmed,
    Processing,
    Shipped,
    Delivered,
    Cancelled
}

class Order {
    private state: OrderState = OrderState.Created;

    confirmPayment() {
        if (this.state === OrderState.PaymentPending) {
            this.state = OrderState.PaymentConfirmed;
        } else {
            throw new Error("Invalid state transition");
        }
    }

    ship() {
        if (this.state === OrderState.Processing) {
            this.state = OrderState.Shipped;
        } else {
            throw new Error("Cannot ship order in current state");
        }
    }

    getState(): OrderState {
        return this.state;
    }
}

enum Feature {
    DarkMode = 1 << 0,        // 1
    Notifications = 1 << 1,   // 2
    AdvancedSearch = 1 << 2,  // 4
    AdminPanel = 1 << 3       // 8
}

class User {
    private features: number = 0;

    enableFeature(feature: Feature) {
        this.features |= feature;
    }

    disableFeature(feature: Feature) {
        this.features &= ~feature;
    }

    hasFeature(feature: Feature): boolean {
        return (this.features & feature) === feature;
    }
}

let user = new User();
user.enableFeature(Feature.DarkMode);
user.enableFeature(Feature.Notifications);

console.log(user.hasFeature(Feature.DarkMode));       // true
console.log(user.hasFeature(Feature.AdvancedSearch)); // false